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>

namespace Rose {
class Stringifier {
    std::string(*stringifier_)(long int, const char*, bool);
public:
    Stringifier(std::string(*stringifier)(long int, const char*, bool)): stringifier_(stringifier) {}
    std::string operator()(long int 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/backend/asmUnparser/AsmUnparser.h line 251
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace AsmUnparser {
    const char* Organization(long);

    std::string Organization(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisAsmUnparserOrganization(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinarySerialIo.h line 116
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
    const char* Format(long);

    std::string Format(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSerialIoFormat(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinarySerialIo.h line 127
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
    const char* Savable(long);

    std::string Savable(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSerialIoSavable(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/AsmUnparser_compat.h line 44
namespace stringify {
    const char* ArmSignForExpressionUnparsing(long);

    std::string ArmSignForExpressionUnparsing(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyArmSignForExpressionUnparsing(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string AssociativitySpecifier(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyAssociativitySpecifier(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string token_sequence_position_enum_type(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 71
namespace stringify { namespace UnparseLanguageIndependentConstructs {
    const char* unparsed_as_enum_type(long);

    std::string unparsed_as_enum_type(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/unparser.h line 201
namespace stringify { namespace Unparser {
    const char* token_sequence_position_enum_type(long);

    std::string token_sequence_position_enum_type(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyUnparser_token_sequence_position_enum_type(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string Format_Opt(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyFormat_Opt(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/CxxCodeGeneration/unparseCxx.h line 522
namespace stringify { namespace Unparse_ExprStmt {
    const char* token_sequence_position_enum_type(long);

    std::string token_sequence_position_enum_type(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyUnparse_ExprStmt_token_sequence_position_enum_type(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string RelativePositionType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAstUnparseAttributeRelativePositionType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/POET/poet_yacc.h line 46
namespace stringify {
    const char* yytokentype(long);

    std::string yytokentype(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_yytokentype(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/MSTL/DOTGeneration.h line 45
namespace stringify { namespace DOTGeneration {
    const char* traversalType(long);

    std::string traversalType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyDOTGeneration_traversalType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QRButtons.h line 29
namespace stringify { namespace qrs { namespace QRButtons {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQRButtonsType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QRSelect.h line 26
namespace stringify { namespace qrs { namespace QRSelect {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQRSelectType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QREdit.h line 28
namespace stringify { namespace qrs { namespace QREdit {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQREditType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/qeditor.h line 65
namespace stringify { namespace qrs { namespace QEditor {
    const char* TypeSel(long);

    std::string TypeSel(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQEditorTypeSel(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/qsourcecolorizer.h line 257
namespace stringify { namespace qrs { namespace QSourceColorizer {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQSourceColorizerType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/parenmatcher.h line 37
namespace stringify { namespace qrs { namespace Paren {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsParenType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/parenmatcher.h line 48
namespace stringify { namespace qrs { namespace ParenMatcher {
    const char* Selection(long);

    std::string Selection(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsParenMatcherSelection(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/paragdata.h line 36
namespace stringify { namespace qrs { namespace Symbol {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsSymbolType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/QRSourceBox.h line 39
namespace stringify { namespace qrs { namespace QRSourceBox {
    const char* ToolbarIdx(long);

    std::string ToolbarIdx(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQRSourceBoxToolbarIdx(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 122
namespace stringify { namespace qrs { namespace Q3TextStringChar {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQ3TextStringCharType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 366
namespace stringify { namespace qrs { namespace Q3TextCursor {
    const char* Operation(long);

    std::string Operation(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQ3TextCursorOperation(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 390
namespace stringify { namespace qrs { namespace Q3TextCommand {
    const char* Commands(long);

    std::string Commands(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQ3TextCommandCommands(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 451
namespace stringify { namespace qrs { namespace Q3TextCustomItem {
    const char* Placement(long);

    std::string Placement(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQ3TextCustomItemPlacement(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 724
namespace stringify { namespace qrs { namespace Q3TextDocument {
    const char* SelectionIds(long);

    std::string SelectionIds(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQ3TextDocumentSelectionIds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1380
namespace stringify { namespace qrs { namespace Q3TextPreProcessor {
    const char* Ids(long);

    std::string Ids(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQ3TextPreProcessorIds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1400
namespace stringify { namespace qrs { namespace Q3TextFormat {
    const char* Flags(long);

    std::string Flags(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQ3TextFormatFlags(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1415
namespace stringify { namespace qrs { namespace Q3TextFormat {
    const char* VerticalAlignment(long);

    std::string VerticalAlignment(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQ3TextFormatVerticalAlignment(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/TreeBox/QRTreeBox.h line 40
namespace stringify { namespace qrs { namespace QRTreeBox {
    const char* ToolbarIdx(long);

    std::string ToolbarIdx(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQRTreeBoxToolbarIdx(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/TreeBox/QRTreeBox.h line 107
namespace stringify { namespace qrs { namespace QRTreeBox {
    const char* popmenu_nodes_id(long);

    std::string popmenu_nodes_id(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_qrsQRTreeBox_popmenu_nodes_id(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_EncodingType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_EncodingType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_BaseEncodings(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_BaseEncodings(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_FontDefType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_FontDefType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_StreamType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_StreamType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_WhenceMode(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_WhenceMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_FontType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_FontType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_InfoType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_InfoType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_PdfVer(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_PdfVer(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_EncryptMode(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_EncryptMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_ColorSpace(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_ColorSpace(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_LineCap(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_LineCap(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_LineJoin(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_LineJoin(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_TextRenderingMode(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_TextRenderingMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_WritingMode(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_WritingMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_PageLayout(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_PageLayout(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_PageMode(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_PageMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_PageNumStyle(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_PageNumStyle(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_DestinationType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_DestinationType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_AnnotType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_AnnotType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_AnnotFlgs(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_AnnotFlgs(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_AnnotHighlightMode(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_AnnotHighlightMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_AnnotIcon(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_AnnotIcon(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_BSSubtype(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_BSSubtype(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_BlendMode(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_BlendMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_TransitionStyle(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_TransitionStyle(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_PageSizes(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_PageSizes(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_PageDirection(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_PageDirection(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_EncoderType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_EncoderType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_ByteType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_ByteType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string _HPDF_TextAlignment(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_HPDF_TextAlignment(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/SgNodeHelper.h line 426
namespace stringify { namespace SgNodeHelper { namespace Pattern { namespace OutputTarget {
    const char* OType(long);

    std::string OType(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifySgNodeHelperPatternOutputTargetOType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/Labeler.h line 60
namespace stringify { namespace SPRAY { namespace LabelProperty {
    const char* LabelType(long);

    std::string LabelType(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySPRAY_LabelPropertyLabelType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/Labeler.h line 86
namespace stringify { namespace SPRAY { namespace LabelProperty {
    const char* IOType(long);

    std::string IOType(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySPRAY_LabelPropertyIOType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/MDCG/include/MDCG/Model/base.hpp line 24
namespace stringify { namespace MDCG { namespace Model {
    const char* model_elements_e(long);

    std::string model_elements_e(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyMDCG_Model_model_elements_e(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/MDCG/include/MDCG/Model/base.hpp line 46
namespace stringify { namespace MDCG { namespace Model { namespace element_t {
    const char* kind_e(long);

    std::string kind_e(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyMDCG_Model_element_t_kind_e(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TypeOfQueryTypeOneParameter(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeOneParameter(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TypeOfQueryTypeTwoParameters(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeTwoParameters(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TypeOfQueryType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyBooleanQueryTypeOfQueryType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/astQuery.h line 96
namespace stringify { namespace AstQueryNamespace {
    const char* QueryDepth(long);

    std::string QueryDepth(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAstQueryNamespaceQueryDepth(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TypeOfQueryTypeOneParameter(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyNumberQueryTypeOfQueryTypeOneParameter(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TypeOfQueryTypeTwoParameters(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyNumberQueryTypeOfQueryTypeTwoParameters(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TypeOfQueryTypeOneParameter(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyNodeQueryTypeOfQueryTypeOneParameter(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TypeOfQueryTypeTwoParameters(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyNodeQueryTypeOfQueryTypeTwoParameters(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string Index_type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyAbstractMemoryObjectIndexSetIndex_type(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/omp_lowering.h line 37
namespace stringify { namespace OmpSupport {
    const char* omp_rtl_enum(long);

    std::string omp_rtl_enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyOmpSupport_omp_rtl_enum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/xomp.c line 60
namespace stringify {
    const char* omp_rtl_enum(long);

    std::string omp_rtl_enum(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_omp_rtl_enum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string defaultEnumFunctionType(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_defaultEnumFunctionType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string InsertionMode(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyFunctionCallInfoInsertionMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string NodeType(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySDG_SDGNodeNodeType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string EdgeType(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySDG_SDGEdgeEdgeType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ControlDependenceType(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySDG_SDGEdgeControlDependenceType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string EdgeType(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySDG_PDGEdgeEdgeType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string COLOR(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyPtrAliasAnalysisCOLOR(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TRAVERSAL_TYPE(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyPtrAliasAnalysisTRAVERSAL_TYPE(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/IntraProcAliasAnalysis.h line 279
namespace stringify { namespace CollectAliasRelations {
    const char* COLOR(long);

    std::string COLOR(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyCollectAliasRelationsCOLOR(long int n, const char *strip=NULL, bool canonic=false);
}

// 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* TRAVERSAL_TYPE(long);

    std::string TRAVERSAL_TYPE(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyCollectAliasRelationsTRAVERSAL_TYPE(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string Dir_ection(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDir_ection(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string running_mode_enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyArithmeticIntensityMeasurement_running_mode_enum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string fp_operation_kind_enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string Type(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify_ssa_unfiltered_cfgReachingDefType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string Direction(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/cfgUtils/CallGraphTraverse.h line 121
namespace stringify { namespace CGFunction { namespace iterator {
    const char* direction(long);

    std::string direction(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyCGFunction_iterator_direction(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/simpleAnalyses/taintAnalysis.h line 60
namespace stringify { namespace TaintLattice {
    const char* Vertex(long);

    std::string Vertex(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyTaintLatticeVertex(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/lattice/ConstrGraph.h line 42
namespace stringify { namespace ConstrGraph {
    const char* levels(long);

    std::string levels(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyConstrGraph_levels(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string dirType(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyBaseGraphBiDirNodesIterator_dirType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string EdgeDirection(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyRIFG_EdgeDirection(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ForwardBackward(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyRIFG_ForwardBackward(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string EdgeType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyCFG_EdgeType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string RITarjType(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyRITarjType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string RITarjEdgeType(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyRITarjEdgeType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string IRProcType(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyIRProcType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string IRStmtType(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyIRStmtType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string EdgeType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyCallGraphEdgeType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string EditType(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyEditDistanceTreeEditDistanceEditType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string Type(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyReachingDefType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ScopeIdentifier_Enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string PlacementPosition_Enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsPlacementPosition_Enum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string IntermediateFileStringPosition_Enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ScopeIdentifier_Enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string PlacementPosition_Enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsPlacementPosition_Enum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string IntermediateFileStringPosition_Enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/KLT/include/KLT/RTL/tile.h line 7
namespace stringify { namespace klt_tile_desc_t {
    const char* tile_kind_e(long);

    std::string tile_kind_e(long, const std::string &strip);
}}

namespace Rose {
    std::string stringify_klt_tile_desc_t_tile_kind_e(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/KLT/include/KLT/Core/looptree.hpp line 30
namespace stringify { namespace KLT { namespace LoopTree {
    const char* kind_e(long);

    std::string kind_e(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyKLT_LoopTree_kind_e(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/KLT/include/KLT/Core/descriptor.hpp line 18
namespace stringify { namespace KLT { namespace Descriptor {
    const char* tile_kind_e(long);

    std::string tile_kind_e(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyKLT_Descriptor_tile_kind_e(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string WarningType(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyWarningType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astProcessing/AstAttributeMechanism.h line 42
namespace stringify { namespace AstAttribute {
    const char* OwnershipPolicy(long);

    std::string OwnershipPolicy(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAstAttributeOwnershipPolicy(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryTaintedFlow.h line 23
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace TaintedFlow {
    const char* Taintedness(long);

    std::string Taintedness(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisTaintedFlowTaintedness(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryTaintedFlow.h line 30
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace TaintedFlow {
    const char* Approximation(long);

    std::string Approximation(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisTaintedFlowApproximation(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySymbolicExprParser.h line 43
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExprParser { namespace Token {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprParserTokenType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryReachability.h line 19
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Reachability {
    const char* Reason(long);

    std::string Reason(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisReachabilityReason(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryReachability.h line 97
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Reachability { namespace Propagate {
    const char* Boolean(long);

    std::string Boolean(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisReachabilityPropagateBoolean(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySymbolicExpr.h line 56
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr {
    const char* Operator(long);

    std::string Operator(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprOperator(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySymbolicExpr.h line 129
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace Formatter {
    const char* ShowComments(long);

    std::string ShowComments(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprFormatterShowComments(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySymbolicExpr.h line 149
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr {
    const char* VisitAction(long);

    std::string VisitAction(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprVisitAction(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySymbolicExpr.h line 944
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace Leaf {
    const char* LeafType(long);

    std::string LeafType(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprLeafLeafType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryFunctionSimilarity.h line 70
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FunctionSimilarity {
    const char* CValKind(long);

    std::string CValKind(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFunctionSimilarityCValKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryFunctionSimilarity.h line 82
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FunctionSimilarity {
    const char* Statistic(long);

    std::string Statistic(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFunctionSimilarityStatistic(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryFeasiblePath.h line 23
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* SearchMode(long);

    std::string SearchMode(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathSearchMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryFeasiblePath.h line 26
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* SemanticMemoryParadigm(long);

    std::string SemanticMemoryParadigm(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryFeasiblePath.h line 32
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* IoMode(long);

    std::string IoMode(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathIoMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryFeasiblePath.h line 35
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* MayOrMust(long);

    std::string MayOrMust(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathMayOrMust(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryFeasiblePath.h line 102
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath { namespace PathProcessor {
    const char* Action(long);

    std::string Action(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathPathProcessorAction(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryString.h line 194
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Strings {
    const char* State(long);

    std::string State(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisStringsState(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySmtSolver.h line 42
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
    const char* LinkMode(long);

    std::string LinkMode(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverLinkMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySmtSolver.h line 54
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySmtSolver.h line 78
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
    const char* Satisfiable(long);

    std::string Satisfiable(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverSatisfiable(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryCallingConvention.h line 49
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
    const char* StackParameterOrder(long);

    std::string StackParameterOrder(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackParameterOrder(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryCallingConvention.h line 56
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
    const char* StackDirection(long);

    std::string StackDirection(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackDirection(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryCallingConvention.h line 62
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
    const char* StackCleanup(long);

    std::string StackCleanup(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackCleanup(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryCallingConvention.h line 86
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention { namespace ParameterLocation {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionParameterLocationType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryCodeInserter.h line 12
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Commit {
    const char* Boolean(long);

    std::string Boolean(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCommitBoolean(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryCodeInserter.h line 22
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
    const char* AggregationDirection(long);

    std::string AggregationDirection(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterAggregationDirection(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryCodeInserter.h line 28
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
    const char* NopPadding(long);

    std::string NopPadding(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterNopPadding(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryCodeInserter.h line 52
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
    const char* RelocType(long);

    std::string RelocType(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterRelocType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/DwarfLineMapper.h line 16
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DwarfLineMapper {
    const char* Direction(long);

    std::string Direction(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDwarfLineMapperDirection(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/instructionSemantics/BaseSemantics2.h line 393
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace BaseSemantics {
    const char* InputOutputProperty(long);

    std::string InputOutputProperty(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/instructionSemantics/DataFlowSemantics2.h line 35
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace DataFlowSemantics { namespace DataFlowEdge {
    const char* EdgeType(long);

    std::string EdgeType(long, const std::string &strip);
}}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/instructionSemantics/SymbolicSemantics2.h line 759
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics {
    const char* WritersMode(long);

    std::string WritersMode(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/instructionSemantics/SymbolicSemantics2.h line 766
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics {
    const char* DefinersMode(long);

    std::string DefinersMode(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/instructionSemantics/IntervalSemantics2.C line 650
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace IntervalSemantics {
    const char* Carry(long);

    std::string Carry(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/instructionSemantics/DispatcherX86.h line 175
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace DispatcherX86 {
    const char* AccessMode(long);

    std::string AccessMode(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryMagic.h line 16
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MagicNumber {
    const char* Mechanism(long);

    std::string Mechanism(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisMagicNumberMechanism(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astMatching/MatchOperation.h line 42
namespace stringify { namespace MatchStatus {
    const char* PatternMatchMode(long);

    std::string PatternMatchMode(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyMatchStatusPatternMatchMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astMatching/MatchOperation.h line 43
namespace stringify { namespace MatchStatus {
    const char* CheckNodeMode(long);

    std::string CheckNodeMode(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyMatchStatusCheckNodeMode(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string InsertMechanism(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySnippetInsertMechanism(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string LocalDeclarationPosition(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySnippetLocalDeclarationPosition(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string locationInTree(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAstNodeClass_locationInTree(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string includeExcludeMechanism(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAstNodeClass_includeExcludeMechanism(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TypeEvaluation(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAstNodeClassTypeEvaluation(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 93
namespace stringify {
    const char* ConstructParamEnum(long);

    std::string ConstructParamEnum(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyConstructParamEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 98
namespace stringify {
    const char* BuildAccessEnum(long);

    std::string BuildAccessEnum(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyBuildAccessEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 106
namespace stringify {
    const char* CopyConfigEnum(long);

    std::string CopyConfigEnum(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyCopyConfigEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 127
namespace stringify {
    const char* TraversalEnum(long);

    std::string TraversalEnum(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyTraversalEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 132
namespace stringify {
    const char* DeleteEnum(long);

    std::string DeleteEnum(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyDeleteEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 2587
namespace stringify { namespace SgAsmRiscOperation {
    const char* RiscOperator(long);

    std::string RiscOperator(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmRiscOperationRiscOperator(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 3415
namespace stringify { namespace SgAsmFunction {
    const char* MayReturn(long);

    std::string MayReturn(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmFunctionMayReturn(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 3425
namespace stringify { namespace SgAsmFunction {
    const char* FunctionReason(long);

    std::string FunctionReason(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmFunctionFunctionReason(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 3580
namespace stringify { namespace SgAsmFunction {
    const char* function_kind_enum(long);

    std::string function_kind_enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmFunction_function_kind_enum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 3817
namespace stringify { namespace SgAsmBlock {
    const char* Reason(long);

    std::string Reason(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmBlockReason(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 4668
namespace stringify { namespace SgAsmElfFileHeader {
    const char* ObjectType(long);

    std::string ObjectType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfFileHeaderObjectType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5088
namespace stringify { namespace SgAsmElfSectionTableEntry {
    const char* SectionType(long);

    std::string SectionType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfSectionTableEntrySectionType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5115
namespace stringify { namespace SgAsmElfSectionTableEntry {
    const char* SectionFlags(long);

    std::string SectionFlags(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfSectionTableEntrySectionFlags(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5517
namespace stringify { namespace SgAsmElfSegmentTableEntry {
    const char* SegmentType(long);

    std::string SegmentType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfSegmentTableEntrySegmentType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5545
namespace stringify { namespace SgAsmElfSegmentTableEntry {
    const char* SegmentFlags(long);

    std::string SegmentFlags(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfSegmentTableEntrySegmentFlags(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5891
namespace stringify { namespace SgAsmElfSymbol {
    const char* ElfSymBinding(long);

    std::string ElfSymBinding(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfSymbolElfSymBinding(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5897
namespace stringify { namespace SgAsmElfSymbol {
    const char* ElfSymType(long);

    std::string ElfSymType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfSymbolElfSymType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 7299
namespace stringify { namespace SgAsmElfRelocEntry {
    const char* RelocType(long);

    std::string RelocType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfRelocEntryRelocType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 7656
namespace stringify { namespace SgAsmElfDynamicEntry {
    const char* EntryType(long);

    std::string EntryType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmElfDynamicEntryEntryType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 10155
namespace stringify { namespace SgAsmPEFileHeader {
    const char* HeaderFlags(long);

    std::string HeaderFlags(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmPEFileHeaderHeaderFlags(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 10164
namespace stringify { namespace SgAsmPEFileHeader {
    const char* Subsystem(long);

    std::string Subsystem(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmPEFileHeaderSubsystem(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 10174
namespace stringify { namespace SgAsmPEFileHeader {
    const char* DLLFlags(long);

    std::string DLLFlags(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmPEFileHeaderDLLFlags(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 10183
namespace stringify { namespace SgAsmPEFileHeader {
    const char* PairPurpose(long);

    std::string PairPurpose(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmPEFileHeaderPairPurpose(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 11964
namespace stringify { namespace SgAsmPESectionTableEntry {
    const char* PESectionFlags(long);

    std::string PESectionFlags(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmPESectionTableEntryPESectionFlags(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 13992
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolDefState(long);

    std::string SymbolDefState(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolDefState(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 13999
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolType(long);

    std::string SymbolType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 14013
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolBinding(long);

    std::string SymbolBinding(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolBinding(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 14546
namespace stringify { namespace SgAsmGenericSection {
    const char* SectionPurpose(long);

    std::string SectionPurpose(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmGenericSectionSectionPurpose(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15383
namespace stringify { namespace SgAsmGenericFile {
    const char* AddressSpace(long);

    std::string AddressSpace(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmGenericFileAddressSpace(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15390
namespace stringify { namespace SgAsmGenericFile {
    const char* Elasticity(long);

    std::string Elasticity(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmGenericFileElasticity(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15796
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecFamily(long);

    std::string ExecFamily(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecFamily(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15807
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecABI(long);

    std::string ExecABI(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecABI(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15831
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* InsSetArchitecture(long);

    std::string InsSetArchitecture(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmExecutableFileFormatInsSetArchitecture(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 16010
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecPurpose(long);

    std::string ExecPurpose(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecPurpose(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TraversalEvent(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifySawyerContainerAlgorithmTraversalEvent(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string Access(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySawyerAccessAccess(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 170
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* SortOrder(long);

    std::string SortOrder(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySawyerCommandLineSortOrder(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 183
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* Canonical(long);

    std::string Canonical(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySawyerCommandLineCanonical(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 191
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* ShowGroupName(long);

    std::string ShowGroupName(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySawyerCommandLineShowGroupName(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 199
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* SwitchSkipping(long);

    std::string SwitchSkipping(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySawyerCommandLineSwitchSkipping(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 1929
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* WhichValue(long);

    std::string WhichValue(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySawyerCommandLineWhichValue(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/CommandLine.h line 2925
namespace stringify { namespace Sawyer { namespace CommandLine { namespace Parser {
    const char* GroupingFlags(long);

    std::string GroupingFlags(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifySawyerCommandLineParserGroupingFlags(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TokenType(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifySawyerDocumentMarkupTokenType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string TokenType(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifySawyerLanguageClexerTokenType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/GraphAlgorithm.h line 338
namespace stringify { namespace Sawyer { namespace Container { namespace Algorithm {
    const char* CsiNextAction(long);

    std::string CsiNextAction(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifySawyerContainerAlgorithmCsiNextAction(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string EdgePhase(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifySawyerContainerGraphEdgePhase(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Message.h line 310
namespace stringify { namespace Sawyer { namespace Message {
    const char* Importance(long);

    std::string Importance(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySawyerMessageImportance(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Message.h line 340
namespace stringify { namespace Sawyer { namespace Message {
    const char* AnsiColor(long);

    std::string AnsiColor(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifySawyerMessageAnsiColor(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Message.h line 988
namespace stringify { namespace Sawyer { namespace Message { namespace Prefix {
    const char* When(long);

    std::string When(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifySawyerMessagePrefixWhen(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string OSType(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyStringUtilityOSType(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string FileNameLocation(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyStringUtilityFileNameLocation(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string SourcePositionClassification(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifySageBuilderSourcePositionClassification(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/OmpAttribute.h line 31
namespace stringify { namespace OmpSupport {
    const char* omp_construct_enum(long);

    std::string omp_construct_enum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyOmpSupport_omp_construct_enum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/omp.h line 30
namespace stringify {
    const char* omp_lock_hint_t(long);

    std::string omp_lock_hint_t(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_omp_lock_hint_t(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/omp.h line 46
namespace stringify {
    const char* omp_sched_t(long);

    std::string omp_sched_t(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_omp_sched_t(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/omp.h line 57
namespace stringify {
    const char* omp_proc_bind_t(long);

    std::string omp_proc_bind_t(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_omp_proc_bind_t(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string DOTStyles(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAstAttributeDOT_DOTStyles(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string DOTShapeTypes(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyDOTGraphNodeDOTShapeTypes(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string DOTArrowTypes(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyDOTGraphEdgeDOTArrowTypes(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string pointerHandling(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAST_Graph_pointerHandling(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string traversalType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAST_Graph_traversalType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 126
namespace stringify { namespace PreprocessingInfo {
    const char* RelativePositionType(long);

    std::string RelativePositionType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyPreprocessingInfoRelativePositionType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 147
namespace stringify { namespace PreprocessingInfo {
    const char* DirectiveType(long);

    std::string DirectiveType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyPreprocessingInfoDirectiveType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 511
namespace stringify { namespace ROSEAttributesList {
    const char* languageTypeEnum(long);

    std::string languageTypeEnum(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSEAttributesList_languageTypeEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string EdgeConditionKind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyVirtualCFG_EdgeConditionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/virtualCFG/virtualBinCFG.h line 15
namespace stringify { namespace VirtualBinCFG {
    const char* EdgeConditionKind(long);

    std::string EdgeConditionKind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyVirtualBinCFG_EdgeConditionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string whitespace(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_token_ids_whitespace(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_C_CXX_keywords(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_keywords(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_C_CXX_alternate_tok(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_alternate_tok(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_C_CXX_Additional_Info(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_Additional_Info(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/ECJ_ROSE_Connection/JavaParserActionROSE.C line 4128
namespace stringify {
    const char* ops(long);

    std::string ops(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_ops(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Cobol_ROSE_Connection/Cobol_to_ROSE_translation.h line 8
namespace stringify { namespace Cobol_ROSE_Translation {
    const char* ProgramSpec(long);

    std::string ProgramSpec(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyCobol_ROSE_TranslationProgramSpec(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Cobol_ROSE_Connection/Cobol_to_ROSE_translation.h line 21
namespace stringify { namespace Cobol_ROSE_Translation {
    const char* ExpressionKind(long);

    std::string ExpressionKind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyCobol_ROSE_TranslationExpressionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/statements.h line 53
namespace stringify {
    const char* a_control_flow_descr_kind_tag(long);

    std::string a_control_flow_descr_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_control_flow_descr_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/ms_metadata.cpp line 1030
namespace stringify { namespace a_type_wrapper {
    const char* a_kind(long);

    std::string a_kind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringify_a_type_wrapper_a_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/ms_metadata.cpp line 1291
namespace stringify { namespace a_class_type_wrapper {
    const char* a_class_kind(long);

    std::string a_class_kind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringify_a_class_type_wrapper_a_class_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/ms_metadata.cpp line 1412
namespace stringify { namespace a_type_indirection {
    const char* an_indirection_kind(long);

    std::string an_indirection_kind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringify_a_type_indirection_an_indirection_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/ms_metadata.cpp line 1563
namespace stringify { namespace an_array_type_wrapper {
    const char* an_array_kind(long);

    std::string an_array_kind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringify_an_array_type_wrapper_an_array_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/ms_metadata.cpp line 3796
namespace stringify { namespace an_accessibility {
    const char* access_kind(long);

    std::string access_kind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringify_an_accessibility_access_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/ms_metadata.cpp line 3835
namespace stringify { namespace a_type_definition {
    const char* a_type_definition_kind(long);

    std::string a_type_definition_kind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringify_a_type_definition_a_type_definition_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/lower_il.h line 402
namespace stringify {
    const char* an_insert_location_kind(long);

    std::string an_insert_location_kind(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_insert_location_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il.h line 81
namespace stringify {
    const char* a_type_info_kind_tag(long);

    std::string a_type_info_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_type_info_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/host_envir.h line 2199
namespace stringify {
    const char* a_unicode_source_kind_tag(long);

    std::string a_unicode_source_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_unicode_source_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/host_envir.h line 3479
namespace stringify {
    const char* a_predef_macro_mode(long);

    std::string a_predef_macro_mode(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_predef_macro_mode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/decls.c line 15092
namespace stringify {
    const char* an_end_of_decl_action(long);

    std::string an_end_of_decl_action(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_end_of_decl_action(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/exprutil.h line 99
namespace stringify {
    const char* an_expression_kind_tag(long);

    std::string an_expression_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_expression_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/exprutil.h line 136
namespace stringify {
    const char* a_cast_source_form(long);

    std::string a_cast_source_form(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_cast_source_form(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/exprutil.h line 155
namespace stringify {
    const char* a_type_class_kind(long);

    std::string a_type_class_kind(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_type_class_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/exprutil.h line 237
namespace stringify {
    const char* an_operand_kind_tag(long);

    std::string an_operand_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_operand_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/exprutil.h line 283
namespace stringify {
    const char* an_operand_state_tag(long);

    std::string an_operand_state_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_operand_state_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/sys_predef.h line 38
namespace stringify {
    const char* a_multiversion_arch_kind_tag(long);

    std::string a_multiversion_arch_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_multiversion_arch_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/mem_manage.h line 399
namespace stringify {
    const char* a_function_number_tag(long);

    std::string a_function_number_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_function_number_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/pragma.h line 49
namespace stringify {
    const char* a_pragma_binding_kind(long);

    std::string a_pragma_binding_kind(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_pragma_binding_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/symbol_tbl.h line 422
namespace stringify {
    const char* a_symbol_kind_tag(long);

    std::string a_symbol_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_symbol_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/symbol_tbl.h line 697
namespace stringify {
    const char* a_dependent_type_fixup_kind_tag(long);

    std::string a_dependent_type_fixup_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_dependent_type_fixup_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/symbol_tbl.h line 3691
namespace stringify {
    const char* a_cli_operator_kind_tag(long);

    std::string a_cli_operator_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_cli_operator_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/symbol_tbl.h line 4495
namespace stringify {
    const char* a_cli_symbol_kind_tag(long);

    std::string a_cli_symbol_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_cli_symbol_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/error.c line 115
namespace stringify {
    const char* a_diagnostic_category_kind_tag(long);

    std::string a_diagnostic_category_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_diagnostic_category_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/error.c line 158
namespace stringify {
    const char* a_message_segment_kind_tag(long);

    std::string a_message_segment_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_message_segment_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/expr.h line 84
namespace stringify {
    const char* an_init_component_kind_tag(long);

    std::string an_init_component_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_init_component_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 405
namespace stringify {
    const char* an_access_specifier_tag(long);

    std::string an_access_specifier_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_access_specifier_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 425
namespace stringify {
    const char* an_assembly_visibility_tag(long);

    std::string an_assembly_visibility_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_assembly_visibility_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 444
namespace stringify {
    const char* a_name_linkage_kind_tag(long);

    std::string a_name_linkage_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_name_linkage_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 1503
namespace stringify {
    const char* an_element_position_kind_tag(long);

    std::string an_element_position_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_element_position_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 1614
namespace stringify {
    const char* an_ELF_visibility_kind_tag(long);

    std::string an_ELF_visibility_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_ELF_visibility_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 2208
namespace stringify {
    const char* an_attribute_arg_kind_tag(long);

    std::string an_attribute_arg_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_attribute_arg_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 2272
namespace stringify {
    const char* an_attribute_family_tag(long);

    std::string an_attribute_family_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_attribute_family_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 2297
namespace stringify {
    const char* an_attribute_location_tag(long);

    std::string an_attribute_location_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_attribute_location_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 2362
namespace stringify {
    const char* an_attribute_kind_tag(long);

    std::string an_attribute_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_attribute_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 2926
namespace stringify {
    const char* a_constant_repr_kind_tag(long);

    std::string a_constant_repr_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_constant_repr_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 2975
namespace stringify {
    const char* an_address_base_kind_tag(long);

    std::string an_address_base_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_address_base_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 3222
namespace stringify {
    const char* a_dynamic_init_kind_tag(long);

    std::string a_dynamic_init_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_dynamic_init_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 3617
namespace stringify {
    const char* a_template_param_constant_kind_tag(long);

    std::string a_template_param_constant_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_template_param_constant_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 3753
namespace stringify {
    const char* a_character_kind_tag(long);

    std::string a_character_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_character_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 3784
namespace stringify {
    const char* a_special_function_kind_tag(long);

    std::string a_special_function_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_special_function_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 4500
namespace stringify {
    const char* a_type_kind_tag(long);

    std::string a_type_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_type_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 4548
namespace stringify {
    const char* an_integer_kind_tag(long);

    std::string an_integer_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_integer_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 4638
namespace stringify {
    const char* a_fixed_point_precision_tag(long);

    std::string a_fixed_point_precision_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_fixed_point_precision_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 4670
namespace stringify {
    const char* a_float_kind_tag(long);

    std::string a_float_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_float_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 4688
namespace stringify {
    const char* a_type_mode_kind_tag(long);

    std::string a_type_mode_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_type_mode_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 4733
namespace stringify {
    const char* an_asm_operand_constraint_kind_tag(long);

    std::string an_asm_operand_constraint_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_asm_operand_constraint_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 4870
namespace stringify {
    const char* an_asm_operand_modifier_tag(long);

    std::string an_asm_operand_modifier_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_asm_operand_modifier_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 4882
namespace stringify {
    const char* a_named_register_tag(long);

    std::string a_named_register_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_named_register_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5050
namespace stringify {
    const char* a_type_qualifier_tag(long);

    std::string a_type_qualifier_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_type_qualifier_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5136
namespace stringify {
    const char* a_upc_pragma_kind_tag(long);

    std::string a_upc_pragma_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_upc_pragma_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5146
namespace stringify {
    const char* a_upc_access_method_tag(long);

    std::string a_upc_access_method_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_upc_access_method_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5157
namespace stringify {
    const char* a_upc_coherence_stack_operation_tag(long);

    std::string a_upc_coherence_stack_operation_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_upc_coherence_stack_operation_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5323
namespace stringify {
    const char* a_stdc_pragma_kind_tag(long);

    std::string a_stdc_pragma_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_stdc_pragma_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5349
namespace stringify {
    const char* a_stdc_pragma_value_tag(long);

    std::string a_stdc_pragma_value_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_stdc_pragma_value_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5370
namespace stringify {
    const char* a_gcc_pragma_kind_tag(long);

    std::string a_gcc_pragma_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_gcc_pragma_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5410
namespace stringify {
    const char* a_pragma_kind_tag(long);

    std::string a_pragma_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_pragma_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5634
namespace stringify {
    const char* a_microsoft_pragma_comment_type_tag(long);

    std::string a_microsoft_pragma_comment_type_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_microsoft_pragma_comment_type_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5648
namespace stringify {
    const char* a_microsoft_pragma_conform_kind_tag(long);

    std::string a_microsoft_pragma_conform_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_microsoft_pragma_conform_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5933
namespace stringify {
    const char* a_calling_convention_tag(long);

    std::string a_calling_convention_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_calling_convention_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 5966
namespace stringify {
    const char* a_decl_modifier_tag(long);

    std::string a_decl_modifier_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_decl_modifier_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 6121
namespace stringify {
    const char* a_ref_qualifier_kind_tag(long);

    std::string a_ref_qualifier_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_ref_qualifier_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 6382
namespace stringify {
    const char* a_templ_arg_kind_tag(long);

    std::string a_templ_arg_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_templ_arg_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 6972
namespace stringify {
    const char* an_anonymous_union_kind_tag(long);

    std::string an_anonymous_union_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_anonymous_union_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 6987
namespace stringify {
    const char* an_inheritance_kind_tag(long);

    std::string an_inheritance_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_inheritance_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 7021
namespace stringify {
    const char* a_cli_class_type_kind_tag(long);

    std::string a_cli_class_type_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_cli_class_type_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 7054
namespace stringify {
    const char* a_property_or_event_kind_tag(long);

    std::string a_property_or_event_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_property_or_event_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 7187
namespace stringify {
    const char* a_rewritten_property_reference_kind_tag(long);

    std::string a_rewritten_property_reference_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_rewritten_property_reference_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 7824
namespace stringify {
    const char* a_template_param_type_kind_tag(long);

    std::string a_template_param_type_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_template_param_type_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 8070
namespace stringify {
    const char* a_based_type_kind_tag(long);

    std::string a_based_type_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_based_type_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 8128
namespace stringify {
    const char* a_pointer_modifier_tag(long);

    std::string a_pointer_modifier_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_pointer_modifier_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 9214
namespace stringify {
    const char* a_storage_class_tag(long);

    std::string a_storage_class_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_storage_class_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 9254
namespace stringify {
    const char* an_init_kind_tag(long);

    std::string an_init_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_init_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 10148
namespace stringify {
    const char* an_opname_kind_tag(long);

    std::string an_opname_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_opname_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 10189
namespace stringify {
    const char* a_builtin_function_kind_tag(long);

    std::string a_builtin_function_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_builtin_function_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 13060
namespace stringify {
    const char* a_ctor_or_dtor_kind_tag(long);

    std::string a_ctor_or_dtor_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_ctor_or_dtor_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 14268
namespace stringify {
    const char* an_expr_node_kind_tag(long);

    std::string an_expr_node_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_expr_node_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 14371
namespace stringify {
    const char* a_lowered_eh_construct_kind_tag(long);

    std::string a_lowered_eh_construct_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_lowered_eh_construct_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 14413
namespace stringify {
    const char* an_expr_operator_kind_tag(long);

    std::string an_expr_operator_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_expr_operator_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 14872
namespace stringify {
    const char* a_builtin_operation_kind_tag(long);

    std::string a_builtin_operation_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_builtin_operation_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 15205
namespace stringify {
    const char* a_local_expr_node_ref_kind_tag(long);

    std::string a_local_expr_node_ref_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_local_expr_node_ref_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 15929
namespace stringify {
    const char* a_statement_kind_tag(long);

    std::string a_statement_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_statement_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 16141
namespace stringify {
    const char* a_for_each_pattern_kind_tag(long);

    std::string a_for_each_pattern_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_for_each_pattern_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 16811
namespace stringify {
    const char* a_constructor_init_kind_tag(long);

    std::string a_constructor_init_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_constructor_init_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 17019
namespace stringify {
    const char* a_generic_constraint_kind_tag(long);

    std::string a_generic_constraint_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_generic_constraint_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 17107
namespace stringify {
    const char* a_template_parameter_kind_tag(long);

    std::string a_template_parameter_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_template_parameter_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 17211
namespace stringify {
    const char* a_template_kind_tag(long);

    std::string a_template_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_template_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 17551
namespace stringify {
    const char* an_object_lifetime_kind_tag(long);

    std::string an_object_lifetime_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_object_lifetime_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 17694
namespace stringify {
    const char* an_ms_attribute_kind_tag(long);

    std::string an_ms_attribute_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_ms_attribute_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 17714
namespace stringify {
    const char* an_ms_attribute_arg_kind_tag(long);

    std::string an_ms_attribute_arg_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_ms_attribute_arg_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/il_def.h line 18023
namespace stringify {
    const char* a_scope_kind_tag(long);

    std::string a_scope_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_scope_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/ms_metadata.h line 25
namespace stringify {
    const char* a_cpp_cli_import_flag_tag(long);

    std::string a_cpp_cli_import_flag_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_cpp_cli_import_flag_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/src/lexical.h line 1829
namespace stringify {
    const char* a_token_extra_info_kind_tag(long);

    std::string a_token_extra_info_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_token_extra_info_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/util/decode.c line 4037
namespace stringify {
    const char* a_substitution_kind(long);

    std::string a_substitution_kind(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_substitution_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/lib_src/eh.h line 309
namespace stringify {
    const char* an_eh_stack_entry_kind_tag(long);

    std::string an_eh_stack_entry_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_an_eh_stack_entry_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/lib_src/rtti.c line 109
namespace stringify {
    const char* a_result_virtuality(long);

    std::string a_result_virtuality(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_result_virtuality(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/include/cxxabi.h line 62
namespace stringify { namespace __cxxabiv1 { namespace __base_class_type_info {
    const char* __offset_flags_masks(long);

    std::string __offset_flags_masks(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify__cxxabiv1__base_class_type_info__offset_flags_masks(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/include/cxxabi.h line 77
namespace stringify { namespace __cxxabiv1 { namespace __vmi_class_type_info {
    const char* __flags_masks(long);

    std::string __flags_masks(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify__cxxabiv1__vmi_class_type_info__flags_masks(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/include/cxxabi.h line 90
namespace stringify { namespace __cxxabiv1 { namespace __pbase_type_info {
    const char* __masks(long);

    std::string __masks(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringify__cxxabiv1__pbase_type_info__masks(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/edgRose.C line 6378
namespace stringify {
    const char* kinds_of_type_references(long);

    std::string kinds_of_type_references(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_kinds_of_type_references(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/sys_predef.h line 212
namespace stringify {
    const char* a_builtin_user_function_kind_tag(long);

    std::string a_builtin_user_function_kind_tag(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_builtin_user_function_kind_tag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/builtin_defs.h line 22
namespace stringify {
    const char* a_builtin_function_type_index(long);

    std::string a_builtin_function_type_index(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_builtin_function_type_index(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/builtin_defs.h line 4189
namespace stringify {
    const char* a_builtin_function_condition_index(long);

    std::string a_builtin_function_condition_index(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_builtin_function_condition_index(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/disp/error.c line 91
namespace stringify {
    const char* a_diag_fill_in_kind(long);

    std::string a_diag_fill_in_kind(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_diag_fill_in_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/disp/error.c line 196
namespace stringify {
    const char* a_diagnostic_kind(long);

    std::string a_diagnostic_kind(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_diagnostic_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.4/src/ms_metadata.cpp line 880
namespace stringify {
    const char* a_top_level_kind(long);

    std::string a_top_level_kind(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_top_level_kind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.4/src/decl_inits.c line 56
namespace stringify {
    const char* a_designation_state(long);

    std::string a_designation_state(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_a_designation_state(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/Clang/clang-frontend-private.hpp line 137
namespace stringify { namespace ClangToSageTranslator {
    const char* Language(long);

    std::string Language(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyClangToSageTranslatorLanguage(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Jovial_ROSE_Connection/Jovial_to_ROSE_translation.h line 8
namespace stringify { namespace Jovial_ROSE_Translation {
    const char* ExpressionKind(long);

    std::string ExpressionKind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyJovial_ROSE_TranslationExpressionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/SRecord.h line 18
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSRecordType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/MemoryMap.h line 125
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap { namespace Attach {
    const char* Boolean(long);

    std::string Boolean(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisMemoryMapAttachBoolean(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/MemoryMap.h line 281
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap {
    const char* InsertFileMapMode(long);

    std::string InsertFileMapMode(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisMemoryMapInsertFileMapMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/ByteOrder.h line 7
namespace stringify { namespace ByteOrder {
    const char* Endianness(long);

    std::string Endianness(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyByteOrderEndianness(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/Ada_to_ROSE_translation.C line 7222
namespace stringify {
    const char* Definition_Kinds(long);

    std::string Definition_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyDefinition_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/Ada_to_ROSE_translation.C line 7859
namespace stringify {
    const char* Path_Kinds(long);

    std::string Path_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyPath_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/Ada_to_ROSE_translation.C line 9954
namespace stringify {
    const char* _Access_Definition_Kinds(long);

    std::string _Access_Definition_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Access_Definition_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/Ada_to_ROSE_translation.C line 9992
namespace stringify {
    const char* _Formal_Type_Kinds(long);

    std::string _Formal_Type_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Formal_Type_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/Ada_to_ROSE_translation.C line 10048
namespace stringify {
    const char* _Discrete_Range_Kinds(long);

    std::string _Discrete_Range_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Discrete_Range_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/Ada_to_ROSE_translation.C line 10079
namespace stringify {
    const char* _Constraint_Kinds(long);

    std::string _Constraint_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Constraint_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/Ada_to_ROSE_translation.C line 10116
namespace stringify {
    const char* _Representation_Clause_Kinds(long);

    std::string _Representation_Clause_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Representation_Clause_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/Ada_to_ROSE_translation.h line 26
namespace stringify { namespace Ada_ROSE_Translation {
    const char* ExpressionKind(long);

    std::string ExpressionKind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAda_ROSE_TranslationExpressionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 47
namespace stringify {
    const char* Element_Kinds(long);

    std::string Element_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyElement_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 142
namespace stringify {
    const char* Operator_Kinds(long);

    std::string Operator_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyOperator_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 172
namespace stringify {
    const char* Pragma_Kinds(long);

    std::string Pragma_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyPragma_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 247
namespace stringify {
    const char* Defining_Name_Kinds(long);

    std::string Defining_Name_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyDefining_Name_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 288
namespace stringify {
    const char* Declaration_Kinds(long);

    std::string Declaration_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyDeclaration_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 392
namespace stringify {
    const char* Declaration_Origins(long);

    std::string Declaration_Origins(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyDeclaration_Origins(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 408
namespace stringify {
    const char* Mode_Kinds(long);

    std::string Mode_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyMode_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 418
namespace stringify {
    const char* Subprogram_Default_Kinds(long);

    std::string Subprogram_Default_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifySubprogram_Default_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 836
namespace stringify {
    const char* _Type_Kinds(long);

    std::string _Type_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Type_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 870
namespace stringify {
    const char* _Interface_Kinds(long);

    std::string _Interface_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Interface_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 879
namespace stringify {
    const char* _Root_Type_Kinds(long);

    std::string _Root_Type_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Root_Type_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 917
namespace stringify {
    const char* _Access_Type_Kinds(long);

    std::string _Access_Type_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringify_Access_Type_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 1244
namespace stringify {
    const char* Expression_Kinds(long);

    std::string Expression_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyExpression_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 1289
namespace stringify {
    const char* Attribute_Kinds(long);

    std::string Attribute_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyAttribute_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 1515
namespace stringify {
    const char* Association_Kinds(long);

    std::string Association_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyAssociation_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 1564
namespace stringify {
    const char* Statement_Kinds(long);

    std::string Statement_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyStatement_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 1792
namespace stringify {
    const char* Clause_Kinds(long);

    std::string Clause_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyClause_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 1893
namespace stringify {
    const char* Enclosing_Kinds(long);

    std::string Enclosing_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyEnclosing_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 1945
namespace stringify {
    const char* Unit_Kinds(long);

    std::string Unit_Kinds(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyUnit_Kinds(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 2012
namespace stringify {
    const char* Unit_Classes(long);

    std::string Unit_Classes(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyUnit_Classes(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/a_nodes.h line 2033
namespace stringify {
    const char* Unit_Origins(long);

    std::string Unit_Origins(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyUnit_Origins(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryLoader/BinaryLoader.h line 55
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryLoader {
    const char* MappingContribution(long);

    std::string MappingContribution(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisBinaryLoaderMappingContribution(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryLoader/BinaryLoader.h line 63
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryLoader {
    const char* ConflictResolution(long);

    std::string ConflictResolution(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisBinaryLoaderConflictResolution(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 8
namespace stringify { namespace General_Language_Translation {
    const char* ExpressionKind(long);

    std::string ExpressionKind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyGeneral_Language_TranslationExpressionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/FASTNodes.h line 88
namespace stringify { namespace FAST { namespace TypeSpec {
    const char* TypeEnum(long);

    std::string TypeEnum(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyFAST_TypeSpecTypeEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/FASTNodes.h line 136
namespace stringify { namespace FAST { namespace AttrSpec {
    const char* AttrEnum(long);

    std::string AttrEnum(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyFAST_AttrSpecAttrEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/FASTNodes.h line 265
namespace stringify { namespace FAST { namespace UseStmt {
    const char* ModuleNature(long);

    std::string ModuleNature(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyFAST_UseStmtModuleNature(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/FASTNodes.h line 444
namespace stringify { namespace FAST { namespace PrefixSpec {
    const char* PrefixEnum(long);

    std::string PrefixEnum(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyFAST_PrefixSpecPrefixEnum(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/Function.h line 42
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Function {
    const char* Ownership(long);

    std::string Ownership(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2FunctionOwnership(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/Partitioner.h line 1416
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Partitioner { namespace MayReturnVertexInfo {
    const char* State(long);

    std::string State(long, const std::string &strip);
}}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2PartitionerMayReturnVertexInfoState(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/ModulesElf.h line 68
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace ModulesElf { namespace FixUndefinedSymbols {
    const char* Boolean(long);

    std::string Boolean(long, const std::string &strip);
}}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2ModulesElfFixUndefinedSymbolsBoolean(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 22
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Precision {
    const char* Level(long);

    std::string Level(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2PrecisionLevel(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 31
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* VertexType(long);

    std::string VertexType(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2VertexType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 42
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* EdgeType(long);

    std::string EdgeType(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2EdgeType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 66
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* Confidence(long);

    std::string Confidence(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2Confidence(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 72
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* SemanticMemoryParadigm(long);

    std::string SemanticMemoryParadigm(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2SemanticMemoryParadigm(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 170
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* MemoryDataAdjustment(long);

    std::string MemoryDataAdjustment(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2MemoryDataAdjustment(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 255
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* FunctionReturnAnalysis(long);

    std::string FunctionReturnAnalysis(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2FunctionReturnAnalysis(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/DataFlow.h line 28
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace DataFlow { namespace DfCfgVertex {
    const char* Type(long);

    std::string Type(long, const std::string &strip);
}}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2DataFlowDfCfgVertexType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/Modules.h line 44
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace BasicBlockCallback {
    const char* Termination(long);

    std::string Termination(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2BasicBlockCallbackTermination(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/Reference.h line 29
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Reference {
    const char* Granularity(long);

    std::string Granularity(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2ReferenceGranularity(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/CfgPath.h line 329
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Inliner {
    const char* HowInline(long);

    std::string HowInline(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisPartitioner2InlinerHowInline(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_Fortran_Identifiers(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyROSE_Fortran_Identifiers(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_Fortran_Operators(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyROSE_Fortran_Operators(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_Fortran_Additional_Info(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyROSE_Fortran_Additional_Info(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_Fortran_keywords(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_keywords(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_C_CXX_keywords(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_C_CXX_keywords(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_Fortran_Operators(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_Operators(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_C_CXX_operators(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_C_CXX_operators(long int n, const char *strip=NULL, bool canonic=false);
}

// 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(long);

    std::string ROSE_Fortran_Additional_Info(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_Additional_Info(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/AssemblerX86.h line 141
namespace stringify { namespace AssemblerX86 {
    const char* OperandDefn(long);

    std::string OperandDefn(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAssemblerX86OperandDefn(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/AssemblerX86.h line 382
namespace stringify { namespace AssemblerX86 {
    const char* MemoryReferencePattern(long);

    std::string MemoryReferencePattern(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAssemblerX86MemoryReferencePattern(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/BinaryDebugger.h line 15
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryDebugger {
    const char* DetachMode(long);

    std::string DetachMode(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisBinaryDebuggerDetachMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/BinaryDebugger.h line 18
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryDebugger {
    const char* Flag(long);

    std::string Flag(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisBinaryDebuggerFlag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/BinaryDebugger.h line 29
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryDebugger {
    const char* RegPageStatus(long);

    std::string RegPageStatus(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisBinaryDebuggerRegPageStatus(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 12
namespace stringify {
    const char* M68kFamily(long);

    std::string M68kFamily(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kFamily(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 49
namespace stringify {
    const char* M68kRegisterClass(long);

    std::string M68kRegisterClass(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kRegisterClass(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 58
namespace stringify {
    const char* M68kSpecialPurposeRegister(long);

    std::string M68kSpecialPurposeRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kSpecialPurposeRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 66
namespace stringify {
    const char* M68kMacRegister(long);

    std::string M68kMacRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kMacRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 81
namespace stringify {
    const char* M68kEmacRegister(long);

    std::string M68kEmacRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kEmacRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 90
namespace stringify {
    const char* M68kSupervisorRegister(long);

    std::string M68kSupervisorRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kSupervisorRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 177
namespace stringify {
    const char* M68kEffectiveAddressMode(long);

    std::string M68kEffectiveAddressMode(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kEffectiveAddressMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 231
namespace stringify {
    const char* M68kDataFormat(long);

    std::string M68kDataFormat(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kDataFormat(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 242
namespace stringify {
    const char* M68kInstructionKind(long);

    std::string M68kInstructionKind(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyM68kInstructionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/DisassemblerX86.h line 139
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DisassemblerX86 {
    const char* RegisterMode(long);

    std::string RegisterMode(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDisassemblerX86RegisterMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/DisassemblerX86.h line 144
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DisassemblerX86 {
    const char* MMPrefix(long);

    std::string MMPrefix(long, const std::string &strip);
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDisassemblerX86MMPrefix(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/DisassemblerMips.h line 34
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DisassemblerMips { namespace Mips32 {
    const char* Architecture(long);

    std::string Architecture(long, const std::string &strip);
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDisassemblerMipsMips32Architecture(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsMips.h line 6
namespace stringify {
    const char* MipsRegisterClass(long);

    std::string MipsRegisterClass(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyMipsRegisterClass(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsMips.h line 18
namespace stringify {
    const char* MipsFcsrMinors(long);

    std::string MipsFcsrMinors(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyMipsFcsrMinors(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsMips.h line 26
namespace stringify {
    const char* MipsSpecialPurposeRegister(long);

    std::string MipsSpecialPurposeRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyMipsSpecialPurposeRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsMips.h line 35
namespace stringify {
    const char* MipsInstructionKind(long);

    std::string MipsInstructionKind(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyMipsInstructionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/armInstructionEnum.h line 6
namespace stringify {
    const char* ArmRegisterClass(long);

    std::string ArmRegisterClass(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyArmRegisterClass(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/armInstructionEnum.h line 12
namespace stringify {
    const char* ArmProgramStatusRegister(long);

    std::string ArmProgramStatusRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyArmProgramStatusRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/armInstructionEnum.h line 18
namespace stringify {
    const char* ArmInstructionKind(long);

    std::string ArmInstructionKind(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyArmInstructionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/armInstructionEnum.h line 123
namespace stringify {
    const char* ArmInstructionCondition(long);

    std::string ArmInstructionCondition(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyArmInstructionCondition(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/BinaryDebugger.C line 12
namespace stringify {
    const char* __ptrace_request(long);

    std::string __ptrace_request(long, const std::string &strip);
}

namespace Rose {
    std::string stringify__ptrace_request(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 9
namespace stringify {
    const char* X86InstructionSize(long);

    std::string X86InstructionSize(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86InstructionSize(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 17
namespace stringify {
    const char* X86RegisterClass(long);

    std::string X86RegisterClass(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86RegisterClass(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 30
namespace stringify {
    const char* X86SegmentRegister(long);

    std::string X86SegmentRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86SegmentRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 41
namespace stringify {
    const char* X86GeneralPurposeRegister(long);

    std::string X86GeneralPurposeRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86GeneralPurposeRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 61
namespace stringify {
    const char* X86StRegister(long);

    std::string X86StRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86StRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 74
namespace stringify {
    const char* X86Flags(long);

    std::string X86Flags(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86Flags(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 83
namespace stringify {
    const char* X86Flag(long);

    std::string X86Flag(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86Flag(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 104
namespace stringify {
    const char* X86BranchPrediction(long);

    std::string X86BranchPrediction(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86BranchPrediction(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 112
namespace stringify {
    const char* X86RepeatPrefix(long);

    std::string X86RepeatPrefix(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86RepeatPrefix(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 121
namespace stringify {
    const char* X86Exception(long);

    std::string X86Exception(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86Exception(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/AssemblerX86Init.h line 21
namespace stringify {
    const char* X86InstructionKind(long);

    std::string X86InstructionKind(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyX86InstructionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/Registers.h line 275
namespace stringify { namespace RegisterDictionary { namespace SortBySize {
    const char* Direction(long);

    std::string Direction(long, const std::string &strip);
}}}

namespace Rose {
    std::string stringifyRegisterDictionarySortBySizeDirection(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/powerpcInstructionEnum.h line 8
namespace stringify {
    const char* PowerpcInstructionKind(long);

    std::string PowerpcInstructionKind(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyPowerpcInstructionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/powerpcInstructionEnum.h line 454
namespace stringify {
    const char* PowerpcRegisterClass(long);

    std::string PowerpcRegisterClass(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyPowerpcRegisterClass(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/powerpcInstructionEnum.h line 470
namespace stringify {
    const char* PowerpcConditionRegisterAccessGranularity(long);

    std::string PowerpcConditionRegisterAccessGranularity(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyPowerpcConditionRegisterAccessGranularity(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/powerpcInstructionEnum.h line 477
namespace stringify {
    const char* PowerpcSpecialPurposeRegister(long);

    std::string PowerpcSpecialPurposeRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyPowerpcSpecialPurposeRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/powerpcInstructionEnum.h line 487
namespace stringify {
    const char* PowerpcTimeBaseRegister(long);

    std::string PowerpcTimeBaseRegister(long, const std::string &strip);
}

namespace Rose {
    std::string stringifyPowerpcTimeBaseRegister(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/Assembler.h line 71
namespace stringify { namespace Assembler {
    const char* EncodingType(long);

    std::string EncodingType(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyAssemblerEncodingType(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_OpenFortranParser_ROSE_Connection/Fortran_to_ROSE_translation.h line 8
namespace stringify { namespace Fortran_ROSE_Translation {
    const char* ExpressionKind(long);

    std::string ExpressionKind(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyFortran_ROSE_TranslationExpressionKind(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/AstGraphWidget/DisplayEdge.h line 40
namespace stringify { namespace DisplayEdge {
    const char* PaintMode(long);

    std::string PaintMode(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyDisplayEdgePaintMode(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/TaskSystem/TaskInterface.h line 25
namespace stringify { namespace Task {
    const char* State(long);

    std::string State(long, const std::string &strip);
}}

namespace Rose {
    std::string stringifyTaskState(long int n, const char *strip=NULL, bool canonic=false);
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/TaskSystem/CompilerOutputWidget.h line 25
namespace stringify { namespace CompilerOutputWidget {
    const char* PatternType(long);