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/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/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 62
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/BinaryAnalysis/libraryIdentification/FunctionIdDatabaseInterface.h line 30
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/BinarySymbolicExprParser.h line 57
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/Concolic/ConcolicExecutor.h line 25
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic { namespace InputVariables { namespace Variable {
    const char* Whence(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/Concolic/BasicTypes.h line 17
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/DwarfLineMapper.h line 20
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/BinaryDebugger.C line 28
namespace stringify {
    const char* __ptrace_request(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryReachability.h line 25
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/BinaryFunctionSimilarity.h line 73
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 85
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/BinarySmtSolver.h line 45
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 57
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 81
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/instructionSemantics/DataFlowSemantics2.h line 37
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/BaseSemanticsTypes.h line 78
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/DispatcherPowerpc.C line 18
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace UpdateCr {
    const char* Flag(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/IntervalSemantics2.C line 654
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/SymbolicSemantics2.h line 65
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics { namespace AllowSideEffects {
    const char* Flag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/SymbolicSemantics2.h line 769
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 776
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/DispatcherX86.h line 181
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/BinaryTaintedFlow.h line 25
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 32
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/BinarySymbolicExpr.h line 55
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace TypeStyle {
    const char* Flag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 73
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 175
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 195
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 228
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace Type {
    const char* TypeClass(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 14
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 24
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 30
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 54
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/BinaryCallingConvention.h line 53
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 60
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 66
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 90
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/BinaryFeasiblePath.h line 36
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 43
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 49
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 56
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 59
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 178
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/BinaryMagic.h line 19
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/BinaryAnalysis/BinaryHotPatch.h line 31
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace HotPatch { namespace Record {
    const char* Type(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryString.h line 198
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/BinaryDebugger.h line 32
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
    const char* DetachMode(int64_t);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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/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/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/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/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/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/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/CallGraph/CallGraph.h line 73
namespace stringify { namespace CallGraph {
    const char* EdgeType(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/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/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/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/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/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/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/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/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/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/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/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/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/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/astMatching/MatchOperation.h line 40
namespace stringify { namespace MatchStatus {
    const char* PatternMatchMode(int64_t);

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/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/midend/abstractLayer/Labeler.h line 59
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 95
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/abstractLayer/SgNodeHelper.h line 531
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/astProcessing/AstRestructure.h line 22
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/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/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/roseSupport/CommandLine.C line 21
namespace stringify { namespace Rose { namespace CommandLine { namespace FailedAssertionBehaviorAdjuster {
    const char* Behavior(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseSupport/utility_functions.C line 847
namespace stringify {
    const char* language_enum(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseSupport/transformationSupport.h line 37
namespace stringify { namespace TransformationSupport {
    const char* operatorCodeType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseSupport/callbacks.h line 14
namespace stringify { namespace Rose { namespace Callbacks {
    const char* Direction(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseSupport/SqlDatabase.h line 121
namespace stringify { namespace SqlDatabase {
    const char* Driver(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qpanellayout.h line 38
namespace stringify { namespace QPanelLayout {
    const char* Position(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qpanellayout.h line 87
namespace stringify { namespace QPanelLayout {
    const char* SizeType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qlanguagedefinition.h line 44
namespace stringify { namespace QLanguageDefinition {
    const char* CollapseFlag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentline.h line 38
namespace stringify { namespace QParenthesis {
    const char* Role(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentline.h line 69
namespace stringify { namespace QDocumentLine {
    const char* State(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 39
namespace stringify { namespace QDocumentCursor {
    const char* MoveFlag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 48
namespace stringify { namespace QDocumentCursor {
    const char* MoveOperation(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 75
namespace stringify { namespace QDocumentCursor {
    const char* SelectionType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 84
namespace stringify { namespace QDocument {
    const char* LineEnding(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 93
namespace stringify { namespace QDocument {
    const char* TextProcessing(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 100
namespace stringify { namespace QDocument {
    const char* WhiteSpaceFlag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcommand.h line 37
namespace stringify { namespace QDocumentCommand {
    const char* Command(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentsearch.h line 40
namespace stringify { namespace QDocumentSearch {
    const char* Option(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor_p.h line 52
namespace stringify { namespace QDocumentCursorHandle {
    const char* Flags(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qreliablefilewatch.h line 52
namespace stringify { namespace QReliableFileWatch {
    const char* State(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfa.h line 42
namespace stringify {
    const char* NFAType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfa.h line 63
namespace stringify {
    const char* NFAAssertion(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfadefinition.h line 41
namespace stringify { namespace QNFAAction {
    const char* QNFAAction_(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfadefinition.h line 129
namespace stringify { namespace QNFADefinition { namespace PMatch {
    const char* Type(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qcodeedit.h line 46
namespace stringify { namespace QCodeEdit {
    const char* Position(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 64
namespace stringify { namespace QEditor {
    const char* CodecUpdatePolicy(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 74
namespace stringify { namespace QEditor {
    const char* EditFlag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 493
namespace stringify { namespace QEditor {
    const char* SaveState(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QtGradientEditor/qtcolorline.h line 62
namespace stringify { namespace QtColorLine {
    const char* ColorComponent(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QtGradientEditor/qtgradientwidget.cpp line 91
namespace stringify { namespace QtGradientWidgetPrivate {
    const char* Handle(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/TaskSystem/TaskInterface.h line 25
namespace stringify { namespace Task {
    const char* State(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/TaskSystem/CompilerOutputWidget.h line 25
namespace stringify { namespace CompilerOutputWidget {
    const char* PatternType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/AstGraphWidget/DisplayEdge.h line 40
namespace stringify { namespace DisplayEdge {
    const char* PaintMode(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/util/AstDisplayInfo.h line 14
namespace stringify { namespace AstDisplayInfo {
    const char* NodeType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/ProjectManager/DependencyInfo.h line 20
namespace stringify { namespace DependencyInfo {
    const char* State(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/failSafe/failSafePragma.h line 31
namespace stringify { namespace FailSafe {
    const char* fail_safe_enum(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/dataStructureTraversal/exampleTest.C line 3
namespace stringify {
    const char* controlEnum(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/dataStructureTraversal/GenRepresentation.h line 23
namespace stringify { namespace GenRepresentation {
    const char* TypeOfPrint(int64_t);

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

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

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

// 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 543
namespace stringify { namespace Unparse_ExprStmt {
    const char* token_sequence_position_enum_type(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryEdgeArrows.h line 34
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 62
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 71
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/BinarySerialIo.h line 122
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 133
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.h line 254
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/BinaryUnparserBase.h line 40
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/frontend/ECJ_ROSE_Connection/JavaParserActionROSE.C line 4134
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_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_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/CxxFrontend/Clang/clang-to-dot-private.hpp line 152
namespace stringify { namespace ClangToDotTranslator {
    const char* Language(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/Clang/clang-to-dot-private.hpp line 223
namespace stringify { namespace ClangToDotTranslator { namespace ClangToDotTranslator {
    const char* Language(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/Clang/clang-frontend-private.hpp line 150
namespace stringify { namespace ClangToSageTranslator {
    const char* Language(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/edgRose.C line 6369
namespace stringify {
    const char* kinds_of_type_references(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/edgRose.C line 46857
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/edgRose/edgRose.C line 61713
namespace stringify {
    const char* a_pragma_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 266
namespace stringify {
    const char* an_init_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 1182
namespace stringify {
    const char* a_decl_modifier_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 7715
namespace stringify {
    const char* a_local_expr_node_ref_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 10912
namespace stringify {
    const char* an_operand_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 13897
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_6.0/src/symbol_tbl.h line 464
namespace stringify {
    const char* a_symbol_kind_tag(int64_t);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/floating.h line 416
namespace stringify {
    const char* an_fp_type(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/floating.h line 515
namespace stringify {
    const char* an_fp_return_type(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/interpret.h line 59
namespace stringify {
    const char* a_constexpr_intrinsic_tag(int64_t);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/builtin_defs.h line 25
namespace stringify {
    const char* a_builtin_function_type_index(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/builtin_defs.h line 5812
namespace stringify {
    const char* a_builtin_function_condition_index(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/builtin_defs.h line 6527
namespace stringify {
    const char* a_builtin_function_kind_tag(int64_t);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/exprutil.h line 162
namespace stringify {
    const char* an_overload_context(int64_t);

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/lexical.h line 1973
namespace stringify {
    const char* a_token_extra_info_kind_tag(int64_t);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 2474
namespace stringify {
    const char* an_attribute_family_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 2499
namespace stringify {
    const char* an_attribute_location_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 2568
namespace stringify {
    const char* an_attribute_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 3206
namespace stringify {
    const char* a_constant_repr_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 3258
namespace stringify {
    const char* an_address_base_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 3519
namespace stringify {
    const char* a_dynamic_init_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 3953
namespace stringify {
    const char* a_template_param_constant_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 4087
namespace stringify {
    const char* a_character_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 4909
namespace stringify {
    const char* a_type_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 4957
namespace stringify {
    const char* an_integer_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5047
namespace stringify {
    const char* a_fixed_point_precision_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5079
namespace stringify {
    const char* a_float_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5105
namespace stringify {
    const char* a_type_mode_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5161
namespace stringify {
    const char* an_asm_operand_constraint_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5326
namespace stringify {
    const char* an_asm_operand_modifier_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5337
namespace stringify {
    const char* a_named_register_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5512
namespace stringify {
    const char* a_type_qualifier_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5614
namespace stringify {
    const char* a_upc_pragma_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5624
namespace stringify {
    const char* a_upc_access_method_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5635
namespace stringify {
    const char* a_upc_coherence_stack_operation_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5816
namespace stringify {
    const char* a_stdc_pragma_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5842
namespace stringify {
    const char* a_stdc_pragma_value_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 5863
namespace stringify {
    const char* a_gcc_pragma_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6133
namespace stringify {
    const char* a_microsoft_pragma_comment_type_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6147
namespace stringify {
    const char* a_microsoft_pragma_conform_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6454
namespace stringify {
    const char* a_calling_convention_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6642
namespace stringify {
    const char* a_ref_qualifier_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 6924
namespace stringify {
    const char* a_templ_arg_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7554
namespace stringify {
    const char* an_anonymous_union_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7569
namespace stringify {
    const char* an_inheritance_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7603
namespace stringify {
    const char* a_cli_class_type_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7636
namespace stringify {
    const char* a_property_or_event_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 7769
namespace stringify {
    const char* a_rewritten_property_reference_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 8436
namespace stringify {
    const char* a_template_param_type_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 8702
namespace stringify {
    const char* a_based_type_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 8763
namespace stringify {
    const char* a_pointer_modifier_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 9944
namespace stringify {
    const char* a_storage_class_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 11066
namespace stringify {
    const char* an_opname_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 11121
namespace stringify {
    const char* a_ctor_or_dtor_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 12399
namespace stringify {
    const char* an_expr_node_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 12524
namespace stringify {
    const char* a_lowered_eh_construct_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 12566
namespace stringify {
    const char* an_expr_operator_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 13090
namespace stringify {
    const char* a_builtin_operation_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 14313
namespace stringify {
    const char* a_statement_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 14542
namespace stringify {
    const char* a_for_each_pattern_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 15361
namespace stringify {
    const char* a_constructor_init_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 15587
namespace stringify {
    const char* a_generic_constraint_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 15675
namespace stringify {
    const char* a_template_parameter_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 15779
namespace stringify {
    const char* a_template_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 16125
namespace stringify {
    const char* an_object_lifetime_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 16268
namespace stringify {
    const char* an_ms_attribute_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 16290
namespace stringify {
    const char* an_ms_attribute_arg_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/il_def.h line 16680
namespace stringify {
    const char* a_scope_kind_tag(int64_t);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/sys_predef.h line 220
namespace stringify {
    const char* a_builtin_user_function_kind_tag(int64_t);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/src/ms_metadata.h line 22
namespace stringify {
    const char* a_cpp_cli_import_flag_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/lib_src/eh.h line 348
namespace stringify {
    const char* an_eh_stack_entry_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/lib_src/rtti.c line 120
namespace stringify {
    const char* a_result_virtuality(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/include/cxxabi.h line 62
namespace stringify { namespace __cxxabiv1 { namespace __base_class_type_info {
    const char* __offset_flags_masks(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/include/cxxabi.h line 77
namespace stringify { namespace __cxxabiv1 { namespace __vmi_class_type_info {
    const char* __flags_masks(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/include/cxxabi.h line 90
namespace stringify { namespace __cxxabiv1 { namespace __pbase_type_info {
    const char* __masks(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.0/util/decode.c line 4308
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_5.0/src/decls.c line 16203
namespace stringify {
    const char* an_end_of_decl_action(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/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_5.0/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_6.1/src/decls.h line 24
namespace stringify {
    const char* a_tu_decl_stage(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.1/src/il_def.h line 17318
namespace stringify {
    const char* a_module_kind_tag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 14
namespace stringify { namespace LanguageTranslation {
    const char* FunctionModifier(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 35
namespace stringify { namespace LanguageTranslation {
    const char* PackingSpecifier(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 45
namespace stringify { namespace LanguageTranslation {
    const char* ExpressionKind(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/sage-tree-builder.h line 103
namespace stringify { namespace Rose { namespace builder { namespace SageTreeBuilder {
    const char* LanguageEnum(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/Partitioner.h line 1494
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Partitioner { namespace MayReturnVertexInfo {
    const char* State(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/Function.h line 46
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Function {
    const char* Ownership(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/CfgPath.h line 457
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Inliner {
    const char* HowInline(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/ModulesX86.h line 100
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace ModulesX86 { namespace SwitchSuccessors {
    const char* EntryType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/ModulesElf.h line 89
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace ModulesElf { namespace FixUndefinedSymbols {
    const char* Boolean(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/Modules.h line 49
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace BasicBlockCallback {
    const char* Termination(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 27
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Precision {
    const char* Level(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace AllowParallelEdges {
    const char* Type(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 55
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* EdgeType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 79
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* Confidence(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 183
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* MemoryDataAdjustment(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/BasicTypes.h line 299
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
    const char* FunctionReturnAnalysis(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/Reference.h line 32
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Reference {
    const char* Granularity(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Partitioner2/DataFlow.h line 31
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace DataFlow { namespace DfCfgVertex {
    const char* Type(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Jovial_ROSE_Connection/jovial_preprocess.C line 36
namespace stringify {
    const char* State(int64_t);

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

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

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

// 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/BinaryLoader/BinaryLoader.h line 66
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryLoader {
    const char* MappingContribution(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryLoader/BinaryLoader.h line 74
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryLoader {
    const char* ConflictResolution(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 14
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_keywords(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 147
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_C_CXX_keywords(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 215
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_Operators(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 242
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_C_CXX_operators(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 321
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_Additional_Info(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 10
namespace stringify {
    const char* ROSE_Fortran_Identifiers(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 140
namespace stringify {
    const char* ROSE_Fortran_Operators(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 167
namespace stringify {
    const char* ROSE_Fortran_Additional_Info(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_OpenFortranParser_ROSE_Connection/FASTNodes.h line 88
namespace stringify { namespace FAST { namespace TypeSpec {
    const char* TypeEnum(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_OpenFortranParser_ROSE_Connection/FASTNodes.h line 136
namespace stringify { namespace FAST { namespace AttrSpec {
    const char* AttrEnum(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_OpenFortranParser_ROSE_Connection/FASTNodes.h line 265
namespace stringify { namespace FAST { namespace UseStmt {
    const char* ModuleNature(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_OpenFortranParser_ROSE_Connection/FASTNodes.h line 444
namespace stringify { namespace FAST { namespace PrefixSpec {
    const char* PrefixEnum(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_OpenFortranParser_ROSE_Connection/Fortran_to_ROSE_translation.h line 8
namespace stringify { namespace Fortran_ROSE_Translation {
    const char* ExpressionKind(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/AssemblerX86Init.h line 27
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86InstructionKind(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsPowerpc.h line 13
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* PowerpcWordSize(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsPowerpc.h line 19
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* PowerpcInstructionKind(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsPowerpc.h line 466
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* PowerpcRegisterClass(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsPowerpc.h line 482
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* PowerpcConditionRegisterAccessGranularity(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsPowerpc.h line 489
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* PowerpcSpecialPurposeRegister(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsPowerpc.h line 500
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* PowerpcTimeBaseRegister(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/Assembler.h line 79
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Assembler {
    const char* EncodingType(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/AssemblerX86.h line 143
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace AssemblerX86 {
    const char* OperandDefn(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/AssemblerX86.h line 384
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace AssemblerX86 {
    const char* MemoryReferencePattern(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/DisassemblerMips.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DisassemblerMips { namespace Mips32 {
    const char* Architecture(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 19
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* M68kFamily(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 67
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* M68kSpecialPurposeRegister(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 76
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* M68kMacRegister(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 92
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* M68kEmacRegister(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 102
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* M68kSupervisorRegister(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 189
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* M68kEffectiveAddressMode(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 243
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* M68kDataFormat(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsM68k.h line 255
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* M68kInstructionKind(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/DisassemblerX86.h line 151
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DisassemblerX86 {
    const char* RegisterMode(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/DisassemblerX86.h line 156
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DisassemblerX86 {
    const char* MMPrefix(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsAarch64.h line 39
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* Aarch64RegisterClass(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/DisassemblerAarch64.h line 39
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DisassemblerAarch64 {
    const char* Architecture(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/DisassemblerAarch64.h line 45
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DisassemblerAarch64 {
    const char* Mode(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 15
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86InstructionSize(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 36
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86SegmentRegister(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 67
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86StRegister(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 80
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86Flags(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 89
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86Flag(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 110
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86BranchPrediction(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 118
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86RepeatPrefix(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsX86.h line 127
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* X86Exception(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsMips.h line 25
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* MipsFcsrMinors(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/InstructionEnumsMips.h line 33
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* MipsSpecialPurposeRegister(int64_t);

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/BinaryInstructionCache.h line 47
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ManagedInstruction {
    const char* State(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/Registers.h line 296
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace RegisterDictionary { namespace SortBySize {
    const char* Direction(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/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/dot_asis/dot_asis_library/include/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/dot_asis/dot_asis_library/include/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>& Pragma_Kinds();
}

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 247
namespace stringify {
    const char* Defining_Name_Kinds(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 288
namespace stringify {
    const char* Declaration_Kinds(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 392
namespace stringify {
    const char* Declaration_Origins(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 408
namespace stringify {
    const char* Mode_Kinds(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 418
namespace stringify {
    const char* Subprogram_Default_Kinds(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 812
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/dot_asis/dot_asis_library/include/a_nodes.h line 845
namespace stringify {
    const char* _Type_Kinds(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 869
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/dot_asis/dot_asis_library/include/a_nodes.h line 879
namespace stringify {
    const char* _Interface_Kinds(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 888
namespace stringify {
    const char* _Root_Type_Kinds(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 897
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/dot_asis/dot_asis_library/include/a_nodes.h line 904
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/dot_asis/dot_asis_library/include/a_nodes.h line 926
namespace stringify {
    const char* _Access_Type_Kinds(int64_t);

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/dot_asis/dot_asis_library/include/a_nodes.h line 937
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/dot_asis/dot_asis_library/include/a_nodes.h line 1267
namespace stringify {
    const char* Expression_Kinds(int64_t);

    std::string Expression_Kinds(int64_t, const std::string &strip);

    const std::vector<int64_t>&