stringify.h

// DO NOT EDIT -- This file is automatically generated.

#ifndef ROSE_STRINGIFY_H
#define ROSE_STRINGIFY_H
#include <boost/algorithm/string/predicate.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
#include <vector>

namespace Rose {
class Stringifier {
    std::string(*stringifier_)(int64_t, const char*, bool);
public:
    Stringifier(std::string(*stringifier)(int64_t, const char*, bool)): stringifier_(stringifier) {}
    std::string operator()(int64_t n, const char *strip=NULL, bool canonic=false) {
        return stringifier_(n, strip, canonic);
    }
};
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryUnparserBase.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace ArrowMargin {
    const char* Flags(int64_t);

    std::string Flags(int64_t, const std::string &strip);

    const std::vector<int64_t>& Flags();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisUnparserArrowMarginFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisUnparserArrowMarginFlags();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryEdgeArrows.h line 31
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
    const char* OutputPart(int64_t);

    std::string OutputPart(int64_t, const std::string &strip);

    const std::vector<int64_t>& OutputPart();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryEdgeArrows.h line 59
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
    const char* ArrowStylePreset(int64_t);

    std::string ArrowStylePreset(int64_t, const std::string &strip);

    const std::vector<int64_t>& ArrowStylePreset();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryEdgeArrows.h line 68
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
    const char* ArrowSide(int64_t);

    std::string ArrowSide(int64_t, const std::string &strip);

    const std::vector<int64_t>& ArrowSide();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide();
}

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

    std::string Organization(int64_t, const std::string &strip);

    const std::vector<int64_t>& Organization();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisAsmUnparserOrganization(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisAsmUnparserOrganization();
}

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

    std::string Format(int64_t, const std::string &strip);

    const std::vector<int64_t>& Format();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSerialIoFormat(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoFormat();
}

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

    std::string Savable(int64_t, const std::string &strip);

    const std::vector<int64_t>& Savable();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSerialIoSavable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoSavable();
}

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

    std::string ArmSignForExpressionUnparsing(int64_t, const std::string &strip);

    const std::vector<int64_t>& ArmSignForExpressionUnparsing();
}

namespace Rose {
    std::string stringifyArmSignForExpressionUnparsing(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyArmSignForExpressionUnparsing();
}

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

    std::string AssociativitySpecifier(int64_t, const std::string &strip);

    const std::vector<int64_t>& AssociativitySpecifier();
}

namespace Rose {
    std::string stringifyAssociativitySpecifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAssociativitySpecifier();
}

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

    std::string token_sequence_position_enum_type(int64_t, const std::string &strip);

    const std::vector<int64_t>& token_sequence_position_enum_type();
}}

namespace Rose {
    std::string stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type();
}

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

    std::string unparsed_as_enum_type(int64_t, const std::string &strip);

    const std::vector<int64_t>& unparsed_as_enum_type();
}}

namespace Rose {
    std::string stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type();
}

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

    std::string token_sequence_position_enum_type(int64_t, const std::string &strip);

    const std::vector<int64_t>& token_sequence_position_enum_type();
}}

namespace Rose {
    std::string stringifyUnparser_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparser_token_sequence_position_enum_type();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/formatSupport/unparse_format.h line 51
namespace stringify {
    const char* Format_Opt(int64_t);

    std::string Format_Opt(int64_t, const std::string &strip);

    const std::vector<int64_t>& Format_Opt();
}

namespace Rose {
    std::string stringifyFormat_Opt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFormat_Opt();
}

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

    std::string token_sequence_position_enum_type(int64_t, const std::string &strip);

    const std::vector<int64_t>& token_sequence_position_enum_type();
}}

namespace Rose {
    std::string stringifyUnparse_ExprStmt_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparse_ExprStmt_token_sequence_position_enum_type();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/astUnparseAttribute.h line 33
namespace stringify { namespace AstUnparseAttribute {
    const char* RelativePositionType(int64_t);

    std::string RelativePositionType(int64_t, const std::string &strip);

    const std::vector<int64_t>& RelativePositionType();
}}

namespace Rose {
    std::string stringifyAstUnparseAttributeRelativePositionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstUnparseAttributeRelativePositionType();
}

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

    std::string yytokentype(int64_t, const std::string &strip);

    const std::vector<int64_t>& yytokentype();
}

namespace Rose {
    std::string stringify_yytokentype(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_yytokentype();
}

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

    std::string traversalType(int64_t, const std::string &strip);

    const std::vector<int64_t>& traversalType();
}}

namespace Rose {
    std::string stringifyDOTGeneration_traversalType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGeneration_traversalType();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}

namespace Rose {
    std::string stringify_qrsQRButtonsType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRButtonsType();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}

namespace Rose {
    std::string stringify_qrsQRSelectType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRSelectType();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}

namespace Rose {
    std::string stringify_qrsQREditType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQREditType();
}

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

    std::string TypeSel(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeSel();
}}}

namespace Rose {
    std::string stringify_qrsQEditorTypeSel(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQEditorTypeSel();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}

namespace Rose {
    std::string stringify_qrsQSourceColorizerType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQSourceColorizerType();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}

namespace Rose {
    std::string stringify_qrsParenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsParenType();
}

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

    std::string Selection(int64_t, const std::string &strip);

    const std::vector<int64_t>& Selection();
}}}

namespace Rose {
    std::string stringify_qrsParenMatcherSelection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsParenMatcherSelection();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}

namespace Rose {
    std::string stringify_qrsSymbolType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsSymbolType();
}

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

    std::string ToolbarIdx(int64_t, const std::string &strip);

    const std::vector<int64_t>& ToolbarIdx();
}}}

namespace Rose {
    std::string stringify_qrsQRSourceBoxToolbarIdx(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRSourceBoxToolbarIdx();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}

namespace Rose {
    std::string stringify_qrsQ3TextStringCharType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextStringCharType();
}

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

    std::string Operation(int64_t, const std::string &strip);

    const std::vector<int64_t>& Operation();
}}}

namespace Rose {
    std::string stringify_qrsQ3TextCursorOperation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextCursorOperation();
}

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

    std::string Commands(int64_t, const std::string &strip);

    const std::vector<int64_t>& Commands();
}}}

namespace Rose {
    std::string stringify_qrsQ3TextCommandCommands(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextCommandCommands();
}

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

    std::string Placement(int64_t, const std::string &strip);

    const std::vector<int64_t>& Placement();
}}}

namespace Rose {
    std::string stringify_qrsQ3TextCustomItemPlacement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextCustomItemPlacement();
}

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

    std::string SelectionIds(int64_t, const std::string &strip);

    const std::vector<int64_t>& SelectionIds();
}}}

namespace Rose {
    std::string stringify_qrsQ3TextDocumentSelectionIds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextDocumentSelectionIds();
}

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

    std::string Ids(int64_t, const std::string &strip);

    const std::vector<int64_t>& Ids();
}}}

namespace Rose {
    std::string stringify_qrsQ3TextPreProcessorIds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextPreProcessorIds();
}

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

    std::string Flags(int64_t, const std::string &strip);

    const std::vector<int64_t>& Flags();
}}}

namespace Rose {
    std::string stringify_qrsQ3TextFormatFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextFormatFlags();
}

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

    std::string VerticalAlignment(int64_t, const std::string &strip);

    const std::vector<int64_t>& VerticalAlignment();
}}}

namespace Rose {
    std::string stringify_qrsQ3TextFormatVerticalAlignment(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextFormatVerticalAlignment();
}

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

    std::string ToolbarIdx(int64_t, const std::string &strip);

    const std::vector<int64_t>& ToolbarIdx();
}}}

namespace Rose {
    std::string stringify_qrsQRTreeBoxToolbarIdx(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRTreeBoxToolbarIdx();
}

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

    std::string popmenu_nodes_id(int64_t, const std::string &strip);

    const std::vector<int64_t>& popmenu_nodes_id();
}}}

namespace Rose {
    std::string stringify_qrsQRTreeBox_popmenu_nodes_id(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRTreeBox_popmenu_nodes_id();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_encoder.h line 69
namespace stringify {
    const char* _HPDF_EncodingType(int64_t);

    std::string _HPDF_EncodingType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_EncodingType();
}

namespace Rose {
    std::string stringify_HPDF_EncodingType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_EncodingType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_encoder.h line 130
namespace stringify {
    const char* _HPDF_BaseEncodings(int64_t);

    std::string _HPDF_BaseEncodings(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_BaseEncodings();
}

namespace Rose {
    std::string stringify_HPDF_BaseEncodings(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_BaseEncodings();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_fontdef.h line 63
namespace stringify {
    const char* _HPDF_FontDefType(int64_t);

    std::string _HPDF_FontDefType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_FontDefType();
}

namespace Rose {
    std::string stringify_HPDF_FontDefType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_FontDefType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_streams.h line 33
namespace stringify {
    const char* _HPDF_StreamType(int64_t);

    std::string _HPDF_StreamType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_StreamType();
}

namespace Rose {
    std::string stringify_HPDF_StreamType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_StreamType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_streams.h line 46
namespace stringify {
    const char* _HPDF_WhenceMode(int64_t);

    std::string _HPDF_WhenceMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_WhenceMode();
}

namespace Rose {
    std::string stringify_HPDF_WhenceMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_WhenceMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_font.h line 31
namespace stringify {
    const char* _HPDF_FontType(int64_t);

    std::string _HPDF_FontType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_FontType();
}

namespace Rose {
    std::string stringify_HPDF_FontType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_FontType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 128
namespace stringify {
    const char* _HPDF_InfoType(int64_t);

    std::string _HPDF_InfoType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_InfoType();
}

namespace Rose {
    std::string stringify_HPDF_InfoType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_InfoType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 144
namespace stringify {
    const char* _HPDF_PdfVer(int64_t);

    std::string _HPDF_PdfVer(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_PdfVer();
}

namespace Rose {
    std::string stringify_HPDF_PdfVer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PdfVer();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 154
namespace stringify {
    const char* _HPDF_EncryptMode(int64_t);

    std::string _HPDF_EncryptMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_EncryptMode();
}

namespace Rose {
    std::string stringify_HPDF_EncryptMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_EncryptMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 213
namespace stringify {
    const char* _HPDF_ColorSpace(int64_t);

    std::string _HPDF_ColorSpace(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_ColorSpace();
}

namespace Rose {
    std::string stringify_HPDF_ColorSpace(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_ColorSpace();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 250
namespace stringify {
    const char* _HPDF_LineCap(int64_t);

    std::string _HPDF_LineCap(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_LineCap();
}

namespace Rose {
    std::string stringify_HPDF_LineCap(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_LineCap();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 260
namespace stringify {
    const char* _HPDF_LineJoin(int64_t);

    std::string _HPDF_LineJoin(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_LineJoin();
}

namespace Rose {
    std::string stringify_HPDF_LineJoin(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_LineJoin();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 270
namespace stringify {
    const char* _HPDF_TextRenderingMode(int64_t);

    std::string _HPDF_TextRenderingMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_TextRenderingMode();
}

namespace Rose {
    std::string stringify_HPDF_TextRenderingMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_TextRenderingMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 283
namespace stringify {
    const char* _HPDF_WritingMode(int64_t);

    std::string _HPDF_WritingMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_WritingMode();
}

namespace Rose {
    std::string stringify_HPDF_WritingMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_WritingMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 290
namespace stringify {
    const char* _HPDF_PageLayout(int64_t);

    std::string _HPDF_PageLayout(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_PageLayout();
}

namespace Rose {
    std::string stringify_HPDF_PageLayout(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageLayout();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 299
namespace stringify {
    const char* _HPDF_PageMode(int64_t);

    std::string _HPDF_PageMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_PageMode();
}

namespace Rose {
    std::string stringify_HPDF_PageMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 311
namespace stringify {
    const char* _HPDF_PageNumStyle(int64_t);

    std::string _HPDF_PageNumStyle(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_PageNumStyle();
}

namespace Rose {
    std::string stringify_HPDF_PageNumStyle(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageNumStyle();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 321
namespace stringify {
    const char* _HPDF_DestinationType(int64_t);

    std::string _HPDF_DestinationType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_DestinationType();
}

namespace Rose {
    std::string stringify_HPDF_DestinationType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_DestinationType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 334
namespace stringify {
    const char* _HPDF_AnnotType(int64_t);

    std::string _HPDF_AnnotType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_AnnotType();
}

namespace Rose {
    std::string stringify_HPDF_AnnotType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_AnnotType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 352
namespace stringify {
    const char* _HPDF_AnnotFlgs(int64_t);

    std::string _HPDF_AnnotFlgs(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_AnnotFlgs();
}

namespace Rose {
    std::string stringify_HPDF_AnnotFlgs(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_AnnotFlgs();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 363
namespace stringify {
    const char* _HPDF_AnnotHighlightMode(int64_t);

    std::string _HPDF_AnnotHighlightMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_AnnotHighlightMode();
}

namespace Rose {
    std::string stringify_HPDF_AnnotHighlightMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_AnnotHighlightMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 372
namespace stringify {
    const char* _HPDF_AnnotIcon(int64_t);

    std::string _HPDF_AnnotIcon(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_AnnotIcon();
}

namespace Rose {
    std::string stringify_HPDF_AnnotIcon(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_AnnotIcon();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 388
namespace stringify {
    const char* _HPDF_BSSubtype(int64_t);

    std::string _HPDF_BSSubtype(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_BSSubtype();
}

namespace Rose {
    std::string stringify_HPDF_BSSubtype(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_BSSubtype();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 399
namespace stringify {
    const char* _HPDF_BlendMode(int64_t);

    std::string _HPDF_BlendMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_BlendMode();
}

namespace Rose {
    std::string stringify_HPDF_BlendMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_BlendMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 417
namespace stringify {
    const char* _HPDF_TransitionStyle(int64_t);

    std::string _HPDF_TransitionStyle(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_TransitionStyle();
}

namespace Rose {
    std::string stringify_HPDF_TransitionStyle(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_TransitionStyle();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 440
namespace stringify {
    const char* _HPDF_PageSizes(int64_t);

    std::string _HPDF_PageSizes(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_PageSizes();
}

namespace Rose {
    std::string stringify_HPDF_PageSizes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageSizes();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 457
namespace stringify {
    const char* _HPDF_PageDirection(int64_t);

    std::string _HPDF_PageDirection(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_PageDirection();
}

namespace Rose {
    std::string stringify_HPDF_PageDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_PageDirection();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 463
namespace stringify {
    const char* _HPDF_EncoderType(int64_t);

    std::string _HPDF_EncoderType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_EncoderType();
}

namespace Rose {
    std::string stringify_HPDF_EncoderType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_EncoderType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 471
namespace stringify {
    const char* _HPDF_ByteType(int64_t);

    std::string _HPDF_ByteType(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_ByteType();
}

namespace Rose {
    std::string stringify_HPDF_ByteType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_ByteType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 479
namespace stringify {
    const char* _HPDF_TextAlignment(int64_t);

    std::string _HPDF_TextAlignment(int64_t, const std::string &strip);

    const std::vector<int64_t>& _HPDF_TextAlignment();
}

namespace Rose {
    std::string stringify_HPDF_TextAlignment(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_HPDF_TextAlignment();
}

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

    std::string OType(int64_t, const std::string &strip);

    const std::vector<int64_t>& OType();
}}}}

namespace Rose {
    std::string stringifySgNodeHelperPatternOutputTargetOType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgNodeHelperPatternOutputTargetOType();
}

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

    std::string LabelType(int64_t, const std::string &strip);

    const std::vector<int64_t>& LabelType();
}}}

namespace Rose {
    std::string stringifyCodeThornLabelPropertyLabelType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornLabelPropertyLabelType();
}

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

    std::string IOType(int64_t, const std::string &strip);

    const std::vector<int64_t>& IOType();
}}}

namespace Rose {
    std::string stringifyCodeThornLabelPropertyIOType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornLabelPropertyIOType();
}

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

    std::string model_elements_e(int64_t, const std::string &strip);

    const std::vector<int64_t>& model_elements_e();
}}}

namespace Rose {
    std::string stringifyMDCG_Model_model_elements_e(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMDCG_Model_model_elements_e();
}

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

    std::string kind_e(int64_t, const std::string &strip);

    const std::vector<int64_t>& kind_e();
}}}}

namespace Rose {
    std::string stringifyMDCG_Model_element_t_kind_e(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMDCG_Model_element_t_kind_e();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nameQuery.h line 74
namespace stringify { namespace NameQuery {
    const char* TypeOfQueryTypeOneParameter(int64_t);

    std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
}}

namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeOneParameter();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nameQuery.h line 94
namespace stringify { namespace NameQuery {
    const char* TypeOfQueryTypeTwoParameters(int64_t);

    std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
}}

namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeTwoParameters();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/booleanQuery.h line 43
namespace stringify { namespace BooleanQuery {
    const char* TypeOfQueryType(int64_t);

    std::string TypeOfQueryType(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeOfQueryType();
}}

namespace Rose {
    std::string stringifyBooleanQueryTypeOfQueryType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBooleanQueryTypeOfQueryType();
}

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

    std::string QueryDepth(int64_t, const std::string &strip);

    const std::vector<int64_t>& QueryDepth();
}}

namespace Rose {
    std::string stringifyAstQueryNamespaceQueryDepth(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstQueryNamespaceQueryDepth();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/numberQuery.h line 10
namespace stringify { namespace NumberQuery {
    const char* TypeOfQueryTypeOneParameter(int64_t);

    std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
}}

namespace Rose {
    std::string stringifyNumberQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeOneParameter();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/numberQuery.h line 19
namespace stringify { namespace NumberQuery {
    const char* TypeOfQueryTypeTwoParameters(int64_t);

    std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
}}

namespace Rose {
    std::string stringifyNumberQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeTwoParameters();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nodeQuery.h line 133
namespace stringify { namespace NodeQuery {
    const char* TypeOfQueryTypeOneParameter(int64_t);

    std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
}}

namespace Rose {
    std::string stringifyNodeQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeOneParameter();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nodeQuery.h line 154
namespace stringify { namespace NodeQuery {
    const char* TypeOfQueryTypeTwoParameters(int64_t);

    std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
}}

namespace Rose {
    std::string stringifyNodeQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeTwoParameters();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractMemoryObject/memory_object_impl.h line 84
namespace stringify { namespace AbstractMemoryObject { namespace IndexSet {
    const char* Index_type(int64_t);

    std::string Index_type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Index_type();
}}}

namespace Rose {
    std::string stringifyAbstractMemoryObjectIndexSetIndex_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAbstractMemoryObjectIndexSetIndex_type();
}

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

    std::string omp_rtl_enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& omp_rtl_enum();
}}

namespace Rose {
    std::string stringifyOmpSupport_omp_rtl_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOmpSupport_omp_rtl_enum();
}

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

    std::string omp_rtl_enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& omp_rtl_enum();
}

namespace Rose {
    std::string stringify_omp_rtl_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_rtl_enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/implicitCodeGeneration/defaultFunctionGenerator.C line 17
namespace stringify {
    const char* defaultEnumFunctionType(int64_t);

    std::string defaultEnumFunctionType(int64_t, const std::string &strip);

    const std::vector<int64_t>& defaultEnumFunctionType();
}

namespace Rose {
    std::string stringify_defaultEnumFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_defaultEnumFunctionType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/extractFunctionArgumentsNormalization/functionEvaluationOrderTraversal.h line 40
namespace stringify { namespace FunctionCallInfo {
    const char* InsertionMode(int64_t);

    std::string InsertionMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& InsertionMode();
}}

namespace Rose {
    std::string stringifyFunctionCallInfoInsertionMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFunctionCallInfoInsertionMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 21
namespace stringify { namespace SDG { namespace SDGNode {
    const char* NodeType(int64_t);

    std::string NodeType(int64_t, const std::string &strip);

    const std::vector<int64_t>& NodeType();
}}}

namespace Rose {
    std::string stringifySDG_SDGNodeNodeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySDG_SDGNodeNodeType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 48
namespace stringify { namespace SDG { namespace SDGEdge {
    const char* EdgeType(int64_t);

    std::string EdgeType(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeType();
}}}

namespace Rose {
    std::string stringifySDG_SDGEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySDG_SDGEdgeEdgeType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 58
namespace stringify { namespace SDG { namespace SDGEdge {
    const char* ControlDependenceType(int64_t);

    std::string ControlDependenceType(int64_t, const std::string &strip);

    const std::vector<int64_t>& ControlDependenceType();
}}}

namespace Rose {
    std::string stringifySDG_SDGEdgeControlDependenceType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySDG_SDGEdgeControlDependenceType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/PDG.h line 32
namespace stringify { namespace SDG { namespace PDGEdge {
    const char* EdgeType(int64_t);

    std::string EdgeType(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeType();
}}}

namespace Rose {
    std::string stringifySDG_PDGEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySDG_PDGEdgeEdgeType();
}

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

    std::string COLOR(int64_t, const std::string &strip);

    const std::vector<int64_t>& COLOR();
}}

namespace Rose {
    std::string stringifyPtrAliasAnalysisCOLOR(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPtrAliasAnalysisCOLOR();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/PtrAliasAnalysis.h line 33
namespace stringify { namespace PtrAliasAnalysis {
    const char* TRAVERSAL_TYPE(int64_t);

    std::string TRAVERSAL_TYPE(int64_t, const std::string &strip);

    const std::vector<int64_t>& TRAVERSAL_TYPE();
}}

namespace Rose {
    std::string stringifyPtrAliasAnalysisTRAVERSAL_TYPE(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPtrAliasAnalysisTRAVERSAL_TYPE();
}

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

    std::string COLOR(int64_t, const std::string &strip);

    const std::vector<int64_t>& COLOR();
}}

namespace Rose {
    std::string stringifyCollectAliasRelationsCOLOR(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCollectAliasRelationsCOLOR();
}

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

    std::string TRAVERSAL_TYPE(int64_t, const std::string &strip);

    const std::vector<int64_t>& TRAVERSAL_TYPE();
}}

namespace Rose {
    std::string stringifyCollectAliasRelationsTRAVERSAL_TYPE(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCollectAliasRelationsTRAVERSAL_TYPE();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/dominanceAnalysis/DominatorTree.h line 13
namespace stringify { namespace DominatorTreesAndDominanceFrontiers {
    const char* Dir_ection(int64_t);

    std::string Dir_ection(int64_t, const std::string &strip);

    const std::vector<int64_t>& Dir_ection();
}}

namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDir_ection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDir_ection();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/arithmeticIntensity/ai_measurement.h line 25
namespace stringify { namespace ArithmeticIntensityMeasurement {
    const char* running_mode_enum(int64_t);

    std::string running_mode_enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& running_mode_enum();
}}

namespace Rose {
    std::string stringifyArithmeticIntensityMeasurement_running_mode_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_running_mode_enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/arithmeticIntensity/ai_measurement.h line 30
namespace stringify { namespace ArithmeticIntensityMeasurement {
    const char* fp_operation_kind_enum(int64_t);

    std::string fp_operation_kind_enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& fp_operation_kind_enum();
}}

namespace Rose {
    std::string stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/ssaUnfilteredCfg/reachingDefUnfilteredCfg.h line 19
namespace stringify { namespace ssa_unfiltered_cfg { namespace ReachingDef {
    const char* Type(int64_t);

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}

namespace Rose {
    std::string stringify_ssa_unfiltered_cfgReachingDefType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_ssa_unfiltered_cfgReachingDefType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/dominatorTreesAndDominanceFrontiers/DominatorTree.h line 50
namespace stringify { namespace DominatorTreesAndDominanceFrontiers { namespace DominatorTree {
    const char* Direction(int64_t);

    std::string Direction(int64_t, const std::string &strip);

    const std::vector<int64_t>& Direction();
}}}

namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection();
}

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

    std::string direction(int64_t, const std::string &strip);

    const std::vector<int64_t>& direction();
}}}

namespace Rose {
    std::string stringifyCGFunction_iterator_direction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCGFunction_iterator_direction();
}

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

    std::string Vertex(int64_t, const std::string &strip);

    const std::vector<int64_t>& Vertex();
}}

namespace Rose {
    std::string stringifyTaintLatticeVertex(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTaintLatticeVertex();
}

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

    std::string levels(int64_t, const std::string &strip);

    const std::vector<int64_t>& levels();
}}

namespace Rose {
    std::string stringifyConstrGraph_levels(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyConstrGraph_levels();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Utils/BaseGraph.h line 261
namespace stringify { namespace BaseGraph { namespace BiDirNodesIterator {
    const char* dirType(int64_t);

    std::string dirType(int64_t, const std::string &strip);

    const std::vector<int64_t>& dirType();
}}}

namespace Rose {
    std::string stringifyBaseGraphBiDirNodesIterator_dirType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBaseGraphBiDirNodesIterator_dirType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/RIFG.h line 63
namespace stringify { namespace RIFG {
    const char* EdgeDirection(int64_t);

    std::string EdgeDirection(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeDirection();
}}

namespace Rose {
    std::string stringifyRIFG_EdgeDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRIFG_EdgeDirection();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/RIFG.h line 64
namespace stringify { namespace RIFG {
    const char* ForwardBackward(int64_t);

    std::string ForwardBackward(int64_t, const std::string &strip);

    const std::vector<int64_t>& ForwardBackward();
}}

namespace Rose {
    std::string stringifyRIFG_ForwardBackward(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRIFG_ForwardBackward();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/CFG.h line 83
namespace stringify { namespace CFG {
    const char* EdgeType(int64_t);

    std::string EdgeType(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeType();
}}

namespace Rose {
    std::string stringifyCFG_EdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCFG_EdgeType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/TarjanIntervals.h line 65
namespace stringify {
    const char* RITarjType(int64_t);

    std::string RITarjType(int64_t, const std::string &strip);

    const std::vector<int64_t>& RITarjType();
}

namespace Rose {
    std::string stringifyRITarjType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRITarjType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/TarjanIntervals.h line 67
namespace stringify {
    const char* RITarjEdgeType(int64_t);

    std::string RITarjEdgeType(int64_t, const std::string &strip);

    const std::vector<int64_t>& RITarjEdgeType();
}

namespace Rose {
    std::string stringifyRITarjEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRITarjEdgeType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 163
namespace stringify {
    const char* IRProcType(int64_t);

    std::string IRProcType(int64_t, const std::string &strip);

    const std::vector<int64_t>& IRProcType();
}

namespace Rose {
    std::string stringifyIRProcType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyIRProcType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 173
namespace stringify {
    const char* IRStmtType(int64_t);

    std::string IRStmtType(int64_t, const std::string &strip);

    const std::vector<int64_t>& IRStmtType();
}

namespace Rose {
    std::string stringifyIRStmtType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyIRStmtType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CallGraph/CallGraph.h line 73
namespace stringify { namespace CallGraph {
    const char* EdgeType(int64_t);

    std::string EdgeType(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeType();
}}

namespace Rose {
    std::string stringifyCallGraphEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCallGraphEdgeType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/EditDistance/TreeEditDistance.h line 60
namespace stringify { namespace Rose { namespace EditDistance { namespace TreeEditDistance {
    const char* EditType(int64_t);

    std::string EditType(int64_t, const std::string &strip);

    const std::vector<int64_t>& EditType();
}}}}

namespace Rose {
    std::string stringifyEditDistanceTreeEditDistanceEditType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyEditDistanceTreeEditDistanceEditType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/staticSingleAssignment/reachingDef.h line 18
namespace stringify { namespace ReachingDef {
    const char* Type(int64_t);

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}

namespace Rose {
    std::string stringifyReachingDefType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyReachingDefType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 52
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* ScopeIdentifier_Enum(int64_t);

    std::string ScopeIdentifier_Enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& ScopeIdentifier_Enum();
}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 66
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* PlacementPosition_Enum(int64_t);

    std::string PlacementPosition_Enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& PlacementPosition_Enum();
}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsPlacementPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsPlacementPosition_Enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 79
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* IntermediateFileStringPosition_Enum(int64_t);

    std::string IntermediateFileStringPosition_Enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& IntermediateFileStringPosition_Enum();
}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 141
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* ScopeIdentifier_Enum(int64_t);

    std::string ScopeIdentifier_Enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& ScopeIdentifier_Enum();
}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 162
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* PlacementPosition_Enum(int64_t);

    std::string PlacementPosition_Enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& PlacementPosition_Enum();
}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsPlacementPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsPlacementPosition_Enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 176
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* IntermediateFileStringPosition_Enum(int64_t);

    std::string IntermediateFileStringPosition_Enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& IntermediateFileStringPosition_Enum();
}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum();
}

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

    std::string tile_kind_e(int64_t, const std::string &strip);

    const std::vector<int64_t>& tile_kind_e();
}}

namespace Rose {
    std::string stringify_klt_tile_desc_t_tile_kind_e(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_klt_tile_desc_t_tile_kind_e();
}

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

    std::string kind_e(int64_t, const std::string &strip);

    const std::vector<int64_t>& kind_e();
}}}

namespace Rose {
    std::string stringifyKLT_LoopTree_kind_e(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyKLT_LoopTree_kind_e();
}

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

    std::string tile_kind_e(int64_t, const std::string &strip);

    const std::vector<int64_t>& tile_kind_e();
}}}

namespace Rose {
    std::string stringifyKLT_Descriptor_tile_kind_e(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyKLT_Descriptor_tile_kind_e();
}

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

    std::string Taintedness(int64_t, const std::string &strip);

    const std::vector<int64_t>& Taintedness();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisTaintedFlowTaintedness(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowTaintedness();
}

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

    std::string Approximation(int64_t, const std::string &strip);

    const std::vector<int64_t>& Approximation();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisTaintedFlowApproximation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowApproximation();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprParserTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprParserTokenType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryConcolic.h line 57
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic { namespace Update {
    const char* Flag(int64_t);

    std::string Flag(int64_t, const std::string &strip);

    const std::vector<int64_t>& Flag();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisConcolicUpdateFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicUpdateFlag();
}

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

    std::string Reason(int64_t, const std::string &strip);

    const std::vector<int64_t>& Reason();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisReachabilityReason(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisReachabilityReason();
}

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

    std::string Operator(int64_t, const std::string &strip);

    const std::vector<int64_t>& Operator();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprOperator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprOperator();
}

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

    std::string ShowComments(int64_t, const std::string &strip);

    const std::vector<int64_t>& ShowComments();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprFormatterShowComments(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprFormatterShowComments();
}

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

    std::string VisitAction(int64_t, const std::string &strip);

    const std::vector<int64_t>& VisitAction();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprVisitAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprVisitAction();
}

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

    std::string LeafType(int64_t, const std::string &strip);

    const std::vector<int64_t>& LeafType();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprLeafLeafType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprLeafLeafType();
}

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

    std::string CValKind(int64_t, const std::string &strip);

    const std::vector<int64_t>& CValKind();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFunctionSimilarityCValKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityCValKind();
}

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

    std::string Statistic(int64_t, const std::string &strip);

    const std::vector<int64_t>& Statistic();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFunctionSimilarityStatistic(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityStatistic();
}

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

    std::string SearchMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& SearchMode();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathSearchMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSearchMode();
}

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

    std::string SemanticMemoryParadigm(int64_t, const std::string &strip);

    const std::vector<int64_t>& SemanticMemoryParadigm();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm();
}

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

    std::string EdgeVisitOrder(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeVisitOrder();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder();
}

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

    std::string IoMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& IoMode();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathIoMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathIoMode();
}

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

    std::string MayOrMust(int64_t, const std::string &strip);

    const std::vector<int64_t>& MayOrMust();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathMayOrMust(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathMayOrMust();
}

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

    std::string Action(int64_t, const std::string &strip);

    const std::vector<int64_t>& Action();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathPathProcessorAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathPathProcessorAction();
}

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

    std::string State(int64_t, const std::string &strip);

    const std::vector<int64_t>& State();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisStringsState(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisStringsState();
}

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

    std::string LinkMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& LinkMode();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverLinkMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverLinkMode();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverType();
}

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

    std::string Satisfiable(int64_t, const std::string &strip);

    const std::vector<int64_t>& Satisfiable();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverSatisfiable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverSatisfiable();
}

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

    std::string StackParameterOrder(int64_t, const std::string &strip);

    const std::vector<int64_t>& StackParameterOrder();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackParameterOrder(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackParameterOrder();
}

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

    std::string StackDirection(int64_t, const std::string &strip);

    const std::vector<int64_t>& StackDirection();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackDirection();
}

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

    std::string StackCleanup(int64_t, const std::string &strip);

    const std::vector<int64_t>& StackCleanup();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackCleanup(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackCleanup();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionParameterLocationType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionParameterLocationType();
}

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

    std::string Boolean(int64_t, const std::string &strip);

    const std::vector<int64_t>& Boolean();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCommitBoolean(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCommitBoolean();
}

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

    std::string AggregationDirection(int64_t, const std::string &strip);

    const std::vector<int64_t>& AggregationDirection();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterAggregationDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterAggregationDirection();
}

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

    std::string NopPadding(int64_t, const std::string &strip);

    const std::vector<int64_t>& NopPadding();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterNopPadding(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterNopPadding();
}

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

    std::string RelocType(int64_t, const std::string &strip);

    const std::vector<int64_t>& RelocType();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterRelocType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterRelocType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/libraryIdentification/FunctionIdDatabaseInterface.h line 28
namespace stringify { namespace LibraryIdentification {
    const char* DUPLICATE_OPTION(int64_t);

    std::string DUPLICATE_OPTION(int64_t, const std::string &strip);

    const std::vector<int64_t>& DUPLICATE_OPTION();
}}

namespace Rose {
    std::string stringifyLibraryIdentificationDUPLICATE_OPTION(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyLibraryIdentificationDUPLICATE_OPTION();
}

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

    std::string Direction(int64_t, const std::string &strip);

    const std::vector<int64_t>& Direction();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDwarfLineMapperDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDwarfLineMapperDirection();
}

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

    std::string InputOutputProperty(int64_t, const std::string &strip);

    const std::vector<int64_t>& InputOutputProperty();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty();
}

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

    std::string EdgeType(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeType();
}}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType();
}

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

    std::string WritersMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& WritersMode();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode();
}

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

    std::string DefinersMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& DefinersMode();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode();
}

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

    std::string Carry(int64_t, const std::string &strip);

    const std::vector<int64_t>& Carry();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry();
}

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

    std::string AccessMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& AccessMode();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode();
}

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

    std::string Mechanism(int64_t, const std::string &strip);

    const std::vector<int64_t>& Mechanism();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisMagicNumberMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMagicNumberMechanism();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astProcessing/AstAttributeMechanism.C line 21
namespace stringify {
    const char* WarningType(int64_t);

    std::string WarningType(int64_t, const std::string &strip);

    const std::vector<int64_t>& WarningType();
}

namespace Rose {
    std::string stringifyWarningType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyWarningType();
}

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

    std::string OwnershipPolicy(int64_t, const std::string &strip);

    const std::vector<int64_t>& OwnershipPolicy();
}}

namespace Rose {
    std::string stringifyAstAttributeOwnershipPolicy(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstAttributeOwnershipPolicy();
}

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

    std::string PatternMatchMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& PatternMatchMode();
}}

namespace Rose {
    std::string stringifyMatchStatusPatternMatchMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMatchStatusPatternMatchMode();
}

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

    std::string CheckNodeMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& CheckNodeMode();
}}

namespace Rose {
    std::string stringifyMatchStatusCheckNodeMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMatchStatusCheckNodeMode();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astSnippet/Snippet.h line 319
namespace stringify { namespace Rose { namespace Snippet {
    const char* InsertMechanism(int64_t);

    std::string InsertMechanism(int64_t, const std::string &strip);

    const std::vector<int64_t>& InsertMechanism();
}}}

namespace Rose {
    std::string stringifySnippetInsertMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySnippetInsertMechanism();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astSnippet/Snippet.h line 329
namespace stringify { namespace Rose { namespace Snippet {
    const char* LocalDeclarationPosition(int64_t);

    std::string LocalDeclarationPosition(int64_t, const std::string &strip);

    const std::vector<int64_t>& LocalDeclarationPosition();
}}}

namespace Rose {
    std::string stringifySnippetLocalDeclarationPosition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySnippetLocalDeclarationPosition();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/MFB/include/MFB/Sage/graph.hpp line 35
namespace stringify { namespace MFB { namespace Graph { namespace API {
    const char* link_kind_e(int64_t);

    std::string link_kind_e(int64_t, const std::string &strip);

    const std::vector<int64_t>& link_kind_e();
}}}}

namespace Rose {
    std::string stringifyMFB_GraphAPIlink_kind_e(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMFB_GraphAPIlink_kind_e();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 100
namespace stringify { namespace AstNodeClass {
    const char* locationInTree(int64_t);

    std::string locationInTree(int64_t, const std::string &strip);

    const std::vector<int64_t>& locationInTree();
}}

namespace Rose {
    std::string stringifyAstNodeClass_locationInTree(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClass_locationInTree();
}

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

    std::string includeExcludeMechanism(int64_t, const std::string &strip);

    const std::vector<int64_t>& includeExcludeMechanism();
}}

namespace Rose {
    std::string stringifyAstNodeClass_includeExcludeMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClass_includeExcludeMechanism();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 309
namespace stringify { namespace AstNodeClass {
    const char* TypeEvaluation(int64_t);

    std::string TypeEvaluation(int64_t, const std::string &strip);

    const std::vector<int64_t>& TypeEvaluation();
}}

namespace Rose {
    std::string stringifyAstNodeClassTypeEvaluation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClassTypeEvaluation();
}

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

    std::string ConstructParamEnum(int64_t, const std::string &strip);

    const std::vector<int64_t>& ConstructParamEnum();
}

namespace Rose {
    std::string stringifyConstructParamEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyConstructParamEnum();
}

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

    std::string BuildAccessEnum(int64_t, const std::string &strip);

    const std::vector<int64_t>& BuildAccessEnum();
}

namespace Rose {
    std::string stringifyBuildAccessEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBuildAccessEnum();
}

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

    std::string CopyConfigEnum(int64_t, const std::string &strip);

    const std::vector<int64_t>& CopyConfigEnum();
}

namespace Rose {
    std::string stringifyCopyConfigEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCopyConfigEnum();
}

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

    std::string TraversalEnum(int64_t, const std::string &strip);

    const std::vector<int64_t>& TraversalEnum();
}

namespace Rose {
    std::string stringifyTraversalEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTraversalEnum();
}

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

    std::string DeleteEnum(int64_t, const std::string &strip);

    const std::vector<int64_t>& DeleteEnum();
}

namespace Rose {
    std::string stringifyDeleteEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDeleteEnum();
}

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

    std::string RiscOperator(int64_t, const std::string &strip);

    const std::vector<int64_t>& RiscOperator();
}}

namespace Rose {
    std::string stringifySgAsmRiscOperationRiscOperator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmRiscOperationRiscOperator();
}

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

    std::string MayReturn(int64_t, const std::string &strip);

    const std::vector<int64_t>& MayReturn();
}}

namespace Rose {
    std::string stringifySgAsmFunctionMayReturn(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmFunctionMayReturn();
}

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

    std::string FunctionReason(int64_t, const std::string &strip);

    const std::vector<int64_t>& FunctionReason();
}}

namespace Rose {
    std::string stringifySgAsmFunctionFunctionReason(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmFunctionFunctionReason();
}

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

    std::string function_kind_enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& function_kind_enum();
}}

namespace Rose {
    std::string stringifySgAsmFunction_function_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmFunction_function_kind_enum();
}

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

    std::string Reason(int64_t, const std::string &strip);

    const std::vector<int64_t>& Reason();
}}

namespace Rose {
    std::string stringifySgAsmBlockReason(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmBlockReason();
}

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

    std::string ObjectType(int64_t, const std::string &strip);

    const std::vector<int64_t>& ObjectType();
}}

namespace Rose {
    std::string stringifySgAsmElfFileHeaderObjectType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfFileHeaderObjectType();
}

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

    std::string SectionType(int64_t, const std::string &strip);

    const std::vector<int64_t>& SectionType();
}}

namespace Rose {
    std::string stringifySgAsmElfSectionTableEntrySectionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionType();
}

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

    std::string SectionFlags(int64_t, const std::string &strip);

    const std::vector<int64_t>& SectionFlags();
}}

namespace Rose {
    std::string stringifySgAsmElfSectionTableEntrySectionFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionFlags();
}

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

    std::string SegmentType(int64_t, const std::string &strip);

    const std::vector<int64_t>& SegmentType();
}}

namespace Rose {
    std::string stringifySgAsmElfSegmentTableEntrySegmentType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentType();
}

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

    std::string SegmentFlags(int64_t, const std::string &strip);

    const std::vector<int64_t>& SegmentFlags();
}}

namespace Rose {
    std::string stringifySgAsmElfSegmentTableEntrySegmentFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentFlags();
}

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

    std::string ElfSymBinding(int64_t, const std::string &strip);

    const std::vector<int64_t>& ElfSymBinding();
}}

namespace Rose {
    std::string stringifySgAsmElfSymbolElfSymBinding(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymBinding();
}

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

    std::string ElfSymType(int64_t, const std::string &strip);

    const std::vector<int64_t>& ElfSymType();
}}

namespace Rose {
    std::string stringifySgAsmElfSymbolElfSymType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymType();
}

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

    std::string RelocType(int64_t, const std::string &strip);

    const std::vector<int64_t>& RelocType();
}}

namespace Rose {
    std::string stringifySgAsmElfRelocEntryRelocType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfRelocEntryRelocType();
}

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

    std::string EntryType(int64_t, const std::string &strip);

    const std::vector<int64_t>& EntryType();
}}

namespace Rose {
    std::string stringifySgAsmElfDynamicEntryEntryType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfDynamicEntryEntryType();
}

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

    std::string HeaderFlags(int64_t, const std::string &strip);

    const std::vector<int64_t>& HeaderFlags();
}}

namespace Rose {
    std::string stringifySgAsmPEFileHeaderHeaderFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPEFileHeaderHeaderFlags();
}

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

    std::string Subsystem(int64_t, const std::string &strip);

    const std::vector<int64_t>& Subsystem();
}}

namespace Rose {
    std::string stringifySgAsmPEFileHeaderSubsystem(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPEFileHeaderSubsystem();
}

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

    std::string DLLFlags(int64_t, const std::string &strip);

    const std::vector<int64_t>& DLLFlags();
}}

namespace Rose {
    std::string stringifySgAsmPEFileHeaderDLLFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPEFileHeaderDLLFlags();
}

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

    std::string PairPurpose(int64_t, const std::string &strip);

    const std::vector<int64_t>& PairPurpose();
}}

namespace Rose {
    std::string stringifySgAsmPEFileHeaderPairPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPEFileHeaderPairPurpose();
}

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

    std::string PESectionFlags(int64_t, const std::string &strip);

    const std::vector<int64_t>& PESectionFlags();
}}

namespace Rose {
    std::string stringifySgAsmPESectionTableEntryPESectionFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPESectionTableEntryPESectionFlags();
}

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

    std::string SymbolDefState(int64_t, const std::string &strip);

    const std::vector<int64_t>& SymbolDefState();
}}

namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolDefState(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolDefState();
}

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

    std::string SymbolType(int64_t, const std::string &strip);

    const std::vector<int64_t>& SymbolType();
}}

namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolType();
}

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

    std::string SymbolBinding(int64_t, const std::string &strip);

    const std::vector<int64_t>& SymbolBinding();
}}

namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolBinding(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolBinding();
}

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

    std::string SectionPurpose(int64_t, const std::string &strip);

    const std::vector<int64_t>& SectionPurpose();
}}

namespace Rose {
    std::string stringifySgAsmGenericSectionSectionPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericSectionSectionPurpose();
}

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

    std::string AddressSpace(int64_t, const std::string &strip);

    const std::vector<int64_t>& AddressSpace();
}}

namespace Rose {
    std::string stringifySgAsmGenericFileAddressSpace(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericFileAddressSpace();
}

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

    std::string Elasticity(int64_t, const std::string &strip);

    const std::vector<int64_t>& Elasticity();
}}

namespace Rose {
    std::string stringifySgAsmGenericFileElasticity(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericFileElasticity();
}

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

    std::string ExecFamily(int64_t, const std::string &strip);

    const std::vector<int64_t>& ExecFamily();
}}

namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecFamily(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecFamily();
}

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

    std::string ExecABI(int64_t, const std::string &strip);

    const std::vector<int64_t>& ExecABI();
}}

namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecABI(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecABI();
}

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

    std::string InsSetArchitecture(int64_t, const std::string &strip);

    const std::vector<int64_t>& InsSetArchitecture();
}}

namespace Rose {
    std::string stringifySgAsmExecutableFileFormatInsSetArchitecture(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatInsSetArchitecture();
}

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

    std::string ExecPurpose(int64_t, const std::string &strip);

    const std::vector<int64_t>& ExecPurpose();
}}

namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecPurpose();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Tree.h line 119
namespace stringify { namespace Sawyer { namespace Tree {
    const char* TraversalEvent(int64_t);

    std::string TraversalEvent(int64_t, const std::string &strip);

    const std::vector<int64_t>& TraversalEvent();
}}}

namespace Rose {
    std::string stringifySawyerTreeTraversalEvent(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerTreeTraversalEvent();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Tree.h line 125
namespace stringify { namespace Sawyer { namespace Tree {
    const char* TraversalAction(int64_t);

    std::string TraversalAction(int64_t, const std::string &strip);

    const std::vector<int64_t>& TraversalAction();
}}}

namespace Rose {
    std::string stringifySawyerTreeTraversalAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerTreeTraversalAction();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/Tree.h line 481
namespace stringify { namespace Sawyer { namespace Tree { namespace Node {
    const char* TraversalDirection(int64_t);

    std::string TraversalDirection(int64_t, const std::string &strip);

    const std::vector<int64_t>& TraversalDirection();
}}}}

namespace Rose {
    std::string stringifySawyerTreeNodeTraversalDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerTreeNodeTraversalDirection();
}

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

    std::string TraversalEvent(int64_t, const std::string &strip);

    const std::vector<int64_t>& TraversalEvent();
}}}}

namespace Rose {
    std::string stringifySawyerContainerAlgorithmTraversalEvent(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerAlgorithmTraversalEvent();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tools/symbolFreq.C line 11
namespace stringify {
    const char* Algorithm(int64_t);

    std::string Algorithm(int64_t, const std::string &strip);

    const std::vector<int64_t>& Algorithm();
}

namespace Rose {
    std::string stringifyAlgorithm(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAlgorithm();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/Sawyer/Access.h line 12
namespace stringify { namespace Sawyer { namespace Access {
    const char* Access(int64_t);

    std::string Access(int64_t, const std::string &strip);

    const std::vector<int64_t>& Access();
}}}

namespace Rose {
    std::string stringifySawyerAccessAccess(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerAccessAccess();
}

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

    std::string SortOrder(int64_t, const std::string &strip);

    const std::vector<int64_t>& SortOrder();
}}}

namespace Rose {
    std::string stringifySawyerCommandLineSortOrder(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineSortOrder();
}

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

    std::string Canonical(int64_t, const std::string &strip);

    const std::vector<int64_t>& Canonical();
}}}

namespace Rose {
    std::string stringifySawyerCommandLineCanonical(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineCanonical();
}

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

    std::string ShowGroupName(int64_t, const std::string &strip);

    const std::vector<int64_t>& ShowGroupName();
}}}

namespace Rose {
    std::string stringifySawyerCommandLineShowGroupName(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineShowGroupName();
}

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

    std::string SwitchSkipping(int64_t, const std::string &strip);

    const std::vector<int64_t>& SwitchSkipping();
}}}

namespace Rose {
    std::string stringifySawyerCommandLineSwitchSkipping(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineSwitchSkipping();
}

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

    std::string WhichValue(int64_t, const std::string &strip);

    const std::vector<int64_t>& WhichValue();
}}}

namespace Rose {
    std::string stringifySawyerCommandLineWhichValue(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineWhichValue();
}

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

    std::string GroupingFlags(int64_t, const std::string &strip);

    const std::vector<int64_t>& GroupingFlags();
}}}}

namespace Rose {
    std::string stringifySawyerCommandLineParserGroupingFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineParserGroupingFlags();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/Sawyer/DocumentMarkup.h line 35
namespace stringify { namespace Sawyer { namespace Document { namespace Markup {
    const char* TokenType(int64_t);

    std::string TokenType(int64_t, const std::string &strip);

    const std::vector<int64_t>& TokenType();
}}}}

namespace Rose {
    std::string stringifySawyerDocumentMarkupTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerDocumentMarkupTokenType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/Sawyer/Clexer.h line 18
namespace stringify { namespace Sawyer { namespace Language { namespace Clexer {
    const char* TokenType(int64_t);

    std::string TokenType(int64_t, const std::string &strip);

    const std::vector<int64_t>& TokenType();
}}}}

namespace Rose {
    std::string stringifySawyerLanguageClexerTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerLanguageClexerTokenType();
}

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

    std::string CsiNextAction(int64_t, const std::string &strip);

    const std::vector<int64_t>& CsiNextAction();
}}}}

namespace Rose {
    std::string stringifySawyerContainerAlgorithmCsiNextAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerAlgorithmCsiNextAction();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/Sawyer/Graph.h line 629
namespace stringify { namespace Sawyer { namespace Container { namespace Graph {
    const char* EdgePhase(int64_t);

    std::string EdgePhase(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgePhase();
}}}}

namespace Rose {
    std::string stringifySawyerContainerGraphEdgePhase(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerGraphEdgePhase();
}

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

    std::string Importance(int64_t, const std::string &strip);

    const std::vector<int64_t>& Importance();
}}}

namespace Rose {
    std::string stringifySawyerMessageImportance(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessageImportance();
}

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

    std::string AnsiColor(int64_t, const std::string &strip);

    const std::vector<int64_t>& AnsiColor();
}}}

namespace Rose {
    std::string stringifySawyerMessageAnsiColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessageAnsiColor();
}

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

    std::string When(int64_t, const std::string &strip);

    const std::vector<int64_t>& When();
}}}}

namespace Rose {
    std::string stringifySawyerMessagePrefixWhen(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessagePrefixWhen();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/Assert/demo1.C line 11
namespace stringify {
    const char* Color(int64_t);

    std::string Color(int64_t, const std::string &strip);

    const std::vector<int64_t>& Color();
}

namespace Rose {
    std::string stringifyColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColor();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/Tree/treeUnitTests.C line 430
namespace stringify { namespace BinaryExpr {
    const char* Operator(int64_t);

    std::string Operator(int64_t, const std::string &strip);

    const std::vector<int64_t>& Operator();
}}

namespace Rose {
    std::string stringifyBinaryExprOperator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryExprOperator();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/CommandLine/cmdUnitTests.C line 628
namespace stringify {
    const char* TestColor(int64_t);

    std::string TestColor(int64_t, const std::string &strip);

    const std::vector<int64_t>& TestColor();
}

namespace Rose {
    std::string stringifyTestColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTestColor();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/CommandLine/cmdUnitTests.C line 914
namespace stringify {
    const char* Test23Enum(int64_t);

    std::string Test23Enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& Test23Enum();
}

namespace Rose {
    std::string stringifyTest23Enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTest23Enum();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/CommandLine/grepExample.C line 5
namespace stringify {
    const char* Matcher(int64_t);

    std::string Matcher(int64_t, const std::string &strip);

    const std::vector<int64_t>& Matcher();
}

namespace Rose {
    std::string stringifyMatcher(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMatcher();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/CommandLine/grepExample.C line 6
namespace stringify {
    const char* ColorWhen(int64_t);

    std::string ColorWhen(int64_t, const std::string &strip);

    const std::vector<int64_t>& ColorWhen();
}

namespace Rose {
    std::string stringifyColorWhen(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorWhen();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/CommandLine/grepExample.C line 7
namespace stringify {
    const char* BinaryFile(int64_t);

    std::string BinaryFile(int64_t, const std::string &strip);

    const std::vector<int64_t>& BinaryFile();
}

namespace Rose {
    std::string stringifyBinaryFile(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryFile();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/CommandLine/grepExample.C line 8
namespace stringify {
    const char* Action(int64_t);

    std::string Action(int64_t, const std::string &strip);

    const std::vector<int64_t>& Action();
}

namespace Rose {
    std::string stringifyAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAction();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Sawyer/sawyer-20190524/tests/CommandLine/demo1.C line 6
namespace stringify {
    const char* WhenColor(int64_t);

    std::string WhenColor(int64_t, const std::string &strip);

    const std::vector<int64_t>& WhenColor();
}

namespace Rose {
    std::string stringifyWhenColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyWhenColor();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/stringSupport/FileUtility.h line 25
namespace stringify { namespace Rose { namespace StringUtility {
    const char* OSType(int64_t);

    std::string OSType(int64_t, const std::string &strip);

    const std::vector<int64_t>& OSType();
}}}

namespace Rose {
    std::string stringifyStringUtilityOSType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyStringUtilityOSType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/stringSupport/FileUtility.h line 150
namespace stringify { namespace Rose { namespace StringUtility {
    const char* FileNameLocation(int64_t);

    std::string FileNameLocation(int64_t, const std::string &strip);

    const std::vector<int64_t>& FileNameLocation();
}}}

namespace Rose {
    std::string stringifyStringUtilityFileNameLocation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyStringUtilityFileNameLocation();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/Color.h line 236
namespace stringify { namespace Rose { namespace Color {
    const char* AnsiColor(int64_t);

    std::string AnsiColor(int64_t, const std::string &strip);

    const std::vector<int64_t>& AnsiColor();
}}}

namespace Rose {
    std::string stringifyColorAnsiColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorAnsiColor();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/sageInterface/sageBuilder.h line 138
namespace stringify { namespace SageBuilder {
    const char* SourcePositionClassification(int64_t);

    std::string SourcePositionClassification(int64_t, const std::string &strip);

    const std::vector<int64_t>& SourcePositionClassification();
}}

namespace Rose {
    std::string stringifySageBuilderSourcePositionClassification(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySageBuilderSourcePositionClassification();
}

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

    std::string omp_construct_enum(int64_t, const std::string &strip);

    const std::vector<int64_t>& omp_construct_enum();
}}

namespace Rose {
    std::string stringifyOmpSupport_omp_construct_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOmpSupport_omp_construct_enum();
}

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

    std::string omp_lock_hint_t(int64_t, const std::string &strip);

    const std::vector<int64_t>& omp_lock_hint_t();
}

namespace Rose {
    std::string stringify_omp_lock_hint_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_lock_hint_t();
}

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

    std::string omp_sched_t(int64_t, const std::string &strip);

    const std::vector<int64_t>& omp_sched_t();
}

namespace Rose {
    std::string stringify_omp_sched_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_sched_t();
}

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

    std::string omp_proc_bind_t(int64_t, const std::string &strip);

    const std::vector<int64_t>& omp_proc_bind_t();
}

namespace Rose {
    std::string stringify_omp_proc_bind_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_proc_bind_t();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 25
namespace stringify { namespace AstAttributeDOT {
    const char* DOTStyles(int64_t);

    std::string DOTStyles(int64_t, const std::string &strip);

    const std::vector<int64_t>& DOTStyles();
}}

namespace Rose {
    std::string stringifyAstAttributeDOT_DOTStyles(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstAttributeDOT_DOTStyles();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 90
namespace stringify { namespace DOTGraphNode {
    const char* DOTShapeTypes(int64_t);

    std::string DOTShapeTypes(int64_t, const std::string &strip);

    const std::vector<int64_t>& DOTShapeTypes();
}}

namespace Rose {
    std::string stringifyDOTGraphNodeDOTShapeTypes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGraphNodeDOTShapeTypes();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 137
namespace stringify { namespace DOTGraphEdge {
    const char* DOTArrowTypes(int64_t);

    std::string DOTArrowTypes(int64_t, const std::string &strip);

    const std::vector<int64_t>& DOTArrowTypes();
}}

namespace Rose {
    std::string stringifyDOTGraphEdgeDOTArrowTypes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGraphEdgeDOTArrowTypes();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/astGraph.h line 12
namespace stringify { namespace AST_Graph {
    const char* pointerHandling(int64_t);

    std::string pointerHandling(int64_t, const std::string &strip);

    const std::vector<int64_t>& pointerHandling();
}}

namespace Rose {
    std::string stringifyAST_Graph_pointerHandling(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_Graph_pointerHandling();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/astGraph.h line 19
namespace stringify { namespace AST_Graph {
    const char* traversalType(int64_t);

    std::string traversalType(int64_t, const std::string &strip);

    const std::vector<int64_t>& traversalType();
}}

namespace Rose {
    std::string stringifyAST_Graph_traversalType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_Graph_traversalType();
}

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

    std::string RelativePositionType(int64_t, const std::string &strip);

    const std::vector<int64_t>& RelativePositionType();
}}

namespace Rose {
    std::string stringifyPreprocessingInfoRelativePositionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPreprocessingInfoRelativePositionType();
}

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

    std::string DirectiveType(int64_t, const std::string &strip);

    const std::vector<int64_t>& DirectiveType();
}}

namespace Rose {
    std::string stringifyPreprocessingInfoDirectiveType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPreprocessingInfoDirectiveType();
}

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

    std::string languageTypeEnum(int64_t, const std::string &strip);

    const std::vector<int64_t>& languageTypeEnum();
}}

namespace Rose {
    std::string stringifyROSEAttributesList_languageTypeEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSEAttributesList_languageTypeEnum();
}

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

    std::string EdgeConditionKind(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeConditionKind();
}}

namespace Rose {
    std::string stringifyVirtualCFG_EdgeConditionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyVirtualCFG_EdgeConditionKind();
}

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

    std::string EdgeConditionKind(int64_t, const std::string &strip);

    const std::vector<int64_t>& EdgeConditionKind();
}}

namespace Rose {
    std::string stringifyVirtualBinCFG_EdgeConditionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyVirtualBinCFG_EdgeConditionKind();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 12
namespace stringify { namespace ROSE_token_ids {
    const char* whitespace(int64_t);

    std::string whitespace(int64_t, const std::string &strip);

    const std::vector<int64_t>& whitespace();
}}

namespace Rose {
    std::string stringifyROSE_token_ids_whitespace(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_ids_whitespace();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 21
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_keywords(int64_t);

    std::string ROSE_C_CXX_keywords(int64_t, const std::string &strip);

    const std::vector<int64_t>& ROSE_C_CXX_keywords();
}}

namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_keywords();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 159
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_alternate_tok(int64_t);

    std::string ROSE_C_CXX_alternate_tok(int64_t, const std::string &strip);

    const std::vector<int64_t>& ROSE_C_CXX_alternate_tok();
}}

namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_alternate_tok(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_alternate_tok();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 171
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_Additional_Info(int64_t);

    std::string ROSE_C_CXX_Additional_Info(int64_t, const std::string &strip);

    const std::vector<int64_t>& ROSE_C_CXX_Additional_Info();
}}

namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_Additional_Info();
}

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

    std::string ops(int64_t, const std::string &strip);

    const std::vector<int64_t>& ops();
}

namespace Rose {
    std::string stringify_ops(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_ops();
}

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

    std::string ProgramSpec(int64_t, const std::string &strip);

    const std::vector<int64_t>& ProgramSpec();
}}

namespace Rose {
    std::string stringifyCobol_ROSE_TranslationProgramSpec(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCobol_ROSE_TranslationProgramSpec();
}

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

    std::string ExpressionKind(int64_t, const std::string &strip);

    const std::vector<int64_t>& ExpressionKind();
}}

namespace Rose {
    std::string stringifyCobol_ROSE_TranslationExpressionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCobol_ROSE_TranslationExpressionKind();
}

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

    std::string a_control_flow_descr_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_control_flow_descr_kind_tag();
}

namespace Rose {
    std::string stringify_a_control_flow_descr_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_control_flow_descr_kind_tag();
}

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

    std::string a_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_kind();
}}

namespace Rose {
    std::string stringify_a_type_wrapper_a_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_wrapper_a_kind();
}

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

    std::string a_class_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_class_kind();
}}

namespace Rose {
    std::string stringify_a_class_type_wrapper_a_class_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_class_type_wrapper_a_class_kind();
}

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

    std::string an_indirection_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_indirection_kind();
}}

namespace Rose {
    std::string stringify_a_type_indirection_an_indirection_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_indirection_an_indirection_kind();
}

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

    std::string an_array_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_array_kind();
}}

namespace Rose {
    std::string stringify_an_array_type_wrapper_an_array_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_array_type_wrapper_an_array_kind();
}

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

    std::string access_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& access_kind();
}}

namespace Rose {
    std::string stringify_an_accessibility_access_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_accessibility_access_kind();
}

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

    std::string a_type_definition_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_type_definition_kind();
}}

namespace Rose {
    std::string stringify_a_type_definition_a_type_definition_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_definition_a_type_definition_kind();
}

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

    std::string an_insert_location_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_insert_location_kind();
}

namespace Rose {
    std::string stringify_an_insert_location_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_insert_location_kind();
}

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

    std::string a_type_info_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_type_info_kind_tag();
}

namespace Rose {
    std::string stringify_a_type_info_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_info_kind_tag();
}

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

    std::string a_unicode_source_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_unicode_source_kind_tag();
}

namespace Rose {
    std::string stringify_a_unicode_source_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_unicode_source_kind_tag();
}

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

    std::string a_predef_macro_mode(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_predef_macro_mode();
}

namespace Rose {
    std::string stringify_a_predef_macro_mode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_predef_macro_mode();
}

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

    std::string an_end_of_decl_action(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_end_of_decl_action();
}

namespace Rose {
    std::string stringify_an_end_of_decl_action(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_end_of_decl_action();
}

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

    std::string an_expression_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_expression_kind_tag();
}

namespace Rose {
    std::string stringify_an_expression_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_expression_kind_tag();
}

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

    std::string a_cast_source_form(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_cast_source_form();
}

namespace Rose {
    std::string stringify_a_cast_source_form(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cast_source_form();
}

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

    std::string a_type_class_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_type_class_kind();
}

namespace Rose {
    std::string stringify_a_type_class_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_class_kind();
}

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

    std::string an_operand_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_operand_kind_tag();
}

namespace Rose {
    std::string stringify_an_operand_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_operand_kind_tag();
}

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

    std::string an_operand_state_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_operand_state_tag();
}

namespace Rose {
    std::string stringify_an_operand_state_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_operand_state_tag();
}

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

    std::string a_multiversion_arch_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_multiversion_arch_kind_tag();
}

namespace Rose {
    std::string stringify_a_multiversion_arch_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_multiversion_arch_kind_tag();
}

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

    std::string a_function_number_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_function_number_tag();
}

namespace Rose {
    std::string stringify_a_function_number_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_function_number_tag();
}

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

    std::string a_pragma_binding_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_pragma_binding_kind();
}

namespace Rose {
    std::string stringify_a_pragma_binding_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_pragma_binding_kind();
}

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

    std::string a_symbol_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_symbol_kind_tag();
}

namespace Rose {
    std::string stringify_a_symbol_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_symbol_kind_tag();
}

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

    std::string a_dependent_type_fixup_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_dependent_type_fixup_kind_tag();
}

namespace Rose {
    std::string stringify_a_dependent_type_fixup_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_dependent_type_fixup_kind_tag();
}

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

    std::string a_cli_operator_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_cli_operator_kind_tag();
}

namespace Rose {
    std::string stringify_a_cli_operator_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cli_operator_kind_tag();
}

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

    std::string a_cli_symbol_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_cli_symbol_kind_tag();
}

namespace Rose {
    std::string stringify_a_cli_symbol_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cli_symbol_kind_tag();
}

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

    std::string a_diagnostic_category_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_diagnostic_category_kind_tag();
}

namespace Rose {
    std::string stringify_a_diagnostic_category_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_diagnostic_category_kind_tag();
}

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

    std::string a_message_segment_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_message_segment_kind_tag();
}

namespace Rose {
    std::string stringify_a_message_segment_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_message_segment_kind_tag();
}

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

    std::string an_init_component_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_init_component_kind_tag();
}

namespace Rose {
    std::string stringify_an_init_component_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_init_component_kind_tag();
}

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

    std::string an_access_specifier_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_access_specifier_tag();
}

namespace Rose {
    std::string stringify_an_access_specifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_access_specifier_tag();
}

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

    std::string an_assembly_visibility_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_assembly_visibility_tag();
}

namespace Rose {
    std::string stringify_an_assembly_visibility_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_assembly_visibility_tag();
}

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

    std::string a_name_linkage_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_name_linkage_kind_tag();
}

namespace Rose {
    std::string stringify_a_name_linkage_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_name_linkage_kind_tag();
}

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

    std::string an_element_position_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_element_position_kind_tag();
}

namespace Rose {
    std::string stringify_an_element_position_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_element_position_kind_tag();
}

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

    std::string an_ELF_visibility_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_ELF_visibility_kind_tag();
}

namespace Rose {
    std::string stringify_an_ELF_visibility_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ELF_visibility_kind_tag();
}

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

    std::string an_attribute_arg_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_attribute_arg_kind_tag();
}

namespace Rose {
    std::string stringify_an_attribute_arg_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_attribute_arg_kind_tag();
}

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

    std::string an_attribute_family_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_attribute_family_tag();
}

namespace Rose {
    std::string stringify_an_attribute_family_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_attribute_family_tag();
}

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

    std::string an_attribute_location_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_attribute_location_tag();
}

namespace Rose {
    std::string stringify_an_attribute_location_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_attribute_location_tag();
}

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

    std::string an_attribute_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_attribute_kind_tag();
}

namespace Rose {
    std::string stringify_an_attribute_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_attribute_kind_tag();
}

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

    std::string a_constant_repr_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_constant_repr_kind_tag();
}

namespace Rose {
    std::string stringify_a_constant_repr_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_constant_repr_kind_tag();
}

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

    std::string an_address_base_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_address_base_kind_tag();
}

namespace Rose {
    std::string stringify_an_address_base_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_address_base_kind_tag();
}

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

    std::string a_dynamic_init_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_dynamic_init_kind_tag();
}

namespace Rose {
    std::string stringify_a_dynamic_init_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_dynamic_init_kind_tag();
}

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

    std::string a_template_param_constant_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_template_param_constant_kind_tag();
}

namespace Rose {
    std::string stringify_a_template_param_constant_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_template_param_constant_kind_tag();
}

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

    std::string a_character_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_character_kind_tag();
}

namespace Rose {
    std::string stringify_a_character_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_character_kind_tag();
}

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

    std::string a_special_function_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_special_function_kind_tag();
}

namespace Rose {
    std::string stringify_a_special_function_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_special_function_kind_tag();
}

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

    std::string a_type_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_type_kind_tag();
}

namespace Rose {
    std::string stringify_a_type_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_kind_tag();
}

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

    std::string an_integer_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_integer_kind_tag();
}

namespace Rose {
    std::string stringify_an_integer_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_integer_kind_tag();
}

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

    std::string a_fixed_point_precision_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_fixed_point_precision_tag();
}

namespace Rose {
    std::string stringify_a_fixed_point_precision_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_fixed_point_precision_tag();
}

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

    std::string a_float_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_float_kind_tag();
}

namespace Rose {
    std::string stringify_a_float_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_float_kind_tag();
}

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

    std::string a_type_mode_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_type_mode_kind_tag();
}

namespace Rose {
    std::string stringify_a_type_mode_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_mode_kind_tag();
}

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

    std::string an_asm_operand_constraint_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_asm_operand_constraint_kind_tag();
}

namespace Rose {
    std::string stringify_an_asm_operand_constraint_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_asm_operand_constraint_kind_tag();
}

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

    std::string an_asm_operand_modifier_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_asm_operand_modifier_tag();
}

namespace Rose {
    std::string stringify_an_asm_operand_modifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_asm_operand_modifier_tag();
}

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

    std::string a_named_register_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_named_register_tag();
}

namespace Rose {
    std::string stringify_a_named_register_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_named_register_tag();
}

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

    std::string a_type_qualifier_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_type_qualifier_tag();
}

namespace Rose {
    std::string stringify_a_type_qualifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_qualifier_tag();
}

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

    std::string a_upc_pragma_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_upc_pragma_kind_tag();
}

namespace Rose {
    std::string stringify_a_upc_pragma_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_upc_pragma_kind_tag();
}

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

    std::string a_upc_access_method_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_upc_access_method_tag();
}

namespace Rose {
    std::string stringify_a_upc_access_method_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_upc_access_method_tag();
}

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

    std::string a_upc_coherence_stack_operation_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_upc_coherence_stack_operation_tag();
}

namespace Rose {
    std::string stringify_a_upc_coherence_stack_operation_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_upc_coherence_stack_operation_tag();
}

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

    std::string a_stdc_pragma_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_stdc_pragma_kind_tag();
}

namespace Rose {
    std::string stringify_a_stdc_pragma_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_stdc_pragma_kind_tag();
}

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

    std::string a_stdc_pragma_value_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_stdc_pragma_value_tag();
}

namespace Rose {
    std::string stringify_a_stdc_pragma_value_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_stdc_pragma_value_tag();
}

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

    std::string a_gcc_pragma_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_gcc_pragma_kind_tag();
}

namespace Rose {
    std::string stringify_a_gcc_pragma_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_gcc_pragma_kind_tag();
}

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

    std::string a_pragma_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_pragma_kind_tag();
}

namespace Rose {
    std::string stringify_a_pragma_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_pragma_kind_tag();
}

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

    std::string a_microsoft_pragma_comment_type_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_microsoft_pragma_comment_type_tag();
}

namespace Rose {
    std::string stringify_a_microsoft_pragma_comment_type_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_microsoft_pragma_comment_type_tag();
}

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

    std::string a_microsoft_pragma_conform_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_microsoft_pragma_conform_kind_tag();
}

namespace Rose {
    std::string stringify_a_microsoft_pragma_conform_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_microsoft_pragma_conform_kind_tag();
}

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

    std::string a_calling_convention_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_calling_convention_tag();
}

namespace Rose {
    std::string stringify_a_calling_convention_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_calling_convention_tag();
}

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

    std::string a_decl_modifier_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_decl_modifier_tag();
}

namespace Rose {
    std::string stringify_a_decl_modifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_decl_modifier_tag();
}

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

    std::string a_ref_qualifier_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_ref_qualifier_kind_tag();
}

namespace Rose {
    std::string stringify_a_ref_qualifier_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_ref_qualifier_kind_tag();
}

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

    std::string a_templ_arg_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_templ_arg_kind_tag();
}

namespace Rose {
    std::string stringify_a_templ_arg_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_templ_arg_kind_tag();
}

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

    std::string an_anonymous_union_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_anonymous_union_kind_tag();
}

namespace Rose {
    std::string stringify_an_anonymous_union_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_anonymous_union_kind_tag();
}

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

    std::string an_inheritance_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_inheritance_kind_tag();
}

namespace Rose {
    std::string stringify_an_inheritance_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_inheritance_kind_tag();
}

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

    std::string a_cli_class_type_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_cli_class_type_kind_tag();
}

namespace Rose {
    std::string stringify_a_cli_class_type_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cli_class_type_kind_tag();
}

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

    std::string a_property_or_event_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_property_or_event_kind_tag();
}

namespace Rose {
    std::string stringify_a_property_or_event_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_property_or_event_kind_tag();
}

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

    std::string a_rewritten_property_reference_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_rewritten_property_reference_kind_tag();
}

namespace Rose {
    std::string stringify_a_rewritten_property_reference_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_rewritten_property_reference_kind_tag();
}

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

    std::string a_template_param_type_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_template_param_type_kind_tag();
}

namespace Rose {
    std::string stringify_a_template_param_type_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_template_param_type_kind_tag();
}

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

    std::string a_based_type_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_based_type_kind_tag();
}

namespace Rose {
    std::string stringify_a_based_type_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_based_type_kind_tag();
}

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

    std::string a_pointer_modifier_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_pointer_modifier_tag();
}

namespace Rose {
    std::string stringify_a_pointer_modifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_pointer_modifier_tag();
}

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

    std::string a_storage_class_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_storage_class_tag();
}

namespace Rose {
    std::string stringify_a_storage_class_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_storage_class_tag();
}

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

    std::string an_init_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_init_kind_tag();
}

namespace Rose {
    std::string stringify_an_init_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_init_kind_tag();
}

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

    std::string an_opname_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_opname_kind_tag();
}

namespace Rose {
    std::string stringify_an_opname_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_opname_kind_tag();
}

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

    std::string a_builtin_function_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_builtin_function_kind_tag();
}

namespace Rose {
    std::string stringify_a_builtin_function_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_function_kind_tag();
}

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

    std::string a_ctor_or_dtor_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_ctor_or_dtor_kind_tag();
}

namespace Rose {
    std::string stringify_a_ctor_or_dtor_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_ctor_or_dtor_kind_tag();
}

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

    std::string an_expr_node_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_expr_node_kind_tag();
}

namespace Rose {
    std::string stringify_an_expr_node_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_expr_node_kind_tag();
}

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

    std::string a_lowered_eh_construct_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_lowered_eh_construct_kind_tag();
}

namespace Rose {
    std::string stringify_a_lowered_eh_construct_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_lowered_eh_construct_kind_tag();
}

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

    std::string an_expr_operator_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_expr_operator_kind_tag();
}

namespace Rose {
    std::string stringify_an_expr_operator_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_expr_operator_kind_tag();
}

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

    std::string a_builtin_operation_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_builtin_operation_kind_tag();
}

namespace Rose {
    std::string stringify_a_builtin_operation_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_operation_kind_tag();
}

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

    std::string a_local_expr_node_ref_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_local_expr_node_ref_kind_tag();
}

namespace Rose {
    std::string stringify_a_local_expr_node_ref_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_local_expr_node_ref_kind_tag();
}

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

    std::string a_statement_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_statement_kind_tag();
}

namespace Rose {
    std::string stringify_a_statement_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_statement_kind_tag();
}

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

    std::string a_for_each_pattern_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_for_each_pattern_kind_tag();
}

namespace Rose {
    std::string stringify_a_for_each_pattern_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_for_each_pattern_kind_tag();
}

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

    std::string a_constructor_init_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_constructor_init_kind_tag();
}

namespace Rose {
    std::string stringify_a_constructor_init_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_constructor_init_kind_tag();
}

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

    std::string a_generic_constraint_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_generic_constraint_kind_tag();
}

namespace Rose {
    std::string stringify_a_generic_constraint_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_generic_constraint_kind_tag();
}

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

    std::string a_template_parameter_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_template_parameter_kind_tag();
}

namespace Rose {
    std::string stringify_a_template_parameter_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_template_parameter_kind_tag();
}

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

    std::string a_template_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_template_kind_tag();
}

namespace Rose {
    std::string stringify_a_template_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_template_kind_tag();
}

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

    std::string an_object_lifetime_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_object_lifetime_kind_tag();
}

namespace Rose {
    std::string stringify_an_object_lifetime_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_object_lifetime_kind_tag();
}

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

    std::string an_ms_attribute_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_ms_attribute_kind_tag();
}

namespace Rose {
    std::string stringify_an_ms_attribute_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ms_attribute_kind_tag();
}

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

    std::string an_ms_attribute_arg_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_ms_attribute_arg_kind_tag();
}

namespace Rose {
    std::string stringify_an_ms_attribute_arg_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ms_attribute_arg_kind_tag();
}

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

    std::string a_scope_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_scope_kind_tag();
}

namespace Rose {
    std::string stringify_a_scope_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_scope_kind_tag();
}

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

    std::string a_cpp_cli_import_flag_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_cpp_cli_import_flag_tag();
}

namespace Rose {
    std::string stringify_a_cpp_cli_import_flag_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cpp_cli_import_flag_tag();
}

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

    std::string a_token_extra_info_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_token_extra_info_kind_tag();
}

namespace Rose {
    std::string stringify_a_token_extra_info_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_token_extra_info_kind_tag();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/util/decode.c line 4037
namespace stringify {
    const char* a_substitution_kind(int64_t);

    std::string a_substitution_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_substitution_kind();
}

namespace Rose {
    std::string stringify_a_substitution_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_substitution_kind();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/lib_src/eh.h line 309
namespace stringify {
    const char* an_eh_stack_entry_kind_tag(int64_t);

    std::string an_eh_stack_entry_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& an_eh_stack_entry_kind_tag();
}

namespace Rose {
    std::string stringify_an_eh_stack_entry_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_eh_stack_entry_kind_tag();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/lib_src/rtti.c line 109
namespace stringify {
    const char* a_result_virtuality(int64_t);

    std::string a_result_virtuality(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_result_virtuality();
}

namespace Rose {
    std::string stringify_a_result_virtuality(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_result_virtuality();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/include/cxxabi.h line 62
namespace stringify { namespace __cxxabiv1 { namespace __base_class_type_info {
    const char* __offset_flags_masks(int64_t);

    std::string __offset_flags_masks(int64_t, const std::string &strip);

    const std::vector<int64_t>& __offset_flags_masks();
}}}

namespace Rose {
    std::string stringify__cxxabiv1__base_class_type_info__offset_flags_masks(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify__cxxabiv1__base_class_type_info__offset_flags_masks();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/include/cxxabi.h line 77
namespace stringify { namespace __cxxabiv1 { namespace __vmi_class_type_info {
    const char* __flags_masks(int64_t);

    std::string __flags_masks(int64_t, const std::string &strip);

    const std::vector<int64_t>& __flags_masks();
}}}

namespace Rose {
    std::string stringify__cxxabiv1__vmi_class_type_info__flags_masks(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify__cxxabiv1__vmi_class_type_info__flags_masks();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.9/include/cxxabi.h line 90
namespace stringify { namespace __cxxabiv1 { namespace __pbase_type_info {
    const char* __masks(int64_t);

    std::string __masks(int64_t, const std::string &strip);

    const std::vector<int64_t>& __masks();
}}}

namespace Rose {
    std::string stringify__cxxabiv1__pbase_type_info__masks(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify__cxxabiv1__pbase_type_info__masks();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/edgRose.C line 6266
namespace stringify {
    const char* kinds_of_type_references(int64_t);

    std::string kinds_of_type_references(int64_t, const std::string &strip);

    const std::vector<int64_t>& kinds_of_type_references();
}

namespace Rose {
    std::string stringify_kinds_of_type_references(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_kinds_of_type_references();
}

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

    std::string a_builtin_user_function_kind_tag(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_builtin_user_function_kind_tag();
}

namespace Rose {
    std::string stringify_a_builtin_user_function_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_user_function_kind_tag();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/builtin_defs.h line 22
namespace stringify {
    const char* a_builtin_function_type_index(int64_t);

    std::string a_builtin_function_type_index(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_builtin_function_type_index();
}

namespace Rose {
    std::string stringify_a_builtin_function_type_index(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_function_type_index();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/builtin_defs.h line 4189
namespace stringify {
    const char* a_builtin_function_condition_index(int64_t);

    std::string a_builtin_function_condition_index(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_builtin_function_condition_index();
}

namespace Rose {
    std::string stringify_a_builtin_function_condition_index(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_function_condition_index();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/disp/error.c line 91
namespace stringify {
    const char* a_diag_fill_in_kind(int64_t);

    std::string a_diag_fill_in_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_diag_fill_in_kind();
}

namespace Rose {
    std::string stringify_a_diag_fill_in_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_diag_fill_in_kind();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.14/src/disp/error.c line 196
namespace stringify {
    const char* a_diagnostic_kind(int64_t);

    std::string a_diagnostic_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_diagnostic_kind();
}

namespace Rose {
    std::string stringify_a_diagnostic_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_diagnostic_kind();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_4.4/src/ms_metadata.cpp line 880
namespace stringify {
    const char* a_top_level_kind(int64_t);

    std::string a_top_level_kind(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_top_level_kind();
}

namespace Rose {
    std::string stringify_a_top_level_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_top_level_kind();
}

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

    std::string a_designation_state(int64_t, const std::string &strip);

    const std::vector<int64_t>& a_designation_state();
}

namespace Rose {
    std::string stringify_a_designation_state(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_designation_state();
}

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

    std::string Language(int64_t, const std::string &strip);

    const std::vector<int64_t>& Language();
}}

namespace Rose {
    std::string stringifyClangToSageTranslatorLanguage(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyClangToSageTranslatorLanguage();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Jovial_ROSE_Connection/Jovial_to_ROSE_translation.h line 11
namespace stringify { namespace Jovial_ROSE_Translation {
    const char* ExpressionKind(int64_t);

    std::string ExpressionKind(int64_t, const std::string &strip);

    const std::vector<int64_t>& ExpressionKind();
}}

namespace Rose {
    std::string stringifyJovial_ROSE_TranslationExpressionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyJovial_ROSE_TranslationExpressionKind();
}

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

    std::string Type(int64_t, const std::string &strip);

    const std::vector<int64_t>& Type();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSRecordType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSRecordType();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/MemoryMap.h line 126
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap { namespace Attach {
    const char* Boolean(int64_t);

    std::string Boolean(int64_t, const std::string &strip);

    const std::vector<int64_t>& Boolean();
}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisMemoryMapAttachBoolean(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapAttachBoolean();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/MemoryMap.h line 282
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap {
    const char* InsertFileMapMode(int64_t);

    std::string InsertFileMapMode(int64_t, const std::string &strip);

    const std::vector<int64_t>& InsertFileMapMode();
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisMemoryMapInsertFileMapMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapInsertFileMapMode();
}

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

    std::string Endianness(int64_t, const std::string &strip);

    const std::vector<int64_t>& Endianness();
}}

namespace Rose {
    std::string stringifyByteOrderEndianness(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyByteOrderEndianness();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Csharp_ROSE_Connection/ast2dot.hpp line 11
namespace stringify { namespace dot {
    const char* attr_set(int64_t);

    std::string attr_set(int64_t, const std::string &strip);

    const std::vector<int64_t>& attr_set();
}}

namespace Rose {
    std::string stringify_dot_attr_set(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_dot_attr_set();
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Csharp_ROSE_Connection/csharpBuilder.h line 10
namespace stringify { namespace csharp_translator {
    const char* SeqKind(int64_t);

    std::string SeqKind(int64_t, const std::string &strip);

    const std::vector<int64_t>& SeqKind();
}}

namespace Rose {
    std::string stringify_csharp_translatorSeqKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_csharp_translatorSeqKind();
}

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

    std::string Definition_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& Definition_Kinds();
}

namespace Rose {
    std::string stringifyDefinition_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDefinition_Kinds();
}

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

    std::string Path_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& Path_Kinds();
}

namespace Rose {
    std::string stringifyPath_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPath_Kinds();
}

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

    std::string _Access_Definition_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& _Access_Definition_Kinds();
}

namespace Rose {
    std::string stringify_Access_Definition_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_Access_Definition_Kinds();
}

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

    std::string _Formal_Type_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& _Formal_Type_Kinds();
}

namespace Rose {
    std::string stringify_Formal_Type_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_Formal_Type_Kinds();
}

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

    std::string _Discrete_Range_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& _Discrete_Range_Kinds();
}

namespace Rose {
    std::string stringify_Discrete_Range_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_Discrete_Range_Kinds();
}

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

    std::string _Constraint_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& _Constraint_Kinds();
}

namespace Rose {
    std::string stringify_Constraint_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_Constraint_Kinds();
}

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

    std::string _Representation_Clause_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& _Representation_Clause_Kinds();
}

namespace Rose {
    std::string stringify_Representation_Clause_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_Representation_Clause_Kinds();
}

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

    std::string ExpressionKind(int64_t, const std::string &strip);

    const std::vector<int64_t>& ExpressionKind();
}}

namespace Rose {
    std::string stringifyAda_ROSE_TranslationExpressionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAda_ROSE_TranslationExpressionKind();
}

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

    std::string Element_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& Element_Kinds();
}

namespace Rose {
    std::string stringifyElement_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyElement_Kinds();
}

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

    std::string Operator_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>& Operator_Kinds();
}

namespace Rose {
    std::string stringifyOperator_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOperator_Kinds();
}

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

    std::string Pragma_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>&