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/Rose/AST/Defect.h line 27
namespace stringify { namespace Rose { namespace AST { namespace Defects {
    const char* Kind(int64_t);
 
    std::string Kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Kind();
}}}}
 
namespace Rose {
    std::string stringifyAST_DefectsKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_DefectsKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/Defect.h line 117
namespace stringify { namespace Rose { namespace AST { namespace Defects {
    const char* Reason(int64_t);
 
    std::string Reason(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Reason();
}}}}
 
namespace Rose {
    std::string stringifyAST_DefectsReason(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_DefectsReason();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/Traversal.h line 19
namespace stringify { namespace Rose { namespace AST { namespace Traversal {
    const char* Order(int64_t);
 
    std::string Order(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Order();
}}}}
 
namespace Rose {
    std::string stringifyAST_TraversalOrder(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_TraversalOrder();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/cmdline.h line 25
namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace graphviz_t {
    const char* Mode(int64_t);
 
    std::string Mode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Mode();
}}}}}
 
namespace Rose {
    std::string stringifyASTcmdline_graphviz_tMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyASTcmdline_graphviz_tMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/cmdline.h line 43
namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace checker_t {
    const char* Mode(int64_t);
 
    std::string Mode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Mode();
}}}}}
 
namespace Rose {
    std::string stringifyASTcmdline_checker_tMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyASTcmdline_checker_tMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/AST/cmdline.h line 54
namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace checker_t {
    const char* Effect(int64_t);
 
    std::string Effect(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Effect();
}}}}}
 
namespace Rose {
    std::string stringifyASTcmdline_checker_tEffect(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyASTcmdline_checker_tEffect();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/FormattedTable.h line 22
namespace stringify { namespace Rose { namespace FormattedTable {
    const char* Format(int64_t);
 
    std::string Format(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Format();
}}}
 
namespace Rose {
    std::string stringifyFormattedTableFormat(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFormattedTableFormat();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/FormattedTable.h line 35
namespace stringify { namespace Rose { namespace FormattedTable {
    const char* Alignment(int64_t);
 
    std::string Alignment(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Alignment();
}}}
 
namespace Rose {
    std::string stringifyFormattedTableAlignment(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFormattedTableAlignment();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 14
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* CilFamily(int64_t);
 
    std::string CilFamily(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CilFamily();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisCilFamily(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCilFamily();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 19
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* CilInstructionKind(int64_t);
 
    std::string CilInstructionKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CilInstructionKind();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisCilInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisCilInstructionKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/FeasiblePath.h line 37
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/Rose/BinaryAnalysis/FeasiblePath.h line 44
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/Rose/BinaryAnalysis/FeasiblePath.h line 50
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/Rose/BinaryAnalysis/FeasiblePath.h line 57
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/Rose/BinaryAnalysis/FeasiblePath.h line 60
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/Rose/BinaryAnalysis/FeasiblePath.h line 180
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/Rose/BinaryAnalysis/HotPatch.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/Rose/BinaryAnalysis/HotPatch.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/Rose/BinaryAnalysis/SRecord.h line 40
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
    const char* Syntax(int64_t);
 
    std::string Syntax(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Syntax();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisSRecordSyntax(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSRecordSyntax();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SRecord.h line 47
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisSRecordType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSRecordType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SymbolicExpression.h line 59
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression { 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 stringifyBinaryAnalysisSymbolicExpressionTypeStyleFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionTypeStyleFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SymbolicExpression.h line 77
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression {
    const char* Operator(int64_t);
 
    std::string Operator(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Operator();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExpressionOperator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionOperator();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SymbolicExpression.h line 162
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression { 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 stringifyBinaryAnalysisSymbolicExpressionFormatterShowComments(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionFormatterShowComments();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SymbolicExpression.h line 183
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression {
    const char* VisitAction(int64_t);
 
    std::string VisitAction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& VisitAction();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExpressionVisitAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionVisitAction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SymbolicExpression.h line 225
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression { 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 stringifyBinaryAnalysisSymbolicExpressionTypeTypeClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionTypeTypeClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SymbolicExpressionParser.h line 59
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpressionParser { 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 stringifyBinaryAnalysisSymbolicExpressionParserTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionParserTokenType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/PointerDetection.h line 177
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace PointerDetection { namespace PointerDescriptor {
    const char* Direction(int64_t);
 
    std::string Direction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Direction();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisPointerDetectionPointerDescriptorDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisPointerDetectionPointerDescriptorDirection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/ModelChecker/PartitionerModel.h line 35
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker { namespace PartitionerModel { namespace Settings {
    const char* MemoryType(int64_t);
 
    std::string MemoryType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& MemoryType();
}}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisModelCheckerPartitionerModelSettingsMemoryType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerPartitionerModelSettingsMemoryType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/ModelChecker/BasicTypes.h line 163
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker {
    const char* TestMode(int64_t);
 
    std::string TestMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TestMode();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisModelCheckerTestMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerTestMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/ModelChecker/BasicTypes.h line 170
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker {
    const char* IoMode(int64_t);
 
    std::string IoMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IoMode();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisModelCheckerIoMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerIoMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/ModelChecker/BasicTypes.h line 176
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker {
    const char* Prune(int64_t);
 
    std::string Prune(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Prune();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisModelCheckerPrune(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerPrune();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/ModelChecker/BasicTypes.h line 182
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker {
    const char* WorkerState(int64_t);
 
    std::string WorkerState(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& WorkerState();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisModelCheckerWorkerState(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerWorkerState();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/ByteOrder.h line 19
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ByteOrder {
    const char* Endianness(int64_t);
 
    std::string Endianness(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Endianness();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisByteOrderEndianness(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisByteOrderEndianness();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/MemoryMap.h line 134
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap { namespace Attach {
    const char* Boolean(int64_t);
 
    std::string Boolean(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Boolean();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisMemoryMapAttachBoolean(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapAttachBoolean();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/MemoryMap.h line 141
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap {
    const char* Clobber(int64_t);
 
    std::string Clobber(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Clobber();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisMemoryMapClobber(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapClobber();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/MemoryMap.h line 303
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap {
    const char* InsertFileMapMode(int64_t);
 
    std::string InsertFileMapMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& InsertFileMapMode();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisMemoryMapInsertFileMapMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapInsertFileMapMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 18
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* Aarch32Exception(int64_t);
 
    std::string Aarch32Exception(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Aarch32Exception();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisAarch32Exception(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisAarch32Exception();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 25
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* Aarch32RegisterClass(int64_t);
 
    std::string Aarch32RegisterClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Aarch32RegisterClass();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisAarch32RegisterClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisAarch32RegisterClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 34
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* Aarch32GeneralPurposeRegister(int64_t);
 
    std::string Aarch32GeneralPurposeRegister(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Aarch32GeneralPurposeRegister();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisAarch32GeneralPurposeRegister(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisAarch32GeneralPurposeRegister();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 45
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* Aarch32DebugRegister(int64_t);
 
    std::string Aarch32DebugRegister(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Aarch32DebugRegister();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisAarch32DebugRegister(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisAarch32DebugRegister();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 103
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* Aarch32SystemRegister(int64_t);
 
    std::string Aarch32SystemRegister(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Aarch32SystemRegister();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisAarch32SystemRegister(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisAarch32SystemRegister();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/DataFlowSemantics.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsDataFlowSemanticsDataFlowEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsDataFlowSemanticsDataFlowEdgeEdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/IntervalSemantics.C line 924
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsIntervalSemanticsCarry(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsIntervalSemanticsCarry();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h line 67
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsAllowSideEffectsFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsAllowSideEffectsFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h line 703
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsWritersMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsWritersMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h line 710
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsDefinersMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsDefinersMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherX86.h line 158
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsDispatcherX86AccessMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsDispatcherX86AccessMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/RiscOperators.h line 483
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace BaseSemantics { namespace RiscOperators {
    const char* IteStatus(int64_t);
 
    std::string IteStatus(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IteStatus();
}}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemanticsBaseSemanticsRiscOperatorsIteStatus(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsBaseSemanticsRiscOperatorsIteStatus();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h line 85
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsBaseSemanticsInputOutputProperty(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsBaseSemanticsInputOutputProperty();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherAarch32.h line 160
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace DispatcherAarch32 {
    const char* SrType(int64_t);
 
    std::string SrType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SrType();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemanticsDispatcherAarch32SrType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsDispatcherAarch32SrType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherAarch32.h line 161
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace DispatcherAarch32 {
    const char* BranchType(int64_t);
 
    std::string BranchType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& BranchType();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemanticsDispatcherAarch32BranchType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsDispatcherAarch32BranchType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherPowerpc.C line 31
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsUpdateCrFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsUpdateCrFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherPowerpc.C line 35
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { 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 stringifyBinaryAnalysisInstructionSemanticsSaveLinkFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsSaveLinkFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionSemantics/TaintSemantics.h line 17
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace TaintSemantics {
    const char* Taintedness(int64_t);
 
    std::string Taintedness(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Taintedness();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemanticsTaintSemanticsTaintedness(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsTaintSemanticsTaintedness();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Unparser/Base.h line 51
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/Rose/BinaryAnalysis/Unparser/EdgeArrows.h line 33
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/Rose/BinaryAnalysis/Unparser/EdgeArrows.h line 61
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/Rose/BinaryAnalysis/Unparser/EdgeArrows.h line 70
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/Rose/BinaryAnalysis/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/Rose/BinaryAnalysis/Partitioner2/Modules.h line 45
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/Rose/BinaryAnalysis/Partitioner2/CfgPath.h line 472
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/Rose/BinaryAnalysis/Partitioner2/DataFlow.h line 32
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/Rose/BinaryAnalysis/Partitioner2/ModulesElf.h line 88
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/Rose/BinaryAnalysis/Partitioner2/Partitioner.h line 1396
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/Rose/BinaryAnalysis/Partitioner2/Function.h line 44
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/Rose/BinaryAnalysis/Partitioner2/ModulesX86.h line 109
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/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 34
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/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 44
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/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 51
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/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 62
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/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 86
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/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 92
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/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 179
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/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 312
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/Rose/BinaryAnalysis/Dwarf/Constants.h line 14
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Dwarf {
    const char* DWARF_TAG(int64_t);
 
    std::string DWARF_TAG(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DWARF_TAG();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDwarfDWARF_TAG(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDwarfDWARF_TAG();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Dwarf/Constants.h line 117
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Dwarf {
    const char* DWARF_FORM(int64_t);
 
    std::string DWARF_FORM(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DWARF_FORM();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDwarfDWARF_FORM(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDwarfDWARF_FORM();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Dwarf/Constants.h line 146
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Dwarf {
    const char* DWARF_AT(int64_t);
 
    std::string DWARF_AT(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DWARF_AT();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDwarfDWARF_AT(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDwarfDWARF_AT();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Dwarf/Constants.h line 360
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Dwarf {
    const char* DWARF_LANG(int64_t);
 
    std::string DWARF_LANG(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DWARF_LANG();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDwarfDWARF_LANG(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDwarfDWARF_LANG();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SmtSolver.h line 51
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/Rose/BinaryAnalysis/SmtSolver.h line 63
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/Rose/BinaryAnalysis/SmtSolver.h line 87
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/Rose/BinaryAnalysis/InstructionEnumsMips.h line 11
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/Rose/BinaryAnalysis/InstructionEnumsMips.h line 24
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/Rose/BinaryAnalysis/InstructionEnumsMips.h line 32
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/Rose/BinaryAnalysis/InstructionEnumsMips.h line 41
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* MipsInterruptMajor(int64_t);
 
    std::string MipsInterruptMajor(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& MipsInterruptMajor();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisMipsInterruptMajor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMipsInterruptMajor();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsMips.h line 46
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* MipsInterruptMinor(int64_t);
 
    std::string MipsInterruptMinor(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& MipsInterruptMinor();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisMipsInterruptMinor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMipsInterruptMinor();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsMips.h line 52
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* MipsDataFormat(int64_t);
 
    std::string MipsDataFormat(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& MipsDataFormat();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisMipsDataFormat(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisMipsDataFormat();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsMips.h line 61
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/Rose/BinaryAnalysis/Concolic/ExecutionEvent.h line 69
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic { namespace ExecutionEvent {
    const char* Action(int64_t);
 
    std::string Action(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Action();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcolicExecutionEventAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicExecutionEventAction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 28
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
    const char* Update(int64_t);
 
    std::string Update(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Update();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcolicUpdate(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicUpdate();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 31
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
    const char* ShowEvents(int64_t);
 
    std::string ShowEvents(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ShowEvents();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcolicShowEvents(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicShowEvents();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
    const char* ShowAssertions(int64_t);
 
    std::string ShowAssertions(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ShowAssertions();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcolicShowAssertions(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicShowAssertions();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 40
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
    const char* InputType(int64_t);
 
    std::string InputType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& InputType();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcolicInputType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicInputType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 50
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
    const char* IoDirection(int64_t);
 
    std::string IoDirection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IoDirection();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcolicIoDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicIoDirection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 58
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
    const char* When(int64_t);
 
    std::string When(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& When();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcolicWhen(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicWhen();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 64
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
    const char* ConcolicPhase(int64_t);
 
    std::string ConcolicPhase(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ConcolicPhase();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcolicConcolicPhase(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicConcolicPhase();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 18
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/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 56
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/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 66
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/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 75
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/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 91
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/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 101
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/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 187
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/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 241
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/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 253
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/Rose/BinaryAnalysis/RegisterDictionary.h line 314
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/Rose/BinaryAnalysis/Debugger/Gdb.h line 172
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace Gdb { namespace Response { namespace ResultRecord {
    const char* ResultClass(int64_t);
 
    std::string ResultClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ResultClass();
}}}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerGdbResponseResultRecordResultClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerGdbResponseResultRecordResultClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Debugger/Linux.h line 27
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace Linux {
    const char* DetachMode(int64_t);
 
    std::string DetachMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DetachMode();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerLinuxDetachMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerLinuxDetachMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Debugger/Linux.h line 35
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace Linux {
    const char* Flag(int64_t);
 
    std::string Flag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Flag();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerLinuxFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerLinuxFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Debugger/Linux.h line 191
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace Linux {
    const char* RegCacheType(int64_t);
 
    std::string RegCacheType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& RegCacheType();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerLinuxRegCacheType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerLinuxRegCacheType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Debugger/GdbResponse.h line 19
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace GdbResponse {
    const char* TokenType(int64_t);
 
    std::string TokenType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TokenType();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerGdbResponseTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerGdbResponseTokenType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Debugger/GdbResponse.h line 68
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace GdbResponse {
    const char* ResultClass(int64_t);
 
    std::string ResultClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ResultClass();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerGdbResponseResultClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerGdbResponseResultClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Debugger/GdbResponse.h line 71
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace GdbResponse {
    const char* AsyncClass(int64_t);
 
    std::string AsyncClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AsyncClass();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerGdbResponseAsyncClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerGdbResponseAsyncClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Debugger/BasicTypes.h line 39
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
    const char* FilterActionFlag(int64_t);
 
    std::string FilterActionFlag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& FilterActionFlag();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerFilterActionFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerFilterActionFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/String.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/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 12
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* PowerpcCapability(int64_t);
 
    std::string PowerpcCapability(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PowerpcCapability();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisPowerpcCapability(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisPowerpcCapability();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 52
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/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 58
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/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 506
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/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 522
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/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 529
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/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 540
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/Rose/BinaryAnalysis/MagicNumber.h line 21
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/Rose/BinaryAnalysis/Variables.h line 156
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Variables { namespace StackVariable {
    const char* Purpose(int64_t);
 
    std::string Purpose(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Purpose();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisVariablesStackVariablePurpose(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisVariablesStackVariablePurpose();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Variables.h line 443
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Variables { namespace StackFrame {
    const char* Direction(int64_t);
 
    std::string Direction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Direction();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisVariablesStackFrameDirection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisVariablesStackFrameDirection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/ConcreteLocation.h line 29
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ConcreteLocation {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisConcreteLocationType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisConcreteLocationType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/FunctionSimilarity.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/Rose/BinaryAnalysis/FunctionSimilarity.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/Rose/BinaryAnalysis/Architecture/ArmAarch32.h line 56
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Architecture { namespace ArmAarch32 {
    const char* InstructionSet(int64_t);
 
    std::string InstructionSet(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& InstructionSet();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisArchitectureArmAarch32InstructionSet(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisArchitectureArmAarch32InstructionSet();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/SerialIo.h line 120
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/Rose/BinaryAnalysis/SerialIo.h line 131
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/Rose/BinaryAnalysis/CodeInserter.h line 19
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/Rose/BinaryAnalysis/CodeInserter.h line 29
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/Rose/BinaryAnalysis/CodeInserter.h line 35
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/Rose/BinaryAnalysis/CodeInserter.h line 59
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/Rose/BinaryAnalysis/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/Rose/BinaryAnalysis/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/Rose/BinaryAnalysis/Disassembler/Aarch64.h line 47
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace Aarch64 {
    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/Rose/BinaryAnalysis/Disassembler/Aarch32.h line 25
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace Aarch32 {
    const char* Mode(int64_t);
 
    std::string Mode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Mode();
}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDisassemblerAarch32Mode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDisassemblerAarch32Mode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Disassembler/Mips.h line 66
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace Mips { namespace Decoder {
    const char* Architecture(int64_t);
 
    std::string Architecture(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Architecture();
}}}}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisDisassemblerMipsDecoderArchitecture(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisDisassemblerMipsDecoderArchitecture();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/Disassembler/X86.h line 149
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace X86 {
    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/Rose/BinaryAnalysis/Disassembler/X86.h line 154
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace X86 {
    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/Rose/BinaryAnalysis/InstructionEnumsAarch64.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* Aarch64Exception(int64_t);
 
    std::string Aarch64Exception(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Aarch64Exception();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisAarch64Exception(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisAarch64Exception();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsAarch64.h line 42
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/Rose/BinaryAnalysis/InstructionEnumsAarch64.h line 57
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/Rose/BinaryAnalysis/InstructionEnumsJvm.h line 28
namespace stringify { namespace Rose { namespace BinaryAnalysis {
    const char* JvmInstructionKind(int64_t);
 
    std::string JvmInstructionKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& JvmInstructionKind();
}}}
 
namespace Rose {
    std::string stringifyBinaryAnalysisJvmInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBinaryAnalysisJvmInstructionKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 13
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 21
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 34
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 45
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 65
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 78
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 87
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 108
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 116
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/Rose/BinaryAnalysis/InstructionEnumsX86.h line 125
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/Rose/BinaryAnalysis/TaintedFlow.h line 24
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/Rose/BinaryAnalysis/TaintedFlow.h line 31
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/Rose/BinaryAnalysis/CallingConvention/BasicTypes.h line 27
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/Rose/BinaryAnalysis/CallingConvention/BasicTypes.h line 34
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/Rose/BinaryAnalysis/CallingConvention/BasicTypes.h line 40
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/Rose/BinaryAnalysis/Reachability.h line 34
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/Rose/Color.h line 22
namespace stringify { namespace Rose { namespace Color {
    const char* Enabled(int64_t);
 
    std::string Enabled(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Enabled();
}}}
 
namespace Rose {
    std::string stringifyColorEnabled(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorEnabled();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Color.h line 31
namespace stringify { namespace Rose { namespace Color {
    const char* Theme(int64_t);
 
    std::string Theme(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Theme();
}}}
 
namespace Rose {
    std::string stringifyColorTheme(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorTheme();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Color.h line 49
namespace stringify { namespace Rose { namespace Color {
    const char* Layer(int64_t);
 
    std::string Layer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Layer();
}}}
 
namespace Rose {
    std::string stringifyColorLayer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorLayer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Color.h line 366
namespace stringify { namespace Rose { namespace Color {
    const char* AnsiColor(int64_t);
 
    std::string AnsiColor(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AnsiColor();
}}}
 
namespace Rose {
    std::string stringifyColorAnsiColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyColorAnsiColor();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Sarif/BasicTypes.h line 15
namespace stringify { namespace Rose { namespace Sarif {
    const char* Kind(int64_t);
 
    std::string Kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Kind();
}}}
 
namespace Rose {
    std::string stringifySarifKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySarifKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Sarif/BasicTypes.h line 25
namespace stringify { namespace Rose { namespace Sarif {
    const char* Severity(int64_t);
 
    std::string Severity(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Severity();
}}}
 
namespace Rose {
    std::string stringifySarifSeverity(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySarifSeverity();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/CodeGen/Object.h line 12
namespace stringify { namespace Rose { namespace CodeGen {
    const char* Object(int64_t);
 
    std::string Object(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Object();
}}}
 
namespace Rose {
    std::string stringifyCodeGenObject(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeGenObject();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/CommandLine/Parser.C line 32
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/Rose/CommandLine/SuffixMultiplierParser.h line 36
namespace stringify { namespace Rose { namespace CommandLine { namespace SuffixMultiplierParser {
    const char* Preferred(int64_t);
 
    std::string Preferred(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Preferred();
}}}}
 
namespace Rose {
    std::string stringifyCommandLineSuffixMultiplierParserPreferred(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCommandLineSuffixMultiplierParserPreferred();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rose/Logger.h line 14
namespace stringify { namespace Rose { namespace Logger {
    const char* Level(int64_t);
 
    std::string Level(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Level();
}}}
 
namespace Rose {
    std::string stringifyLoggerLevel(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyLoggerLevel();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 106
namespace stringify { namespace AstNodeClass {
    const char* locationInTree(int64_t);
 
    std::string locationInTree(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& locationInTree();
}}
 
namespace Rose {
    std::string stringifyAstNodeClass_locationInTree(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClass_locationInTree();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 112
namespace stringify { namespace AstNodeClass {
    const char* includeExcludeMechanism(int64_t);
 
    std::string includeExcludeMechanism(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& includeExcludeMechanism();
}}
 
namespace Rose {
    std::string stringifyAstNodeClass_includeExcludeMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClass_includeExcludeMechanism();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 333
namespace stringify { namespace AstNodeClass {
    const char* TypeEvaluation(int64_t);
 
    std::string TypeEvaluation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeEvaluation();
}}
 
namespace Rose {
    std::string stringifyAstNodeClassTypeEvaluation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodeClassTypeEvaluation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 1652
namespace stringify { namespace SgAsmRiscOperation {
    const char* RiscOperator(int64_t);
 
    std::string RiscOperator(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& RiscOperator();
}}
 
namespace Rose {
    std::string stringifySgAsmRiscOperationRiscOperator(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmRiscOperationRiscOperator();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 2301
namespace stringify { namespace SgAsmPESectionTableEntry {
    const char* PESectionFlags(int64_t);
 
    std::string PESectionFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PESectionFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmPESectionTableEntryPESectionFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPESectionTableEntryPESectionFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 4097
namespace stringify { namespace SgAsmPEFileHeader {
    const char* HeaderFlags(int64_t);
 
    std::string HeaderFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& HeaderFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmPEFileHeaderHeaderFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPEFileHeaderHeaderFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 4106
namespace stringify { namespace SgAsmPEFileHeader {
    const char* Subsystem(int64_t);
 
    std::string Subsystem(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Subsystem();
}}
 
namespace Rose {
    std::string stringifySgAsmPEFileHeaderSubsystem(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPEFileHeaderSubsystem();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 4116
namespace stringify { namespace SgAsmPEFileHeader {
    const char* DLLFlags(int64_t);
 
    std::string DLLFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DLLFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmPEFileHeaderDLLFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPEFileHeaderDLLFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 4125
namespace stringify { namespace SgAsmPEFileHeader {
    const char* PairPurpose(int64_t);
 
    std::string PairPurpose(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PairPurpose();
}}
 
namespace Rose {
    std::string stringifySgAsmPEFileHeaderPairPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmPEFileHeaderPairPurpose();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5502
namespace stringify { namespace SgAsmNullInstruction {
    const char* Kind(int64_t);
 
    std::string Kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Kind();
}}
 
namespace Rose {
    std::string stringifySgAsmNullInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNullInstructionKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5781
namespace stringify { namespace SgAsmNESectionTableEntry {
    const char* NESectionFlags(int64_t);
 
    std::string NESectionFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& NESectionFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmNESectionTableEntryNESectionFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNESectionTableEntryNESectionFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 6119
namespace stringify { namespace SgAsmNERelocEntry {
    const char* NERelocSrcType(int64_t);
 
    std::string NERelocSrcType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& NERelocSrcType();
}}
 
namespace Rose {
    std::string stringifySgAsmNERelocEntryNERelocSrcType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNERelocEntryNERelocSrcType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 6131
namespace stringify { namespace SgAsmNERelocEntry {
    const char* NERelocTgtType(int64_t);
 
    std::string NERelocTgtType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& NERelocTgtType();
}}
 
namespace Rose {
    std::string stringifySgAsmNERelocEntryNERelocTgtType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNERelocEntryNERelocTgtType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 6138
namespace stringify { namespace SgAsmNERelocEntry {
    const char* NERelocModifiers(int64_t);
 
    std::string NERelocModifiers(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& NERelocModifiers();
}}
 
namespace Rose {
    std::string stringifySgAsmNERelocEntryNERelocModifiers(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNERelocEntryNERelocModifiers();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 6143
namespace stringify { namespace SgAsmNERelocEntry {
    const char* NERelocFlags(int64_t);
 
    std::string NERelocFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& NERelocFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmNERelocEntryNERelocFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNERelocEntryNERelocFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 6839
namespace stringify { namespace SgAsmNEFileHeader {
    const char* HeaderFlags1(int64_t);
 
    std::string HeaderFlags1(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& HeaderFlags1();
}}
 
namespace Rose {
    std::string stringifySgAsmNEFileHeaderHeaderFlags1(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNEFileHeaderHeaderFlags1();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 6850
namespace stringify { namespace SgAsmNEFileHeader {
    const char* HeaderFlags2(int64_t);
 
    std::string HeaderFlags2(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& HeaderFlags2();
}}
 
namespace Rose {
    std::string stringifySgAsmNEFileHeaderHeaderFlags2(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNEFileHeaderHeaderFlags2();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 7197
namespace stringify { namespace SgAsmNEEntryPoint {
    const char* NEEntryFlags(int64_t);
 
    std::string NEEntryFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& NEEntryFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmNEEntryPointNEEntryFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmNEEntryPointNEEntryFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 7707
namespace stringify { namespace SgAsmLESectionTableEntry {
    const char* LESectionFlags(int64_t);
 
    std::string LESectionFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& LESectionFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmLESectionTableEntryLESectionFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmLESectionTableEntryLESectionFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 8703
namespace stringify { namespace SgAsmLEFileHeader {
    const char* LEFileHeaderFlags(int64_t);
 
    std::string LEFileHeaderFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& LEFileHeaderFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmLEFileHeaderLEFileHeaderFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmLEFileHeaderLEFileHeaderFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 9298
namespace stringify { namespace SgAsmJvmStackMapVerificationType {
    const char* verification_type_tag(int64_t);
 
    std::string verification_type_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& verification_type_tag();
}}
 
namespace Rose {
    std::string stringifySgAsmJvmStackMapVerificationType_verification_type_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmJvmStackMapVerificationType_verification_type_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 12922
namespace stringify { namespace SgAsmJvmConstantPoolEntry {
    const char* Kind(int64_t);
 
    std::string Kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Kind();
}}
 
namespace Rose {
    std::string stringifySgAsmJvmConstantPoolEntryKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmJvmConstantPoolEntryKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15418
namespace stringify { namespace SgAsmGenericFile {
    const char* AddressSpace(int64_t);
 
    std::string AddressSpace(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AddressSpace();
}}
 
namespace Rose {
    std::string stringifySgAsmGenericFileAddressSpace(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericFileAddressSpace();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15425
namespace stringify { namespace SgAsmGenericFile {
    const char* Elasticity(int64_t);
 
    std::string Elasticity(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Elasticity();
}}
 
namespace Rose {
    std::string stringifySgAsmGenericFileElasticity(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericFileElasticity();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 16212
namespace stringify { namespace SgAsmFunction {
    const char* MayReturn(int64_t);
 
    std::string MayReturn(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& MayReturn();
}}
 
namespace Rose {
    std::string stringifySgAsmFunctionMayReturn(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmFunctionMayReturn();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 16222
namespace stringify { namespace SgAsmFunction {
    const char* FunctionReason(int64_t);
 
    std::string FunctionReason(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& FunctionReason();
}}
 
namespace Rose {
    std::string stringifySgAsmFunctionFunctionReason(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmFunctionFunctionReason();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 16309
namespace stringify { namespace SgAsmFunction {
    const char* function_kind_enum(int64_t);
 
    std::string function_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& function_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgAsmFunction_function_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmFunction_function_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 16865
namespace stringify { namespace SgAsmFloatType {
    const char* Flag(int64_t);
 
    std::string Flag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Flag();
}}
 
namespace Rose {
    std::string stringifySgAsmFloatTypeFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmFloatTypeFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 19120
namespace stringify { namespace SgAsmElfSymbol {
    const char* ElfSymBinding(int64_t);
 
    std::string ElfSymBinding(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ElfSymBinding();
}}
 
namespace Rose {
    std::string stringifySgAsmElfSymbolElfSymBinding(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymBinding();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 19126
namespace stringify { namespace SgAsmElfSymbol {
    const char* ElfSymType(int64_t);
 
    std::string ElfSymType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ElfSymType();
}}
 
namespace Rose {
    std::string stringifySgAsmElfSymbolElfSymType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 19803
namespace stringify { namespace SgAsmElfSegmentTableEntry {
    const char* SegmentType(int64_t);
 
    std::string SegmentType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SegmentType();
}}
 
namespace Rose {
    std::string stringifySgAsmElfSegmentTableEntrySegmentType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 19831
namespace stringify { namespace SgAsmElfSegmentTableEntry {
    const char* SegmentFlags(int64_t);
 
    std::string SegmentFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SegmentFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmElfSegmentTableEntrySegmentFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 20263
namespace stringify { namespace SgAsmElfSectionTableEntry {
    const char* SectionType(int64_t);
 
    std::string SectionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SectionType();
}}
 
namespace Rose {
    std::string stringifySgAsmElfSectionTableEntrySectionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 20290
namespace stringify { namespace SgAsmElfSectionTableEntry {
    const char* SectionFlags(int64_t);
 
    std::string SectionFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SectionFlags();
}}
 
namespace Rose {
    std::string stringifySgAsmElfSectionTableEntrySectionFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 20816
namespace stringify { namespace SgAsmElfRelocEntry {
    const char* RelocType(int64_t);
 
    std::string RelocType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& RelocType();
}}
 
namespace Rose {
    std::string stringifySgAsmElfRelocEntryRelocType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfRelocEntryRelocType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 21518
namespace stringify { namespace SgAsmElfFileHeader {
    const char* ObjectType(int64_t);
 
    std::string ObjectType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ObjectType();
}}
 
namespace Rose {
    std::string stringifySgAsmElfFileHeaderObjectType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfFileHeaderObjectType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 23048
namespace stringify { namespace SgAsmElfDynamicEntry {
    const char* EntryType(int64_t);
 
    std::string EntryType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EntryType();
}}
 
namespace Rose {
    std::string stringifySgAsmElfDynamicEntryEntryType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmElfDynamicEntryEntryType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 30185
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolDefState(int64_t);
 
    std::string SymbolDefState(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SymbolDefState();
}}
 
namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolDefState(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolDefState();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 30192
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolType(int64_t);
 
    std::string SymbolType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SymbolType();
}}
 
namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 30206
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolBinding(int64_t);
 
    std::string SymbolBinding(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SymbolBinding();
}}
 
namespace Rose {
    std::string stringifySgAsmGenericSymbolSymbolBinding(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolBinding();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 31110
namespace stringify { namespace SgAsmGenericSection {
    const char* SectionPurpose(int64_t);
 
    std::string SectionPurpose(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SectionPurpose();
}}
 
namespace Rose {
    std::string stringifySgAsmGenericSectionSectionPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmGenericSectionSectionPurpose();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 35389
namespace stringify { namespace SgAsmCilMetadataHeap {
    const char* ReferenceKind(int64_t);
 
    std::string ReferenceKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ReferenceKind();
}}
 
namespace Rose {
    std::string stringifySgAsmCilMetadataHeapReferenceKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmCilMetadataHeapReferenceKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 40592
namespace stringify { namespace SgAsmBlock {
    const char* Reason(int64_t);
 
    std::string Reason(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Reason();
}}
 
namespace Rose {
    std::string stringifySgAsmBlockReason(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmBlockReason();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 42079
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecFamily(int64_t);
 
    std::string ExecFamily(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ExecFamily();
}}
 
namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecFamily(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecFamily();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 42091
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecABI(int64_t);
 
    std::string ExecABI(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ExecABI();
}}
 
namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecABI(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecABI();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 42116
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* InsSetArchitecture(int64_t);
 
    std::string InsSetArchitecture(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& InsSetArchitecture();
}}
 
namespace Rose {
    std::string stringifySgAsmExecutableFileFormatInsSetArchitecture(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatInsSetArchitecture();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 42298
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecPurpose(int64_t);
 
    std::string ExecPurpose(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ExecPurpose();
}}
 
namespace Rose {
    std::string stringifySgAsmExecutableFileFormatExecPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecPurpose();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 91
namespace stringify {
    const char* ConstructParamEnum(int64_t);
 
    std::string ConstructParamEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ConstructParamEnum();
}
 
namespace Rose {
    std::string stringifyConstructParamEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyConstructParamEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 96
namespace stringify {
    const char* BuildAccessEnum(int64_t);
 
    std::string BuildAccessEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& BuildAccessEnum();
}
 
namespace Rose {
    std::string stringifyBuildAccessEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBuildAccessEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 104
namespace stringify {
    const char* CopyConfigEnum(int64_t);
 
    std::string CopyConfigEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CopyConfigEnum();
}
 
namespace Rose {
    std::string stringifyCopyConfigEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCopyConfigEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 125
namespace stringify {
    const char* TraversalEnum(int64_t);
 
    std::string TraversalEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TraversalEnum();
}
 
namespace Rose {
    std::string stringifyTraversalEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTraversalEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 130
namespace stringify {
    const char* DeleteEnum(int64_t);
 
    std::string DeleteEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DeleteEnum();
}
 
namespace Rose {
    std::string stringifyDeleteEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDeleteEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/stringSupport/FileUtility.h line 25
namespace stringify { namespace Rose { namespace StringUtility {
    const char* OSType(int64_t);
 
    std::string OSType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OSType();
}}}
 
namespace Rose {
    std::string stringifyStringUtilityOSType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyStringUtilityOSType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/util/stringSupport/FileUtility.h line 150
namespace stringify { namespace Rose { namespace StringUtility {
    const char* FileNameLocation(int64_t);
 
    std::string FileNameLocation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& FileNameLocation();
}}}
 
namespace Rose {
    std::string stringifyStringUtilityFileNameLocation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyStringUtilityFileNameLocation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astProcessing/AstAttributeMechanism.C line 21
namespace stringify {
    const char* WarningType(int64_t);
 
    std::string WarningType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& WarningType();
}
 
namespace Rose {
    std::string stringifyWarningType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyWarningType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astProcessing/AstAttributeMechanism.h line 41
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/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/astMatching/matcherparser.C line 1846
namespace stringify {
    const char* yytokentype(int64_t);
 
    std::string yytokentype(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& yytokentype();
}
 
namespace Rose {
    std::string stringify_yytokentype(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_yytokentype();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astMatching/MatchOperation.h line 40
namespace stringify { namespace MatchStatus {
    const char* PatternMatchMode(int64_t);
 
    std::string PatternMatchMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& PatternMatchMode();
}}
 
namespace Rose {
    std::string stringifyMatchStatusPatternMatchMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMatchStatusPatternMatchMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astMatching/MatchOperation.h line 41
namespace stringify { namespace MatchStatus {
    const char* CheckNodeMode(int64_t);
 
    std::string CheckNodeMode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CheckNodeMode();
}}
 
namespace Rose {
    std::string stringifyMatchStatusCheckNodeMode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyMatchStatusCheckNodeMode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/libraryIdentification/libraryIdentification.h line 18
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/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/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/astUtil/AstUtilInterface.h line 13
namespace stringify { namespace AstUtilInterface {
    const char* OperatorSideEffect(int64_t);
 
    std::string OperatorSideEffect(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OperatorSideEffect();
}}
 
namespace Rose {
    std::string stringifyAstUtilInterfaceOperatorSideEffect(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstUtilInterfaceOperatorSideEffect();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astUtil/astInterface/AstInterface.h line 18
namespace stringify { namespace AstNodePtr {
    const char* SpecialAstTypes(int64_t);
 
    std::string SpecialAstTypes(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SpecialAstTypes();
}}
 
namespace Rose {
    std::string stringifyAstNodePtrSpecialAstTypes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstNodePtrSpecialAstTypes();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/Labeler.h line 15
namespace stringify { namespace CodeThorn { namespace LabelProperty {
    const char* LabelType(int64_t);
 
    std::string LabelType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& LabelType();
}}}
 
namespace Rose {
    std::string stringifyCodeThornLabelPropertyLabelType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornLabelPropertyLabelType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/Labeler.h line 50
namespace stringify { namespace CodeThorn { namespace LabelProperty {
    const char* IOType(int64_t);
 
    std::string IOType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IOType();
}}}
 
namespace Rose {
    std::string stringifyCodeThornLabelPropertyIOType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornLabelPropertyIOType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/VariableIdMapping.h line 174
namespace stringify { namespace CodeThorn { namespace VariableIdMapping {
    const char* AggregateType(int64_t);
 
    std::string AggregateType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AggregateType();
}}}
 
namespace Rose {
    std::string stringifyCodeThornVariableIdMappingAggregateType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornVariableIdMappingAggregateType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/VariableIdMapping.h line 175
namespace stringify { namespace CodeThorn { namespace VariableIdMapping {
    const char* VariableScope(int64_t);
 
    std::string VariableScope(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& VariableScope();
}}}
 
namespace Rose {
    std::string stringifyCodeThornVariableIdMappingVariableScope(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCodeThornVariableIdMappingVariableScope();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/SgNodeHelper.h line 542
namespace stringify { namespace SgNodeHelper { namespace Pattern { namespace OutputTarget {
    const char* OType(int64_t);
 
    std::string OType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& OType();
}}}}
 
namespace Rose {
    std::string stringifySgNodeHelperPatternOutputTargetOType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgNodeHelperPatternOutputTargetOType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/xomp.c line 63
namespace stringify {
    const char* omp_rtl_enum(int64_t);
 
    std::string omp_rtl_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_rtl_enum();
}
 
namespace Rose {
    std::string stringify_omp_rtl_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_rtl_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/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/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/astQuery/booleanQuery.h line 43
namespace stringify { namespace BooleanQuery {
    const char* TypeOfQueryType(int64_t);
 
    std::string TypeOfQueryType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryType();
}}
 
namespace Rose {
    std::string stringifyBooleanQueryTypeOfQueryType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBooleanQueryTypeOfQueryType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nameQuery.h line 74
namespace stringify { namespace NameQuery {
    const char* TypeOfQueryTypeOneParameter(int64_t);
 
    std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
}}
 
namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeOneParameter();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nameQuery.h line 94
namespace stringify { namespace NameQuery {
    const char* TypeOfQueryTypeTwoParameters(int64_t);
 
    std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
}}
 
namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeTwoParameters();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/astQuery.h line 81
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/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/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/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/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/OpenAnalysis/Interface/IRInterface.h line 163
namespace stringify {
    const char* IRProcType(int64_t);
 
    std::string IRProcType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IRProcType();
}
 
namespace Rose {
    std::string stringifyIRProcType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyIRProcType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 173
namespace stringify {
    const char* IRStmtType(int64_t);
 
    std::string IRStmtType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& IRStmtType();
}
 
namespace Rose {
    std::string stringifyIRStmtType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyIRStmtType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CallGraph/CallGraph.h line 73
namespace stringify { namespace CallGraph {
    const char* EdgeType(int64_t);
 
    std::string EdgeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeType();
}}
 
namespace Rose {
    std::string stringifyCallGraphEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCallGraphEdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Utils/BaseGraph.h line 261
namespace stringify { namespace BaseGraph { namespace BiDirNodesIterator {
    const char* dirType(int64_t);
 
    std::string dirType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& dirType();
}}}
 
namespace Rose {
    std::string stringifyBaseGraphBiDirNodesIterator_dirType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyBaseGraphBiDirNodesIterator_dirType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/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/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/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/genericDataflow/cfgUtils/CallGraphTraverse.h line 119
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/lattice/ConstrGraph.h line 45
namespace stringify { namespace ConstrGraph {
    const char* levels(int64_t);
 
    std::string levels(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& levels();
}}
 
namespace Rose {
    std::string stringifyConstrGraph_levels(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyConstrGraph_levels();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/simpleAnalyses/taintAnalysis.h line 63
namespace stringify { namespace TaintLattice {
    const char* Vertex(int64_t);
 
    std::string Vertex(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Vertex();
}}
 
namespace Rose {
    std::string stringifyTaintLatticeVertex(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyTaintLatticeVertex();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/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/dominanceAnalysis/DominatorTree.h line 13
namespace stringify { namespace DominatorTreesAndDominanceFrontiers {
    const char* Dir_ection(int64_t);
 
    std::string Dir_ection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Dir_ection();
}}
 
namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDir_ection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDir_ection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/ReadWriteSetAnalysis/ReadWriteSetRecords.h line 26
namespace stringify { namespace ReadWriteSets {
    const char* Globality(int64_t);
 
    std::string Globality(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Globality();
}}
 
namespace Rose {
    std::string stringifyReadWriteSetsGlobality(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyReadWriteSetsGlobality();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/ReadWriteSetAnalysis/ReadWriteSetRecords.h line 42
namespace stringify { namespace ReadWriteSets {
    const char* VarType(int64_t);
 
    std::string VarType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& VarType();
}}
 
namespace Rose {
    std::string stringifyReadWriteSetsVarType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyReadWriteSetsVarType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/ReadWriteSetAnalysis/ReadWriteSetRecords.h line 58
namespace stringify { namespace ReadWriteSets {
    const char* AccessType(int64_t);
 
    std::string AccessType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AccessType();
}}
 
namespace Rose {
    std::string stringifyReadWriteSetsAccessType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyReadWriteSetsAccessType();
}
 
// 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/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/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 280
namespace stringify { namespace CollectAliasRelations {
    const char* COLOR(int64_t);
 
    std::string COLOR(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& COLOR();
}}
 
namespace Rose {
    std::string stringifyCollectAliasRelationsCOLOR(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCollectAliasRelationsCOLOR();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/IntraProcAliasAnalysis.h line 281
namespace stringify { namespace CollectAliasRelations {
    const char* TRAVERSAL_TYPE(int64_t);
 
    std::string TRAVERSAL_TYPE(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TRAVERSAL_TYPE();
}}
 
namespace Rose {
    std::string stringifyCollectAliasRelationsTRAVERSAL_TYPE(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCollectAliasRelationsTRAVERSAL_TYPE();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/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 15
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/utility_functions.C line 1016
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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/Rosebud/Utility.h line 20
namespace stringify { namespace Rosebud {
    const char* Access(int64_t);
 
    std::string Access(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Access();
}}
 
namespace Rose {
    std::string stringifyRosebudAccess(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRosebudAccess();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rosebud/Utility.h line 95
namespace stringify { namespace Rosebud {
    const char* CamelCase(int64_t);
 
    std::string CamelCase(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CamelCase();
}}
 
namespace Rose {
    std::string stringifyRosebudCamelCase(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRosebudCamelCase();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rosebud/Ast.h line 138
namespace stringify { namespace Rosebud { namespace Ast { namespace CppStack {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}}
 
namespace Rose {
    std::string stringifyRosebudAstCppStackType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRosebudAstCppStackType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rosebud/BasicTypes.h line 465
namespace stringify { namespace Rosebud {
    const char* Expand(int64_t);
 
    std::string Expand(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Expand();
}}
 
namespace Rose {
    std::string stringifyRosebudExpand(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRosebudExpand();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Rosebud/BasicTypes.h line 472
namespace stringify { namespace Rosebud {
    const char* When(int64_t);
 
    std::string When(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& When();
}}
 
namespace Rose {
    std::string stringifyRosebudWhen(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyRosebudWhen();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/DocumentMarkup.h line 42
namespace stringify { namespace Sawyer { namespace Document { namespace Markup {
    const char* TokenType(int64_t);
 
    std::string TokenType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TokenType();
}}}}
 
namespace Rose {
    std::string stringifySawyerDocumentMarkupTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerDocumentMarkupTokenType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/CommandLine.h line 173
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* SortOrder(int64_t);
 
    std::string SortOrder(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SortOrder();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineSortOrder(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineSortOrder();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/CommandLine.h line 186
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* Canonical(int64_t);
 
    std::string Canonical(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Canonical();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineCanonical(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineCanonical();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/CommandLine.h line 194
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* ShowGroupName(int64_t);
 
    std::string ShowGroupName(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ShowGroupName();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineShowGroupName(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineShowGroupName();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/CommandLine.h line 202
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* SwitchSkipping(int64_t);
 
    std::string SwitchSkipping(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SwitchSkipping();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineSwitchSkipping(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineSwitchSkipping();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/CommandLine.h line 2010
namespace stringify { namespace Sawyer { namespace CommandLine {
    const char* WhichValue(int64_t);
 
    std::string WhichValue(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& WhichValue();
}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineWhichValue(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineWhichValue();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/CommandLine.h line 3065
namespace stringify { namespace Sawyer { namespace CommandLine { namespace Parser {
    const char* GroupingFlags(int64_t);
 
    std::string GroupingFlags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& GroupingFlags();
}}}}
 
namespace Rose {
    std::string stringifySawyerCommandLineParserGroupingFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerCommandLineParserGroupingFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Graph.h line 645
namespace stringify { namespace Sawyer { namespace Container { namespace Graph {
    const char* EdgePhase(int64_t);
 
    std::string EdgePhase(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgePhase();
}}}}
 
namespace Rose {
    std::string stringifySawyerContainerGraphEdgePhase(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerGraphEdgePhase();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Tree.h line 44
namespace stringify { namespace Sawyer { namespace Tree {
    const char* TraversalEvent(int64_t);
 
    std::string TraversalEvent(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TraversalEvent();
}}}
 
namespace Rose {
    std::string stringifySawyerTreeTraversalEvent(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerTreeTraversalEvent();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Tree.h line 252
namespace stringify { namespace Sawyer { namespace Tree { namespace Vertex {
    const char* Link(int64_t);
 
    std::string Link(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Link();
}}}}
 
namespace Rose {
    std::string stringifySawyerTreeVertexLink(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerTreeVertexLink();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/stringifyEnums.C line 39
namespace stringify {
    const char* Generate(int64_t);
 
    std::string Generate(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Generate();
}
 
namespace Rose {
    std::string stringifyGenerate(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyGenerate();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/stringifyEnums.C line 46
namespace stringify {
    const char* Flag(int64_t);
 
    std::string Flag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Flag();
}
 
namespace Rose {
    std::string stringifyFlag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyFlag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Access.h line 19
namespace stringify { namespace Sawyer { namespace Access {
    const char* Access(int64_t);
 
    std::string Access(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Access();
}}}
 
namespace Rose {
    std::string stringifySawyerAccessAccess(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerAccessAccess();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Clexer.h line 26
namespace stringify { namespace Sawyer { namespace Language { namespace Clexer {
    const char* TokenType(int64_t);
 
    std::string TokenType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TokenType();
}}}}
 
namespace Rose {
    std::string stringifySawyerLanguageClexerTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerLanguageClexerTokenType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Yaml.h line 151
namespace stringify { namespace Sawyer { namespace Yaml { namespace Exception {
    const char* eType(int64_t);
 
    std::string eType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eType();
}}}}
 
namespace Rose {
    std::string stringifySawyerYamlException_eType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerYamlException_eType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Yaml.h line 256
namespace stringify { namespace Sawyer { namespace Yaml { namespace Iterator {
    const char* eType(int64_t);
 
    std::string eType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eType();
}}}}
 
namespace Rose {
    std::string stringifySawyerYamlIterator_eType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerYamlIterator_eType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Yaml.h line 313
namespace stringify { namespace Sawyer { namespace Yaml { namespace ConstIterator {
    const char* eType(int64_t);
 
    std::string eType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eType();
}}}}
 
namespace Rose {
    std::string stringifySawyerYamlConstIterator_eType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerYamlConstIterator_eType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Yaml.h line 330
namespace stringify { namespace Sawyer { namespace Yaml { namespace Node {
    const char* eType(int64_t);
 
    std::string eType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& eType();
}}}}
 
namespace Rose {
    std::string stringifySawyerYamlNode_eType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerYamlNode_eType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/GraphTraversal.h line 39
namespace stringify { namespace Sawyer { namespace Container { namespace Algorithm {
    const char* TraversalEvent(int64_t);
 
    std::string TraversalEvent(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TraversalEvent();
}}}}
 
namespace Rose {
    std::string stringifySawyerContainerAlgorithmTraversalEvent(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerAlgorithmTraversalEvent();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/GraphAlgorithm.h line 478
namespace stringify { namespace Sawyer { namespace Container { namespace Algorithm {
    const char* CsiNextAction(int64_t);
 
    std::string CsiNextAction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& CsiNextAction();
}}}}
 
namespace Rose {
    std::string stringifySawyerContainerAlgorithmCsiNextAction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerContainerAlgorithmCsiNextAction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Database.h line 293
namespace stringify { namespace Sawyer { namespace Database { namespace Statement {
    const char* State(int64_t);
 
    std::string State(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& State();
}}}}
 
namespace Rose {
    std::string stringifySawyerDatabaseStatementState(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerDatabaseStatementState();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Message.h line 313
namespace stringify { namespace Sawyer { namespace Message {
    const char* Importance(int64_t);
 
    std::string Importance(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Importance();
}}}
 
namespace Rose {
    std::string stringifySawyerMessageImportance(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessageImportance();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Message.h line 343
namespace stringify { namespace Sawyer { namespace Message {
    const char* AnsiColor(int64_t);
 
    std::string AnsiColor(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& AnsiColor();
}}}
 
namespace Rose {
    std::string stringifySawyerMessageAnsiColor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessageAnsiColor();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/Sawyer/Message.h line 990
namespace stringify { namespace Sawyer { namespace Message { namespace Prefix {
    const char* When(int64_t);
 
    std::string When(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& When();
}}}}
 
namespace Rose {
    std::string stringifySawyerMessagePrefixWhen(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySawyerMessagePrefixWhen();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/AsmUnparser.h line 259
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/unparser/CxxCodeGeneration/unparseCxx.h line 543
namespace stringify { namespace Unparse_ExprStmt {
    const char* token_sequence_position_enum_type(int64_t);
 
    std::string token_sequence_position_enum_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& token_sequence_position_enum_type();
}}
 
namespace Rose {
    std::string stringifyUnparse_ExprStmt_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnparse_ExprStmt_token_sequence_position_enum_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/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 40
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 66
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/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/frontend/Experimental_Jovial_ROSE_Connection/preprocess.C line 32
namespace stringify { namespace Jovial {
    const char* State(int64_t);
 
    std::string State(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& State();
}}
 
namespace Rose {
    std::string stringifyJovialState(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyJovialState();
}
 
// 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/Experimental_Ada_ROSE_Connection/parser/a_nodes/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/parser/a_nodes/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/parser/a_nodes/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/parser/a_nodes/include/a_nodes.h line 246
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/parser/a_nodes/include/a_nodes.h line 287
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/parser/a_nodes/include/a_nodes.h line 391
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/parser/a_nodes/include/a_nodes.h line 407
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/parser/a_nodes/include/a_nodes.h line 417
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/parser/a_nodes/include/a_nodes.h line 814
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/parser/a_nodes/include/a_nodes.h line 847
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/parser/a_nodes/include/a_nodes.h line 871
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/parser/a_nodes/include/a_nodes.h line 881
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/parser/a_nodes/include/a_nodes.h line 890
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/parser/a_nodes/include/a_nodes.h line 899
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/parser/a_nodes/include/a_nodes.h line 906
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/parser/a_nodes/include/a_nodes.h line 928
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/parser/a_nodes/include/a_nodes.h line 939
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/parser/a_nodes/include/a_nodes.h line 1273
namespace stringify {
    const char* Expression_Kinds(int64_t);
 
    std::string Expression_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Expression_Kinds();
}
 
namespace Rose {
    std::string stringifyExpression_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyExpression_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1318
namespace stringify {
    const char* Attribute_Kinds(int64_t);
 
    std::string Attribute_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Attribute_Kinds();
}
 
namespace Rose {
    std::string stringifyAttribute_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAttribute_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1544
namespace stringify {
    const char* Association_Kinds(int64_t);
 
    std::string Association_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Association_Kinds();
}
 
namespace Rose {
    std::string stringifyAssociation_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAssociation_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1593
namespace stringify {
    const char* Statement_Kinds(int64_t);
 
    std::string Statement_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Statement_Kinds();
}
 
namespace Rose {
    std::string stringifyStatement_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyStatement_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1741
namespace stringify {
    const char* Path_Kinds(int64_t);
 
    std::string Path_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Path_Kinds();
}
 
namespace Rose {
    std::string stringifyPath_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPath_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1821
namespace stringify {
    const char* Clause_Kinds(int64_t);
 
    std::string Clause_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Clause_Kinds();
}
 
namespace Rose {
    std::string stringifyClause_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyClause_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1833
namespace stringify {
    const char* _Representation_Clause_Kinds(int64_t);
 
    std::string _Representation_Clause_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& _Representation_Clause_Kinds();
}
 
namespace Rose {
    std::string stringify_Representation_Clause_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_Representation_Clause_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1918
namespace stringify {
    const char* Enclosing_Kinds(int64_t);
 
    std::string Enclosing_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Enclosing_Kinds();
}
 
namespace Rose {
    std::string stringifyEnclosing_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyEnclosing_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1970
namespace stringify {
    const char* Unit_Kinds(int64_t);
 
    std::string Unit_Kinds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Unit_Kinds();
}
 
namespace Rose {
    std::string stringifyUnit_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnit_Kinds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 2037
namespace stringify {
    const char* Unit_Classes(int64_t);
 
    std::string Unit_Classes(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Unit_Classes();
}
 
namespace Rose {
    std::string stringifyUnit_Classes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnit_Classes();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 2058
namespace stringify {
    const char* Unit_Origins(int64_t);
 
    std::string Unit_Origins(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Unit_Origins();
}
 
namespace Rose {
    std::string stringifyUnit_Origins(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyUnit_Origins();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/ECJ_ROSE_Connection/JavaParserActionROSE.C line 4135
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/SageIII/omp.h line 30
namespace stringify {
    const char* omp_lock_hint_t(int64_t);
 
    std::string omp_lock_hint_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_lock_hint_t();
}
 
namespace Rose {
    std::string stringify_omp_lock_hint_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_lock_hint_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/omp.h line 46
namespace stringify {
    const char* omp_sched_t(int64_t);
 
    std::string omp_sched_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_sched_t();
}
 
namespace Rose {
    std::string stringify_omp_sched_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_sched_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/omp.h line 57
namespace stringify {
    const char* omp_proc_bind_t(int64_t);
 
    std::string omp_proc_bind_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_proc_bind_t();
}
 
namespace Rose {
    std::string stringify_omp_proc_bind_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_omp_proc_bind_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 12
namespace stringify { namespace ROSE_token_ids {
    const char* whitespace(int64_t);
 
    std::string whitespace(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& whitespace();
}}
 
namespace Rose {
    std::string stringifyROSE_token_ids_whitespace(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_ids_whitespace();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 21
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_keywords(int64_t);
 
    std::string ROSE_C_CXX_keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_keywords();
}}
 
namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 159
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_alternate_tok(int64_t);
 
    std::string ROSE_C_CXX_alternate_tok(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_alternate_tok();
}}
 
namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_alternate_tok(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_alternate_tok();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/general_token_defs.h line 171
namespace stringify { namespace ROSE_token_ids {
    const char* ROSE_C_CXX_Additional_Info(int64_t);
 
    std::string ROSE_C_CXX_Additional_Info(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_Additional_Info();
}}
 
namespace Rose {
    std::string stringifyROSE_token_idsROSE_C_CXX_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_token_idsROSE_C_CXX_Additional_Info();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/OmpAttribute.h line 31
namespace stringify { namespace OmpSupport {
    const char* omp_construct_enum(int64_t);
 
    std::string omp_construct_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_construct_enum();
}}
 
namespace Rose {
    std::string stringifyOmpSupport_omp_construct_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOmpSupport_omp_construct_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/virtualCFG/virtualBinCFG.h line 17
namespace stringify { namespace VirtualBinCFG {
    const char* EdgeConditionKind(int64_t);
 
    std::string EdgeConditionKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeConditionKind();
}}
 
namespace Rose {
    std::string stringifyVirtualBinCFG_EdgeConditionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyVirtualBinCFG_EdgeConditionKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/virtualCFG/virtualCFG.h line 47
namespace stringify { namespace VirtualCFG {
    const char* EdgeConditionKind(int64_t);
 
    std::string EdgeConditionKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& EdgeConditionKind();
}}
 
namespace Rose {
    std::string stringifyVirtualCFG_EdgeConditionKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyVirtualCFG_EdgeConditionKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/sageInterface/sageInterface.h line 1965
namespace stringify { namespace SageInterface { namespace DeferredTransformation {
    const char* TransformationKind(int64_t);
 
    std::string TransformationKind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TransformationKind();
}}}
 
namespace Rose {
    std::string stringifySageInterfaceDeferredTransformationTransformationKind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySageInterfaceDeferredTransformationTransformationKind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/sageInterface/sageBuilder.h line 138
namespace stringify { namespace SageBuilder {
    const char* SourcePositionClassification(int64_t);
 
    std::string SourcePositionClassification(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SourcePositionClassification();
}}
 
namespace Rose {
    std::string stringifySageBuilderSourcePositionClassification(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySageBuilderSourcePositionClassification();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 133
namespace stringify { namespace PreprocessingInfo {
    const char* RelativePositionType(int64_t);
 
    std::string RelativePositionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& RelativePositionType();
}}
 
namespace Rose {
    std::string stringifyPreprocessingInfoRelativePositionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPreprocessingInfoRelativePositionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 155
namespace stringify { namespace PreprocessingInfo {
    const char* DirectiveType(int64_t);
 
    std::string DirectiveType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DirectiveType();
}}
 
namespace Rose {
    std::string stringifyPreprocessingInfoDirectiveType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyPreprocessingInfoDirectiveType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/rose_attributes_list.h line 537
namespace stringify { namespace ROSEAttributesList {
    const char* languageTypeEnum(int64_t);
 
    std::string languageTypeEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& languageTypeEnum();
}}
 
namespace Rose {
    std::string stringifyROSEAttributesList_languageTypeEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSEAttributesList_languageTypeEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 25
namespace stringify { namespace AstAttributeDOT {
    const char* DOTStyles(int64_t);
 
    std::string DOTStyles(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DOTStyles();
}}
 
namespace Rose {
    std::string stringifyAstAttributeDOT_DOTStyles(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAstAttributeDOT_DOTStyles();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 90
namespace stringify { namespace DOTGraphNode {
    const char* DOTShapeTypes(int64_t);
 
    std::string DOTShapeTypes(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DOTShapeTypes();
}}
 
namespace Rose {
    std::string stringifyDOTGraphNodeDOTShapeTypes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGraphNodeDOTShapeTypes();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/AstAttributeDOT.h line 137
namespace stringify { namespace DOTGraphEdge {
    const char* DOTArrowTypes(int64_t);
 
    std::string DOTArrowTypes(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& DOTArrowTypes();
}}
 
namespace Rose {
    std::string stringifyDOTGraphEdgeDOTArrowTypes(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGraphEdgeDOTArrowTypes();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/astGraph.h line 12
namespace stringify { namespace AST_Graph {
    const char* pointerHandling(int64_t);
 
    std::string pointerHandling(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& pointerHandling();
}}
 
namespace Rose {
    std::string stringifyAST_Graph_pointerHandling(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_Graph_pointerHandling();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/SageIII/astVisualization/astGraph.h line 19
namespace stringify { namespace AST_Graph {
    const char* traversalType(int64_t);
 
    std::string traversalType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& traversalType();
}}
 
namespace Rose {
    std::string stringifyAST_Graph_traversalType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyAST_Graph_traversalType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/SageTreeBuilder.h line 55
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/Experimental_General_Language_Support/Tokens.h line 18
namespace stringify { namespace Rose { namespace builder {
    const char* JovialEnum(int64_t);
 
    std::string JovialEnum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& JovialEnum();
}}}
 
namespace Rose {
    std::string stringify_builderJovialEnum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_builderJovialEnum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 14
namespace stringify { namespace LanguageTranslation {
    const char* FunctionModifier(int64_t);
 
    std::string FunctionModifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& FunctionModifier();
}}
 
namespace Rose {
    std::string stringifyLanguageTranslationFunctionModifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyLanguageTranslationFunctionModifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 42
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 52
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_Flang_ROSE_Connection/sage-build.C line 72
namespace stringify {
    const char* Order(int64_t);
 
    std::string Order(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Order();
}
 
namespace Rose {
    std::string stringifyOrder(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyOrder();
}
 
// 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/EDG/edgRose/debugging.C line 266
namespace stringify {
    const char* an_init_kind_tag(int64_t);
 
    std::string an_init_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_init_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_init_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_init_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 1182
namespace stringify {
    const char* a_decl_modifier_tag(int64_t);
 
    std::string a_decl_modifier_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_decl_modifier_tag();
}
 
namespace Rose {
    std::string stringify_a_decl_modifier_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_decl_modifier_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 7715
namespace stringify {
    const char* a_local_expr_node_ref_kind_tag(int64_t);
 
    std::string a_local_expr_node_ref_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_local_expr_node_ref_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_local_expr_node_ref_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_local_expr_node_ref_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 10917
namespace stringify {
    const char* an_operand_kind_tag(int64_t);
 
    std::string an_operand_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_operand_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_operand_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_operand_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/debugging.C line 13058
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 14113
namespace stringify {
    const char* a_name_linkage_kind_tag(int64_t);
 
    std::string a_name_linkage_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_name_linkage_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_name_linkage_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_name_linkage_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/edgRose/edgRose.C line 6386
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 46793
namespace stringify {
    const char* a_special_function_kind_tag(int64_t);
 
    std::string a_special_function_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_special_function_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_special_function_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_special_function_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/util/decode.c line 4297
namespace stringify {
    const char* a_substitution_kind(int64_t);
 
    std::string a_substitution_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_substitution_kind();
}
 
namespace Rose {
    std::string stringify_a_substitution_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_substitution_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.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_5.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_5.0/include/cxxabi.h line 90
namespace stringify { namespace __cxxabiv1 { namespace __pbase_type_info {
    const char* __masks(int64_t);
 
    std::string __masks(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& __masks();
}}}
 
namespace Rose {
    std::string stringify__cxxabiv1__pbase_type_info__masks(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify__cxxabiv1__pbase_type_info__masks();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/lib_src/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_5.0/lib_src/rtti.c line 120
namespace stringify {
    const char* a_result_virtuality(int64_t);
 
    std::string a_result_virtuality(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_result_virtuality();
}
 
namespace Rose {
    std::string stringify_a_result_virtuality(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_result_virtuality();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/lexical.h line 1949
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_5.0/src/il.h line 80
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_5.0/src/expr.h line 87
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_5.0/src/il_def.h line 377
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_5.0/src/il_def.h line 397
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_5.0/src/il_def.h line 1550
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_5.0/src/il_def.h line 1661
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_5.0/src/il_def.h line 2380
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_5.0/src/il_def.h line 2456
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_5.0/src/il_def.h line 2481
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_5.0/src/il_def.h line 2550
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_5.0/src/il_def.h line 3171
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_5.0/src/il_def.h line 3223
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_5.0/src/il_def.h line 3484
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_5.0/src/il_def.h line 3901
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_5.0/src/il_def.h line 4035
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_5.0/src/il_def.h line 4809
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_5.0/src/il_def.h line 4857
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_5.0/src/il_def.h line 4947
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_5.0/src/il_def.h line 4979
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_5.0/src/il_def.h line 5005
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_5.0/src/il_def.h line 5061
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_5.0/src/il_def.h line 5226
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_5.0/src/il_def.h line 5237
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_5.0/src/il_def.h line 5412
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_5.0/src/il_def.h line 5514
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_5.0/src/il_def.h line 5524
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_5.0/src/il_def.h line 5535
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_5.0/src/il_def.h line 5717
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_5.0/src/il_def.h line 5743
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_5.0/src/il_def.h line 5764
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_5.0/src/il_def.h line 6034
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_5.0/src/il_def.h line 6048
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_5.0/src/il_def.h line 6355
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_5.0/src/il_def.h line 6543
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_5.0/src/il_def.h line 6818
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_5.0/src/il_def.h line 7427
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_5.0/src/il_def.h line 7442
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_5.0/src/il_def.h line 7476
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_5.0/src/il_def.h line 7509
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_5.0/src/il_def.h line 7642
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_5.0/src/il_def.h line 8309
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_5.0/src/il_def.h line 8575
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_5.0/src/il_def.h line 8633
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_5.0/src/il_def.h line 9768
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_5.0/src/il_def.h line 10858
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_5.0/src/il_def.h line 10912
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_5.0/src/il_def.h line 12165
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_5.0/src/il_def.h line 12288
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_5.0/src/il_def.h line 12330
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_5.0/src/il_def.h line 12850
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_5.0/src/il_def.h line 14049
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_5.0/src/il_def.h line 14278
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_5.0/src/il_def.h line 15070
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_5.0/src/il_def.h line 15297
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_5.0/src/il_def.h line 15385
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_5.0/src/il_def.h line 15489
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_5.0/src/il_def.h line 15834
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_5.0/src/il_def.h line 15977
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_5.0/src/il_def.h line 15999
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_5.0/src/il_def.h line 16385
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_5.0/src/lower_il.h line 421
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_5.0/src/ms_metadata.cpp line 1031
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_5.0/src/ms_metadata.cpp line 1292
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_5.0/src/ms_metadata.cpp line 1413
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_5.0/src/ms_metadata.cpp line 1565
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_5.0/src/ms_metadata.cpp line 3806
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_5.0/src/ms_metadata.cpp line 3845
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_5.0/src/pragma.h line 49
namespace stringify {
    const char* a_pragma_binding_kind(int64_t);
 
    std::string a_pragma_binding_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_pragma_binding_kind();
}
 
namespace Rose {
    std::string stringify_a_pragma_binding_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_pragma_binding_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/error.c line 91
namespace stringify {
    const char* a_diag_fill_in_kind(int64_t);
 
    std::string a_diag_fill_in_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_diag_fill_in_kind();
}
 
namespace Rose {
    std::string stringify_a_diag_fill_in_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_diag_fill_in_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/error.c line 196
namespace stringify {
    const char* a_diagnostic_kind(int64_t);
 
    std::string a_diagnostic_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_diagnostic_kind();
}
 
namespace Rose {
    std::string stringify_a_diagnostic_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_diagnostic_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/builtin_defs.h line 22
namespace stringify {
    const char* a_builtin_function_type_index(int64_t);
 
    std::string a_builtin_function_type_index(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_builtin_function_type_index();
}
 
namespace Rose {
    std::string stringify_a_builtin_function_type_index(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_function_type_index();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/builtin_defs.h line 4277
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_5.0/src/builtin_defs.h line 4862
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_5.0/src/host_envir.h line 2370
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_5.0/src/host_envir.h line 3754
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_5.0/src/disp/decls.c line 16203
namespace stringify {
    const char* an_end_of_decl_action(int64_t);
 
    std::string an_end_of_decl_action(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_end_of_decl_action();
}
 
namespace Rose {
    std::string stringify_an_end_of_decl_action(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_end_of_decl_action();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/exprutil.h line 99
namespace stringify {
    const char* an_expression_kind_tag(int64_t);
 
    std::string an_expression_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& an_expression_kind_tag();
}
 
namespace Rose {
    std::string stringify_an_expression_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_expression_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/exprutil.h line 136
namespace stringify {
    const char* a_cast_source_form(int64_t);
 
    std::string a_cast_source_form(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cast_source_form();
}
 
namespace Rose {
    std::string stringify_a_cast_source_form(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_cast_source_form();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/exprutil.h line 155
namespace stringify {
    const char* a_type_class_kind(int64_t);
 
    std::string a_type_class_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_type_class_kind();
}
 
namespace Rose {
    std::string stringify_a_type_class_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_type_class_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/exprutil.h line 286
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_5.0/src/sys_predef.h line 212
namespace stringify {
    const char* a_builtin_user_function_kind_tag(int64_t);
 
    std::string a_builtin_user_function_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_builtin_user_function_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_builtin_user_function_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_builtin_user_function_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/sys_predef.h line 402
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_5.0/src/statements.h line 53
namespace stringify {
    const char* a_control_flow_descr_kind_tag(int64_t);
 
    std::string a_control_flow_descr_kind_tag(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_control_flow_descr_kind_tag();
}
 
namespace Rose {
    std::string stringify_a_control_flow_descr_kind_tag(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_control_flow_descr_kind_tag();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_5.0/src/ms_metadata.h line 19
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_5.0/src/mem_manage.h line 407
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_5.0/src/symbol_tbl.h line 436
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_5.0/src/symbol_tbl.h line 725
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_5.0/src/symbol_tbl.h line 3934
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_5.0/src/symbol_tbl.h line 4828
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.3/src/interpret.h line 66
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.3/src/decls.h line 28
namespace stringify {
    const char* a_tu_decl_stage(int64_t);
 
    std::string a_tu_decl_stage(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_tu_decl_stage();
}
 
namespace Rose {
    std::string stringify_a_tu_decl_stage(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_a_tu_decl_stage();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.3/src/floating.h line 425
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.3/src/floating.h line 524
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.3/src/ifc_modules.h line 2968
namespace stringify { namespace an_ifc_module {
    const char* a_cache_expr_option(int64_t);
 
    std::string a_cache_expr_option(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cache_expr_option();
}}
 
namespace Rose {
    std::string stringify_an_ifc_module_a_cache_expr_option(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ifc_module_a_cache_expr_option();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.3/src/ifc_modules.h line 2977
namespace stringify { namespace an_ifc_module {
    const char* a_cache_statement_option(int64_t);
 
    std::string a_cache_statement_option(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& a_cache_statement_option();
}}
 
namespace Rose {
    std::string stringify_an_ifc_module_a_cache_statement_option(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_an_ifc_module_a_cache_statement_option();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/EDG/EDG_6.3/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/Clang/clang-frontend-private.hpp line 156
namespace stringify { namespace ClangToSageTranslator {
    const char* Language(int64_t);
 
    std::string Language(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Language();
}}
 
namespace Rose {
    std::string stringifyClangToSageTranslatorLanguage(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyClangToSageTranslatorLanguage();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/CxxFrontend/Clang/clang-to-dot-private.hpp line 156
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 228
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/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 10
namespace stringify {
    const char* ROSE_Fortran_Identifiers(int64_t);
 
    std::string ROSE_Fortran_Identifiers(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Identifiers();
}
 
namespace Rose {
    std::string stringifyROSE_Fortran_Identifiers(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_Identifiers();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 140
namespace stringify {
    const char* ROSE_Fortran_Operators(int64_t);
 
    std::string ROSE_Fortran_Operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Operators();
}
 
namespace Rose {
    std::string stringifyROSE_Fortran_Operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_Operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs.h line 167
namespace stringify {
    const char* ROSE_Fortran_Additional_Info(int64_t);
 
    std::string ROSE_Fortran_Additional_Info(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Additional_Info();
}
 
namespace Rose {
    std::string stringifyROSE_Fortran_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_Additional_Info();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 14
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_keywords(int64_t);
 
    std::string ROSE_Fortran_keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_keywords();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_Fortran_keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 147
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_C_CXX_keywords(int64_t);
 
    std::string ROSE_C_CXX_keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_keywords();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_C_CXX_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_C_CXX_keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 215
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_Operators(int64_t);
 
    std::string ROSE_Fortran_Operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Operators();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_Operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_Fortran_Operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 242
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_C_CXX_operators(int64_t);
 
    std::string ROSE_C_CXX_operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_operators();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_C_CXX_operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_C_CXX_operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/OpenFortranParser_SAGE_Connection/rose_token_defs_gen.h line 321
namespace stringify { namespace ROSE_Fortran_defs {
    const char* ROSE_Fortran_Additional_Info(int64_t);
 
    std::string ROSE_Fortran_Additional_Info(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Additional_Info();
}}
 
namespace Rose {
    std::string stringifyROSE_Fortran_defsROSE_Fortran_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyROSE_Fortran_defsROSE_Fortran_Additional_Info();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Disassemblers/Assembler.h line 80
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/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/AssemblerX86.h line 146
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 387
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/3rdPartyLibraries/json/nlohmann/json.hpp line 4744
namespace stringify { namespace nlohmann { namespace detail {
    const char* input_format_t(int64_t);
 
    std::string input_format_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& input_format_t();
}}}
 
namespace Rose {
    std::string stringify_nlohmann_detail_input_format_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_detail_input_format_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 5909
namespace stringify { namespace nlohmann { namespace detail { namespace lexer_base {
    const char* token_type(int64_t);
 
    std::string token_type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& token_type();
}}}}
 
namespace Rose {
    std::string stringify_nlohmann_detail_lexer_base_token_type(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_detail_lexer_base_token_type();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 7668
namespace stringify { namespace nlohmann { namespace detail {
    const char* cbor_tag_handler_t(int64_t);
 
    std::string cbor_tag_handler_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& cbor_tag_handler_t();
}}}
 
namespace Rose {
    std::string stringify_nlohmann_detail_cbor_tag_handler_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_detail_cbor_tag_handler_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 15469
namespace stringify { namespace nlohmann { namespace detail {
    const char* error_handler_t(int64_t);
 
    std::string error_handler_t(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& error_handler_t();
}}}
 
namespace Rose {
    std::string stringify_nlohmann_detail_error_handler_t(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_detail_error_handler_t();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/json/nlohmann/json.hpp line 24668
namespace stringify { namespace nlohmann { namespace basic_json {
    const char* patch_operations(int64_t);
 
    std::string patch_operations(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& patch_operations();
}}}
 
namespace Rose {
    std::string stringify_nlohmann_basic_json_patch_operations(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_nlohmann_basic_json_patch_operations();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QRSelect.h line 26
namespace stringify { namespace qrs { namespace QRSelect {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}
 
namespace Rose {
    std::string stringify_qrsQRSelectType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRSelectType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QRButtons.h line 29
namespace stringify { namespace qrs { namespace QRButtons {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}
 
namespace Rose {
    std::string stringify_qrsQRButtonsType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRButtonsType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QREdit.h line 28
namespace stringify { namespace qrs { namespace QREdit {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}
 
namespace Rose {
    std::string stringify_qrsQREditType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQREditType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/TreeBox/QRTreeBox.h line 40
namespace stringify { namespace qrs { namespace QRTreeBox {
    const char* ToolbarIdx(int64_t);
 
    std::string ToolbarIdx(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ToolbarIdx();
}}}
 
namespace Rose {
    std::string stringify_qrsQRTreeBoxToolbarIdx(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRTreeBoxToolbarIdx();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/TreeBox/QRTreeBox.h line 107
namespace stringify { namespace qrs { namespace QRTreeBox {
    const char* popmenu_nodes_id(int64_t);
 
    std::string popmenu_nodes_id(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& popmenu_nodes_id();
}}}
 
namespace Rose {
    std::string stringify_qrsQRTreeBox_popmenu_nodes_id(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRTreeBox_popmenu_nodes_id();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/parenmatcher.h line 37
namespace stringify { namespace qrs { namespace Paren {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}
 
namespace Rose {
    std::string stringify_qrsParenType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsParenType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/parenmatcher.h line 48
namespace stringify { namespace qrs { namespace ParenMatcher {
    const char* Selection(int64_t);
 
    std::string Selection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Selection();
}}}
 
namespace Rose {
    std::string stringify_qrsParenMatcherSelection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsParenMatcherSelection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/paragdata.h line 36
namespace stringify { namespace qrs { namespace Symbol {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}
 
namespace Rose {
    std::string stringify_qrsSymbolType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsSymbolType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 122
namespace stringify { namespace qrs { namespace Q3TextStringChar {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}
 
namespace Rose {
    std::string stringify_qrsQ3TextStringCharType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextStringCharType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 366
namespace stringify { namespace qrs { namespace Q3TextCursor {
    const char* Operation(int64_t);
 
    std::string Operation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Operation();
}}}
 
namespace Rose {
    std::string stringify_qrsQ3TextCursorOperation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextCursorOperation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 390
namespace stringify { namespace qrs { namespace Q3TextCommand {
    const char* Commands(int64_t);
 
    std::string Commands(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Commands();
}}}
 
namespace Rose {
    std::string stringify_qrsQ3TextCommandCommands(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextCommandCommands();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 451
namespace stringify { namespace qrs { namespace Q3TextCustomItem {
    const char* Placement(int64_t);
 
    std::string Placement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Placement();
}}}
 
namespace Rose {
    std::string stringify_qrsQ3TextCustomItemPlacement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextCustomItemPlacement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 724
namespace stringify { namespace qrs { namespace Q3TextDocument {
    const char* SelectionIds(int64_t);
 
    std::string SelectionIds(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& SelectionIds();
}}}
 
namespace Rose {
    std::string stringify_qrsQ3TextDocumentSelectionIds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextDocumentSelectionIds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1380
namespace stringify { namespace qrs { namespace Q3TextPreProcessor {
    const char* Ids(int64_t);
 
    std::string Ids(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Ids();
}}}
 
namespace Rose {
    std::string stringify_qrsQ3TextPreProcessorIds(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextPreProcessorIds();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1400
namespace stringify { namespace qrs { namespace Q3TextFormat {
    const char* Flags(int64_t);
 
    std::string Flags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Flags();
}}}
 
namespace Rose {
    std::string stringify_qrsQ3TextFormatFlags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextFormatFlags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1415
namespace stringify { namespace qrs { namespace Q3TextFormat {
    const char* VerticalAlignment(int64_t);
 
    std::string VerticalAlignment(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& VerticalAlignment();
}}}
 
namespace Rose {
    std::string stringify_qrsQ3TextFormatVerticalAlignment(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQ3TextFormatVerticalAlignment();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/qsourcecolorizer.h line 257
namespace stringify { namespace qrs { namespace QSourceColorizer {
    const char* Type(int64_t);
 
    std::string Type(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Type();
}}}
 
namespace Rose {
    std::string stringify_qrsQSourceColorizerType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQSourceColorizerType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/qeditor.h line 65
namespace stringify { namespace qrs { namespace QEditor {
    const char* TypeSel(int64_t);
 
    std::string TypeSel(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& TypeSel();
}}}
 
namespace Rose {
    std::string stringify_qrsQEditorTypeSel(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQEditorTypeSel();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/QRSourceBox.h line 39
namespace stringify { namespace qrs { namespace QRSourceBox {
    const char* ToolbarIdx(int64_t);
 
    std::string ToolbarIdx(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ToolbarIdx();
}}}
 
namespace Rose {
    std::string stringify_qrsQRSourceBoxToolbarIdx(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringify_qrsQRSourceBoxToolbarIdx();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/MSTL/DOTGeneration.h line 48
namespace stringify { namespace DOTGeneration {
    const char* traversalType(int64_t);
 
    std::string traversalType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& traversalType();
}}
 
namespace Rose {
    std::string stringifyDOTGeneration_traversalType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyDOTGeneration_traversalType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 3
namespace stringify {
    const char* E_SgSourceFile(int64_t);
 
    std::string E_SgSourceFile(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSourceFile();
}
 
namespace Rose {
    std::string stringifyE_SgSourceFile(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSourceFile();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 6
namespace stringify {
    const char* E_SgUnknownFile(int64_t);
 
    std::string E_SgUnknownFile(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnknownFile();
}
 
namespace Rose {
    std::string stringifyE_SgUnknownFile(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnknownFile();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 9
namespace stringify {
    const char* E_SgJvmComposite(int64_t);
 
    std::string E_SgJvmComposite(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJvmComposite();
}
 
namespace Rose {
    std::string stringifyE_SgJvmComposite(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJvmComposite();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 12
namespace stringify {
    const char* E_SgBinaryComposite(int64_t);
 
    std::string E_SgBinaryComposite(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBinaryComposite();
}
 
namespace Rose {
    std::string stringifyE_SgBinaryComposite(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBinaryComposite();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 15
namespace stringify {
    const char* E_SgProject(int64_t);
 
    std::string E_SgProject(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgProject();
}
 
namespace Rose {
    std::string stringifyE_SgProject(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgProject();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 18
namespace stringify {
    const char* E_SgExpBaseClass(int64_t);
 
    std::string E_SgExpBaseClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExpBaseClass();
}
 
namespace Rose {
    std::string stringifyE_SgExpBaseClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExpBaseClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 21
namespace stringify {
    const char* E_SgNonrealBaseClass(int64_t);
 
    std::string E_SgNonrealBaseClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNonrealBaseClass();
}
 
namespace Rose {
    std::string stringifyE_SgNonrealBaseClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNonrealBaseClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 24
namespace stringify {
    const char* E_SgBaseClass(int64_t);
 
    std::string E_SgBaseClass(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBaseClass();
}
 
namespace Rose {
    std::string stringifyE_SgBaseClass(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBaseClass();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 27
namespace stringify {
    const char* E_SgTemplateParameter(int64_t);
 
    std::string E_SgTemplateParameter(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateParameter();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateParameter(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateParameter();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 30
namespace stringify {
    const char* E_SgTemplateArgument(int64_t);
 
    std::string E_SgTemplateArgument(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateArgument();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateArgument(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateArgument();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 33
namespace stringify {
    const char* E_SgDirectory(int64_t);
 
    std::string E_SgDirectory(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDirectory();
}
 
namespace Rose {
    std::string stringifyE_SgDirectory(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDirectory();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 36
namespace stringify {
    const char* E_SgFileList(int64_t);
 
    std::string E_SgFileList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFileList();
}
 
namespace Rose {
    std::string stringifyE_SgFileList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFileList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 39
namespace stringify {
    const char* E_SgDirectoryList(int64_t);
 
    std::string E_SgDirectoryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDirectoryList();
}
 
namespace Rose {
    std::string stringifyE_SgDirectoryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDirectoryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 42
namespace stringify {
    const char* E_SgTemplateArgumentList(int64_t);
 
    std::string E_SgTemplateArgumentList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateArgumentList();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateArgumentList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateArgumentList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 45
namespace stringify {
    const char* E_SgTemplateParameterList(int64_t);
 
    std::string E_SgTemplateParameterList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateParameterList();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateParameterList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateParameterList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 48
namespace stringify {
    const char* E_SgIncludeFile(int64_t);
 
    std::string E_SgIncludeFile(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIncludeFile();
}
 
namespace Rose {
    std::string stringifyE_SgIncludeFile(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIncludeFile();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 51
namespace stringify {
    const char* E_SgJavaImportStatementList(int64_t);
 
    std::string E_SgJavaImportStatementList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaImportStatementList();
}
 
namespace Rose {
    std::string stringifyE_SgJavaImportStatementList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaImportStatementList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 54
namespace stringify {
    const char* E_SgJavaClassDeclarationList(int64_t);
 
    std::string E_SgJavaClassDeclarationList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaClassDeclarationList();
}
 
namespace Rose {
    std::string stringifyE_SgJavaClassDeclarationList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaClassDeclarationList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 57
namespace stringify {
    const char* E_SgTypeUnknown(int64_t);
 
    std::string E_SgTypeUnknown(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnknown();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnknown(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnknown();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 60
namespace stringify {
    const char* E_SgTypeChar(int64_t);
 
    std::string E_SgTypeChar(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeChar();
}
 
namespace Rose {
    std::string stringifyE_SgTypeChar(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeChar();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 63
namespace stringify {
    const char* E_SgTypeSignedChar(int64_t);
 
    std::string E_SgTypeSignedChar(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedChar();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedChar(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedChar();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 66
namespace stringify {
    const char* E_SgTypeUnsignedChar(int64_t);
 
    std::string E_SgTypeUnsignedChar(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedChar();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedChar(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedChar();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 69
namespace stringify {
    const char* E_SgTypeShort(int64_t);
 
    std::string E_SgTypeShort(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeShort();
}
 
namespace Rose {
    std::string stringifyE_SgTypeShort(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeShort();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 72
namespace stringify {
    const char* E_SgTypeSignedShort(int64_t);
 
    std::string E_SgTypeSignedShort(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedShort();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedShort(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedShort();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 75
namespace stringify {
    const char* E_SgTypeUnsignedShort(int64_t);
 
    std::string E_SgTypeUnsignedShort(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedShort();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedShort(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedShort();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 78
namespace stringify {
    const char* E_SgTypeInt(int64_t);
 
    std::string E_SgTypeInt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeInt();
}
 
namespace Rose {
    std::string stringifyE_SgTypeInt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeInt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 81
namespace stringify {
    const char* E_SgTypeSignedInt(int64_t);
 
    std::string E_SgTypeSignedInt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedInt();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedInt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedInt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 84
namespace stringify {
    const char* E_SgTypeUnsignedInt(int64_t);
 
    std::string E_SgTypeUnsignedInt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedInt();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedInt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedInt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 87
namespace stringify {
    const char* E_SgTypeLong(int64_t);
 
    std::string E_SgTypeLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 90
namespace stringify {
    const char* E_SgTypeSignedLong(int64_t);
 
    std::string E_SgTypeSignedLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 93
namespace stringify {
    const char* E_SgTypeUnsignedLong(int64_t);
 
    std::string E_SgTypeUnsignedLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 96
namespace stringify {
    const char* E_SgTypeVoid(int64_t);
 
    std::string E_SgTypeVoid(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeVoid();
}
 
namespace Rose {
    std::string stringifyE_SgTypeVoid(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeVoid();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 99
namespace stringify {
    const char* E_SgTypeGlobalVoid(int64_t);
 
    std::string E_SgTypeGlobalVoid(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeGlobalVoid();
}
 
namespace Rose {
    std::string stringifyE_SgTypeGlobalVoid(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeGlobalVoid();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 102
namespace stringify {
    const char* E_SgTypeWchar(int64_t);
 
    std::string E_SgTypeWchar(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeWchar();
}
 
namespace Rose {
    std::string stringifyE_SgTypeWchar(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeWchar();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 105
namespace stringify {
    const char* E_SgTypeFloat(int64_t);
 
    std::string E_SgTypeFloat(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeFloat();
}
 
namespace Rose {
    std::string stringifyE_SgTypeFloat(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeFloat();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 108
namespace stringify {
    const char* E_SgTypeDouble(int64_t);
 
    std::string E_SgTypeDouble(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeDouble();
}
 
namespace Rose {
    std::string stringifyE_SgTypeDouble(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeDouble();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 111
namespace stringify {
    const char* E_SgTypeLongLong(int64_t);
 
    std::string E_SgTypeLongLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeLongLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeLongLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeLongLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 114
namespace stringify {
    const char* E_SgTypeSignedLongLong(int64_t);
 
    std::string E_SgTypeSignedLongLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSignedLongLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSignedLongLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSignedLongLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 117
namespace stringify {
    const char* E_SgTypeUnsignedLongLong(int64_t);
 
    std::string E_SgTypeUnsignedLongLong(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsignedLongLong();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsignedLongLong(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsignedLongLong();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 120
namespace stringify {
    const char* E_SgTypeSigned128bitInteger(int64_t);
 
    std::string E_SgTypeSigned128bitInteger(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeSigned128bitInteger();
}
 
namespace Rose {
    std::string stringifyE_SgTypeSigned128bitInteger(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeSigned128bitInteger();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 123
namespace stringify {
    const char* E_SgTypeUnsigned128bitInteger(int64_t);
 
    std::string E_SgTypeUnsigned128bitInteger(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeUnsigned128bitInteger();
}
 
namespace Rose {
    std::string stringifyE_SgTypeUnsigned128bitInteger(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeUnsigned128bitInteger();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 126
namespace stringify {
    const char* E_SgTypeFloat80(int64_t);
 
    std::string E_SgTypeFloat80(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeFloat80();
}
 
namespace Rose {
    std::string stringifyE_SgTypeFloat80(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeFloat80();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 129
namespace stringify {
    const char* E_SgTypeLongDouble(int64_t);
 
    std::string E_SgTypeLongDouble(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeLongDouble();
}
 
namespace Rose {
    std::string stringifyE_SgTypeLongDouble(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeLongDouble();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 132
namespace stringify {
    const char* E_SgTypeString(int64_t);
 
    std::string E_SgTypeString(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeString();
}
 
namespace Rose {
    std::string stringifyE_SgTypeString(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeString();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 135
namespace stringify {
    const char* E_SgTypeBool(int64_t);
 
    std::string E_SgTypeBool(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeBool();
}
 
namespace Rose {
    std::string stringifyE_SgTypeBool(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeBool();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 138
namespace stringify {
    const char* E_SgPointerMemberType(int64_t);
 
    std::string E_SgPointerMemberType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPointerMemberType();
}
 
namespace Rose {
    std::string stringifyE_SgPointerMemberType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPointerMemberType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 141
namespace stringify {
    const char* E_SgPointerType(int64_t);
 
    std::string E_SgPointerType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPointerType();
}
 
namespace Rose {
    std::string stringifyE_SgPointerType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPointerType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 144
namespace stringify {
    const char* E_SgReferenceType(int64_t);
 
    std::string E_SgReferenceType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgReferenceType();
}
 
namespace Rose {
    std::string stringifyE_SgReferenceType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgReferenceType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 147
namespace stringify {
    const char* E_SgJavaParameterType(int64_t);
 
    std::string E_SgJavaParameterType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaParameterType();
}
 
namespace Rose {
    std::string stringifyE_SgJavaParameterType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaParameterType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 150
namespace stringify {
    const char* E_SgJovialTableType(int64_t);
 
    std::string E_SgJovialTableType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJovialTableType();
}
 
namespace Rose {
    std::string stringifyE_SgJovialTableType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJovialTableType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 153
namespace stringify {
    const char* E_SgClassType(int64_t);
 
    std::string E_SgClassType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgClassType();
}
 
namespace Rose {
    std::string stringifyE_SgClassType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgClassType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 156
namespace stringify {
    const char* E_SgEnumType(int64_t);
 
    std::string E_SgEnumType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEnumType();
}
 
namespace Rose {
    std::string stringifyE_SgEnumType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEnumType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 159
namespace stringify {
    const char* E_SgTypedefType(int64_t);
 
    std::string E_SgTypedefType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypedefType();
}
 
namespace Rose {
    std::string stringifyE_SgTypedefType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypedefType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 162
namespace stringify {
    const char* E_SgNonrealType(int64_t);
 
    std::string E_SgNonrealType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNonrealType();
}
 
namespace Rose {
    std::string stringifyE_SgNonrealType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNonrealType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 165
namespace stringify {
    const char* E_SgJavaParameterizedType(int64_t);
 
    std::string E_SgJavaParameterizedType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaParameterizedType();
}
 
namespace Rose {
    std::string stringifyE_SgJavaParameterizedType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaParameterizedType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 168
namespace stringify {
    const char* E_SgJavaQualifiedType(int64_t);
 
    std::string E_SgJavaQualifiedType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaQualifiedType();
}
 
namespace Rose {
    std::string stringifyE_SgJavaQualifiedType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaQualifiedType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 171
namespace stringify {
    const char* E_SgJavaWildcardType(int64_t);
 
    std::string E_SgJavaWildcardType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaWildcardType();
}
 
namespace Rose {
    std::string stringifyE_SgJavaWildcardType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaWildcardType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 174
namespace stringify {
    const char* E_SgAdaTaskType(int64_t);
 
    std::string E_SgAdaTaskType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaTaskType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaTaskType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaTaskType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 177
namespace stringify {
    const char* E_SgAdaProtectedType(int64_t);
 
    std::string E_SgAdaProtectedType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaProtectedType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaProtectedType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaProtectedType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 180
namespace stringify {
    const char* E_SgAdaFormalType(int64_t);
 
    std::string E_SgAdaFormalType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaFormalType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaFormalType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaFormalType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 183
namespace stringify {
    const char* E_SgAdaDiscriminatedType(int64_t);
 
    std::string E_SgAdaDiscriminatedType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaDiscriminatedType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaDiscriminatedType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaDiscriminatedType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 186
namespace stringify {
    const char* E_SgNamedType(int64_t);
 
    std::string E_SgNamedType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNamedType();
}
 
namespace Rose {
    std::string stringifyE_SgNamedType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNamedType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 189
namespace stringify {
    const char* E_SgModifierType(int64_t);
 
    std::string E_SgModifierType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModifierType();
}
 
namespace Rose {
    std::string stringifyE_SgModifierType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModifierType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 192
namespace stringify {
    const char* E_SgPartialFunctionModifierType(int64_t);
 
    std::string E_SgPartialFunctionModifierType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPartialFunctionModifierType();
}
 
namespace Rose {
    std::string stringifyE_SgPartialFunctionModifierType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPartialFunctionModifierType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 195
namespace stringify {
    const char* E_SgPartialFunctionType(int64_t);
 
    std::string E_SgPartialFunctionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPartialFunctionType();
}
 
namespace Rose {
    std::string stringifyE_SgPartialFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPartialFunctionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 198
namespace stringify {
    const char* E_SgMemberFunctionType(int64_t);
 
    std::string E_SgMemberFunctionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMemberFunctionType();
}
 
namespace Rose {
    std::string stringifyE_SgMemberFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMemberFunctionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 201
namespace stringify {
    const char* E_SgFunctionType(int64_t);
 
    std::string E_SgFunctionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionType();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 204
namespace stringify {
    const char* E_SgArrayType(int64_t);
 
    std::string E_SgArrayType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgArrayType();
}
 
namespace Rose {
    std::string stringifyE_SgArrayType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgArrayType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 207
namespace stringify {
    const char* E_SgTypeEllipse(int64_t);
 
    std::string E_SgTypeEllipse(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeEllipse();
}
 
namespace Rose {
    std::string stringifyE_SgTypeEllipse(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeEllipse();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 210
namespace stringify {
    const char* E_SgTemplateType(int64_t);
 
    std::string E_SgTemplateType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateType();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 213
namespace stringify {
    const char* E_SgQualifiedNameType(int64_t);
 
    std::string E_SgQualifiedNameType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgQualifiedNameType();
}
 
namespace Rose {
    std::string stringifyE_SgQualifiedNameType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgQualifiedNameType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 216
namespace stringify {
    const char* E_SgTypeComplex(int64_t);
 
    std::string E_SgTypeComplex(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeComplex();
}
 
namespace Rose {
    std::string stringifyE_SgTypeComplex(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeComplex();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 219
namespace stringify {
    const char* E_SgTypeImaginary(int64_t);
 
    std::string E_SgTypeImaginary(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeImaginary();
}
 
namespace Rose {
    std::string stringifyE_SgTypeImaginary(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeImaginary();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 222
namespace stringify {
    const char* E_SgTypeDefault(int64_t);
 
    std::string E_SgTypeDefault(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeDefault();
}
 
namespace Rose {
    std::string stringifyE_SgTypeDefault(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeDefault();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 225
namespace stringify {
    const char* E_SgTypeCAFTeam(int64_t);
 
    std::string E_SgTypeCAFTeam(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeCAFTeam();
}
 
namespace Rose {
    std::string stringifyE_SgTypeCAFTeam(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeCAFTeam();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 228
namespace stringify {
    const char* E_SgTypeCrayPointer(int64_t);
 
    std::string E_SgTypeCrayPointer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeCrayPointer();
}
 
namespace Rose {
    std::string stringifyE_SgTypeCrayPointer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeCrayPointer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 231
namespace stringify {
    const char* E_SgTypeLabel(int64_t);
 
    std::string E_SgTypeLabel(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeLabel();
}
 
namespace Rose {
    std::string stringifyE_SgTypeLabel(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeLabel();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 234
namespace stringify {
    const char* E_SgJavaUnionType(int64_t);
 
    std::string E_SgJavaUnionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaUnionType();
}
 
namespace Rose {
    std::string stringifyE_SgJavaUnionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaUnionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 237
namespace stringify {
    const char* E_SgRvalueReferenceType(int64_t);
 
    std::string E_SgRvalueReferenceType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRvalueReferenceType();
}
 
namespace Rose {
    std::string stringifyE_SgRvalueReferenceType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRvalueReferenceType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 240
namespace stringify {
    const char* E_SgTypeNullptr(int64_t);
 
    std::string E_SgTypeNullptr(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeNullptr();
}
 
namespace Rose {
    std::string stringifyE_SgTypeNullptr(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeNullptr();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 243
namespace stringify {
    const char* E_SgDeclType(int64_t);
 
    std::string E_SgDeclType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDeclType();
}
 
namespace Rose {
    std::string stringifyE_SgDeclType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDeclType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 246
namespace stringify {
    const char* E_SgTypeOfType(int64_t);
 
    std::string E_SgTypeOfType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeOfType();
}
 
namespace Rose {
    std::string stringifyE_SgTypeOfType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeOfType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 249
namespace stringify {
    const char* E_SgTypeMatrix(int64_t);
 
    std::string E_SgTypeMatrix(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeMatrix();
}
 
namespace Rose {
    std::string stringifyE_SgTypeMatrix(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeMatrix();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 252
namespace stringify {
    const char* E_SgTypeTuple(int64_t);
 
    std::string E_SgTypeTuple(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeTuple();
}
 
namespace Rose {
    std::string stringifyE_SgTypeTuple(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeTuple();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 255
namespace stringify {
    const char* E_SgTypeChar16(int64_t);
 
    std::string E_SgTypeChar16(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeChar16();
}
 
namespace Rose {
    std::string stringifyE_SgTypeChar16(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeChar16();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 258
namespace stringify {
    const char* E_SgTypeChar32(int64_t);
 
    std::string E_SgTypeChar32(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeChar32();
}
 
namespace Rose {
    std::string stringifyE_SgTypeChar32(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeChar32();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 261
namespace stringify {
    const char* E_SgTypeFloat128(int64_t);
 
    std::string E_SgTypeFloat128(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeFloat128();
}
 
namespace Rose {
    std::string stringifyE_SgTypeFloat128(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeFloat128();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 264
namespace stringify {
    const char* E_SgTypeFixed(int64_t);
 
    std::string E_SgTypeFixed(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeFixed();
}
 
namespace Rose {
    std::string stringifyE_SgTypeFixed(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeFixed();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 267
namespace stringify {
    const char* E_SgAutoType(int64_t);
 
    std::string E_SgAutoType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAutoType();
}
 
namespace Rose {
    std::string stringifyE_SgAutoType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAutoType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 270
namespace stringify {
    const char* E_SgAdaAccessType(int64_t);
 
    std::string E_SgAdaAccessType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaAccessType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaAccessType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaAccessType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 273
namespace stringify {
    const char* E_SgAdaSubtype(int64_t);
 
    std::string E_SgAdaSubtype(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaSubtype();
}
 
namespace Rose {
    std::string stringifyE_SgAdaSubtype(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaSubtype();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 276
namespace stringify {
    const char* E_SgAdaDiscreteType(int64_t);
 
    std::string E_SgAdaDiscreteType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaDiscreteType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaDiscreteType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaDiscreteType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 279
namespace stringify {
    const char* E_SgAdaModularType(int64_t);
 
    std::string E_SgAdaModularType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaModularType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaModularType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaModularType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 282
namespace stringify {
    const char* E_SgAdaDerivedType(int64_t);
 
    std::string E_SgAdaDerivedType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaDerivedType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaDerivedType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaDerivedType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 285
namespace stringify {
    const char* E_SgAdaSubroutineType(int64_t);
 
    std::string E_SgAdaSubroutineType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaSubroutineType();
}
 
namespace Rose {
    std::string stringifyE_SgAdaSubroutineType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaSubroutineType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 288
namespace stringify {
    const char* E_SgJovialBitType(int64_t);
 
    std::string E_SgJovialBitType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJovialBitType();
}
 
namespace Rose {
    std::string stringifyE_SgJovialBitType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJovialBitType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 291
namespace stringify {
    const char* E_SgRangeType(int64_t);
 
    std::string E_SgRangeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRangeType();
}
 
namespace Rose {
    std::string stringifyE_SgRangeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRangeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 294
namespace stringify {
    const char* E_SgType(int64_t);
 
    std::string E_SgType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgType();
}
 
namespace Rose {
    std::string stringifyE_SgType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 297
namespace stringify {
    const char* E_SgCommonBlockObject(int64_t);
 
    std::string E_SgCommonBlockObject(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCommonBlockObject();
}
 
namespace Rose {
    std::string stringifyE_SgCommonBlockObject(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCommonBlockObject();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 300
namespace stringify {
    const char* E_SgInitializedName(int64_t);
 
    std::string E_SgInitializedName(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgInitializedName();
}
 
namespace Rose {
    std::string stringifyE_SgInitializedName(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgInitializedName();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 303
namespace stringify {
    const char* E_SgJavaMemberValuePair(int64_t);
 
    std::string E_SgJavaMemberValuePair(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaMemberValuePair();
}
 
namespace Rose {
    std::string stringifyE_SgJavaMemberValuePair(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaMemberValuePair();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 306
namespace stringify {
    const char* E_SgOmpOrderedClause(int64_t);
 
    std::string E_SgOmpOrderedClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpOrderedClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpOrderedClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpOrderedClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 309
namespace stringify {
    const char* E_SgOmpCollapseClause(int64_t);
 
    std::string E_SgOmpCollapseClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpCollapseClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpCollapseClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpCollapseClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 312
namespace stringify {
    const char* E_SgOmpIfClause(int64_t);
 
    std::string E_SgOmpIfClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpIfClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpIfClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpIfClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 315
namespace stringify {
    const char* E_SgOmpNumThreadsClause(int64_t);
 
    std::string E_SgOmpNumThreadsClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpNumThreadsClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpNumThreadsClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpNumThreadsClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 318
namespace stringify {
    const char* E_SgOmpDeviceClause(int64_t);
 
    std::string E_SgOmpDeviceClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDeviceClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDeviceClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDeviceClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 321
namespace stringify {
    const char* E_SgOmpSafelenClause(int64_t);
 
    std::string E_SgOmpSafelenClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSafelenClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSafelenClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSafelenClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 324
namespace stringify {
    const char* E_SgOmpSimdlenClause(int64_t);
 
    std::string E_SgOmpSimdlenClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSimdlenClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSimdlenClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSimdlenClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 327
namespace stringify {
    const char* E_SgOmpFinalClause(int64_t);
 
    std::string E_SgOmpFinalClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpFinalClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpFinalClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpFinalClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 330
namespace stringify {
    const char* E_SgOmpPriorityClause(int64_t);
 
    std::string E_SgOmpPriorityClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpPriorityClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpPriorityClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpPriorityClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 333
namespace stringify {
    const char* E_SgOmpExpressionClause(int64_t);
 
    std::string E_SgOmpExpressionClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpExpressionClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpExpressionClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpExpressionClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 336
namespace stringify {
    const char* E_SgOmpCopyprivateClause(int64_t);
 
    std::string E_SgOmpCopyprivateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpCopyprivateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpCopyprivateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpCopyprivateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 339
namespace stringify {
    const char* E_SgOmpPrivateClause(int64_t);
 
    std::string E_SgOmpPrivateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpPrivateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpPrivateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpPrivateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 342
namespace stringify {
    const char* E_SgOmpFirstprivateClause(int64_t);
 
    std::string E_SgOmpFirstprivateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpFirstprivateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpFirstprivateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpFirstprivateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 345
namespace stringify {
    const char* E_SgOmpSharedClause(int64_t);
 
    std::string E_SgOmpSharedClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSharedClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSharedClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSharedClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 348
namespace stringify {
    const char* E_SgOmpCopyinClause(int64_t);
 
    std::string E_SgOmpCopyinClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpCopyinClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpCopyinClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpCopyinClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 351
namespace stringify {
    const char* E_SgOmpLastprivateClause(int64_t);
 
    std::string E_SgOmpLastprivateClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpLastprivateClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpLastprivateClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpLastprivateClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 354
namespace stringify {
    const char* E_SgOmpReductionClause(int64_t);
 
    std::string E_SgOmpReductionClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpReductionClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpReductionClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpReductionClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 357
namespace stringify {
    const char* E_SgOmpMapClause(int64_t);
 
    std::string E_SgOmpMapClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpMapClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpMapClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpMapClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 360
namespace stringify {
    const char* E_SgOmpUniformClause(int64_t);
 
    std::string E_SgOmpUniformClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpUniformClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpUniformClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpUniformClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 363
namespace stringify {
    const char* E_SgOmpAlignedClause(int64_t);
 
    std::string E_SgOmpAlignedClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpAlignedClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpAlignedClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpAlignedClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 366
namespace stringify {
    const char* E_SgOmpLinearClause(int64_t);
 
    std::string E_SgOmpLinearClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpLinearClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpLinearClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpLinearClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 369
namespace stringify {
    const char* E_SgOmpDependClause(int64_t);
 
    std::string E_SgOmpDependClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDependClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDependClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDependClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 372
namespace stringify {
    const char* E_SgOmpVariablesClause(int64_t);
 
    std::string E_SgOmpVariablesClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpVariablesClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpVariablesClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpVariablesClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 375
namespace stringify {
    const char* E_SgOmpScheduleClause(int64_t);
 
    std::string E_SgOmpScheduleClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpScheduleClause();
}
 
namespace Rose {
    std::string stringifyE_SgOmpScheduleClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpScheduleClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 378
namespace stringify {
    const char* E_SgLambdaCapture(int64_t);
 
    std::string E_SgLambdaCapture(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLambdaCapture();
}
 
namespace Rose {
    std::string stringifyE_SgLambdaCapture(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLambdaCapture();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 381
namespace stringify {
    const char* E_SgLambdaCaptureList(int64_t);
 
    std::string E_SgLambdaCaptureList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLambdaCaptureList();
}
 
namespace Rose {
    std::string stringifyE_SgLambdaCaptureList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLambdaCaptureList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 384
namespace stringify {
    const char* E_SgAdaRangeConstraint(int64_t);
 
    std::string E_SgAdaRangeConstraint(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaRangeConstraint();
}
 
namespace Rose {
    std::string stringifyE_SgAdaRangeConstraint(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaRangeConstraint();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 387
namespace stringify {
    const char* E_SgAdaIndexConstraint(int64_t);
 
    std::string E_SgAdaIndexConstraint(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaIndexConstraint();
}
 
namespace Rose {
    std::string stringifyE_SgAdaIndexConstraint(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaIndexConstraint();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 390
namespace stringify {
    const char* E_SgAdaDigitsConstraint(int64_t);
 
    std::string E_SgAdaDigitsConstraint(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaDigitsConstraint();
}
 
namespace Rose {
    std::string stringifyE_SgAdaDigitsConstraint(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaDigitsConstraint();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 393
namespace stringify {
    const char* E_SgAdaDeltaConstraint(int64_t);
 
    std::string E_SgAdaDeltaConstraint(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaDeltaConstraint();
}
 
namespace Rose {
    std::string stringifyE_SgAdaDeltaConstraint(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaDeltaConstraint();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 396
namespace stringify {
    const char* E_SgAdaDiscriminantConstraint(int64_t);
 
    std::string E_SgAdaDiscriminantConstraint(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaDiscriminantConstraint();
}
 
namespace Rose {
    std::string stringifyE_SgAdaDiscriminantConstraint(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaDiscriminantConstraint();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 399
namespace stringify {
    const char* E_SgGlobal(int64_t);
 
    std::string E_SgGlobal(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgGlobal();
}
 
namespace Rose {
    std::string stringifyE_SgGlobal(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgGlobal();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 402
namespace stringify {
    const char* E_SgBasicBlock(int64_t);
 
    std::string E_SgBasicBlock(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBasicBlock();
}
 
namespace Rose {
    std::string stringifyE_SgBasicBlock(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBasicBlock();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 405
namespace stringify {
    const char* E_SgIfStmt(int64_t);
 
    std::string E_SgIfStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIfStmt();
}
 
namespace Rose {
    std::string stringifyE_SgIfStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIfStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 408
namespace stringify {
    const char* E_SgForStatement(int64_t);
 
    std::string E_SgForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 411
namespace stringify {
    const char* E_SgTemplateFunctionDefinition(int64_t);
 
    std::string E_SgTemplateFunctionDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateFunctionDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateFunctionDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateFunctionDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 414
namespace stringify {
    const char* E_SgFunctionDefinition(int64_t);
 
    std::string E_SgFunctionDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 417
namespace stringify {
    const char* E_SgTemplateInstantiationDefn(int64_t);
 
    std::string E_SgTemplateInstantiationDefn(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationDefn();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationDefn(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationDefn();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 420
namespace stringify {
    const char* E_SgTemplateClassDefinition(int64_t);
 
    std::string E_SgTemplateClassDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateClassDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateClassDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateClassDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 423
namespace stringify {
    const char* E_SgClassDefinition(int64_t);
 
    std::string E_SgClassDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgClassDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgClassDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgClassDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 426
namespace stringify {
    const char* E_SgWhileStmt(int64_t);
 
    std::string E_SgWhileStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWhileStmt();
}
 
namespace Rose {
    std::string stringifyE_SgWhileStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWhileStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 429
namespace stringify {
    const char* E_SgDoWhileStmt(int64_t);
 
    std::string E_SgDoWhileStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDoWhileStmt();
}
 
namespace Rose {
    std::string stringifyE_SgDoWhileStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDoWhileStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 432
namespace stringify {
    const char* E_SgSwitchStatement(int64_t);
 
    std::string E_SgSwitchStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSwitchStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSwitchStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSwitchStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 435
namespace stringify {
    const char* E_SgCatchOptionStmt(int64_t);
 
    std::string E_SgCatchOptionStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCatchOptionStmt();
}
 
namespace Rose {
    std::string stringifyE_SgCatchOptionStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCatchOptionStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 438
namespace stringify {
    const char* E_SgNamespaceDefinitionStatement(int64_t);
 
    std::string E_SgNamespaceDefinitionStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNamespaceDefinitionStatement();
}
 
namespace Rose {
    std::string stringifyE_SgNamespaceDefinitionStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNamespaceDefinitionStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 441
namespace stringify {
    const char* E_SgAssociateStatement(int64_t);
 
    std::string E_SgAssociateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssociateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgAssociateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssociateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 444
namespace stringify {
    const char* E_SgFortranNonblockedDo(int64_t);
 
    std::string E_SgFortranNonblockedDo(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFortranNonblockedDo();
}
 
namespace Rose {
    std::string stringifyE_SgFortranNonblockedDo(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFortranNonblockedDo();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 447
namespace stringify {
    const char* E_SgFortranDo(int64_t);
 
    std::string E_SgFortranDo(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFortranDo();
}
 
namespace Rose {
    std::string stringifyE_SgFortranDo(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFortranDo();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 450
namespace stringify {
    const char* E_SgForAllStatement(int64_t);
 
    std::string E_SgForAllStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgForAllStatement();
}
 
namespace Rose {
    std::string stringifyE_SgForAllStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgForAllStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 453
namespace stringify {
    const char* E_SgUpcForAllStatement(int64_t);
 
    std::string E_SgUpcForAllStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcForAllStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpcForAllStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcForAllStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 456
namespace stringify {
    const char* E_SgCAFWithTeamStatement(int64_t);
 
    std::string E_SgCAFWithTeamStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCAFWithTeamStatement();
}
 
namespace Rose {
    std::string stringifyE_SgCAFWithTeamStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCAFWithTeamStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 459
namespace stringify {
    const char* E_SgJavaForEachStatement(int64_t);
 
    std::string E_SgJavaForEachStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaForEachStatement();
}
 
namespace Rose {
    std::string stringifyE_SgJavaForEachStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaForEachStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 462
namespace stringify {
    const char* E_SgJavaLabelStatement(int64_t);
 
    std::string E_SgJavaLabelStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaLabelStatement();
}
 
namespace Rose {
    std::string stringifyE_SgJavaLabelStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaLabelStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 465
namespace stringify {
    const char* E_SgMatlabForStatement(int64_t);
 
    std::string E_SgMatlabForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMatlabForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgMatlabForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMatlabForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 468
namespace stringify {
    const char* E_SgFunctionParameterScope(int64_t);
 
    std::string E_SgFunctionParameterScope(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionParameterScope();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionParameterScope(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionParameterScope();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 471
namespace stringify {
    const char* E_SgRangeBasedForStatement(int64_t);
 
    std::string E_SgRangeBasedForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRangeBasedForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgRangeBasedForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRangeBasedForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 474
namespace stringify {
    const char* E_SgJovialForThenStatement(int64_t);
 
    std::string E_SgJovialForThenStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJovialForThenStatement();
}
 
namespace Rose {
    std::string stringifyE_SgJovialForThenStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJovialForThenStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 477
namespace stringify {
    const char* E_SgAdaAcceptStmt(int64_t);
 
    std::string E_SgAdaAcceptStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaAcceptStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAdaAcceptStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaAcceptStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 480
namespace stringify {
    const char* E_SgAdaPackageSpec(int64_t);
 
    std::string E_SgAdaPackageSpec(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaPackageSpec();
}
 
namespace Rose {
    std::string stringifyE_SgAdaPackageSpec(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaPackageSpec();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 483
namespace stringify {
    const char* E_SgAdaPackageBody(int64_t);
 
    std::string E_SgAdaPackageBody(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaPackageBody();
}
 
namespace Rose {
    std::string stringifyE_SgAdaPackageBody(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaPackageBody();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 486
namespace stringify {
    const char* E_SgAdaTaskSpec(int64_t);
 
    std::string E_SgAdaTaskSpec(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaTaskSpec();
}
 
namespace Rose {
    std::string stringifyE_SgAdaTaskSpec(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaTaskSpec();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 489
namespace stringify {
    const char* E_SgAdaTaskBody(int64_t);
 
    std::string E_SgAdaTaskBody(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaTaskBody();
}
 
namespace Rose {
    std::string stringifyE_SgAdaTaskBody(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaTaskBody();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 492
namespace stringify {
    const char* E_SgAdaProtectedBody(int64_t);
 
    std::string E_SgAdaProtectedBody(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaProtectedBody();
}
 
namespace Rose {
    std::string stringifyE_SgAdaProtectedBody(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaProtectedBody();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 495
namespace stringify {
    const char* E_SgAdaProtectedSpec(int64_t);
 
    std::string E_SgAdaProtectedSpec(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaProtectedSpec();
}
 
namespace Rose {
    std::string stringifyE_SgAdaProtectedSpec(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaProtectedSpec();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 498
namespace stringify {
    const char* E_SgAdaGenericDefn(int64_t);
 
    std::string E_SgAdaGenericDefn(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaGenericDefn();
}
 
namespace Rose {
    std::string stringifyE_SgAdaGenericDefn(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaGenericDefn();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 501
namespace stringify {
    const char* E_SgFunctionParameterList(int64_t);
 
    std::string E_SgFunctionParameterList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionParameterList();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionParameterList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionParameterList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 504
namespace stringify {
    const char* E_SgTemplateVariableDeclaration(int64_t);
 
    std::string E_SgTemplateVariableDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateVariableDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateVariableDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateVariableDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 507
namespace stringify {
    const char* E_SgVariableDeclaration(int64_t);
 
    std::string E_SgVariableDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVariableDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgVariableDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVariableDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 510
namespace stringify {
    const char* E_SgVariableDefinition(int64_t);
 
    std::string E_SgVariableDefinition(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVariableDefinition();
}
 
namespace Rose {
    std::string stringifyE_SgVariableDefinition(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVariableDefinition();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 513
namespace stringify {
    const char* E_SgEnumDeclaration(int64_t);
 
    std::string E_SgEnumDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEnumDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgEnumDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEnumDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 516
namespace stringify {
    const char* E_SgAsmStmt(int64_t);
 
    std::string E_SgAsmStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAsmStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 519
namespace stringify {
    const char* E_SgTemplateInstantiationDirectiveStatement(int64_t);
 
    std::string E_SgTemplateInstantiationDirectiveStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationDirectiveStatement();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationDirectiveStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationDirectiveStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 522
namespace stringify {
    const char* E_SgUseStatement(int64_t);
 
    std::string E_SgUseStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUseStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUseStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUseStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 525
namespace stringify {
    const char* E_SgNamespaceDeclarationStatement(int64_t);
 
    std::string E_SgNamespaceDeclarationStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNamespaceDeclarationStatement();
}
 
namespace Rose {
    std::string stringifyE_SgNamespaceDeclarationStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNamespaceDeclarationStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 528
namespace stringify {
    const char* E_SgInterfaceStatement(int64_t);
 
    std::string E_SgInterfaceStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgInterfaceStatement();
}
 
namespace Rose {
    std::string stringifyE_SgInterfaceStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgInterfaceStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 531
namespace stringify {
    const char* E_SgCommonBlock(int64_t);
 
    std::string E_SgCommonBlock(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCommonBlock();
}
 
namespace Rose {
    std::string stringifyE_SgCommonBlock(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCommonBlock();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 534
namespace stringify {
    const char* E_SgTemplateTypedefDeclaration(int64_t);
 
    std::string E_SgTemplateTypedefDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateTypedefDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateTypedefDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateTypedefDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 537
namespace stringify {
    const char* E_SgTemplateInstantiationTypedefDeclaration(int64_t);
 
    std::string E_SgTemplateInstantiationTypedefDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationTypedefDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationTypedefDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationTypedefDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 540
namespace stringify {
    const char* E_SgTypedefDeclaration(int64_t);
 
    std::string E_SgTypedefDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypedefDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTypedefDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypedefDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 543
namespace stringify {
    const char* E_SgStatementFunctionStatement(int64_t);
 
    std::string E_SgStatementFunctionStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStatementFunctionStatement();
}
 
namespace Rose {
    std::string stringifyE_SgStatementFunctionStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStatementFunctionStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 546
namespace stringify {
    const char* E_SgCtorInitializerList(int64_t);
 
    std::string E_SgCtorInitializerList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCtorInitializerList();
}
 
namespace Rose {
    std::string stringifyE_SgCtorInitializerList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCtorInitializerList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 549
namespace stringify {
    const char* E_SgPragmaDeclaration(int64_t);
 
    std::string E_SgPragmaDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPragmaDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgPragmaDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPragmaDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 552
namespace stringify {
    const char* E_SgTemplateClassDeclaration(int64_t);
 
    std::string E_SgTemplateClassDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateClassDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateClassDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateClassDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 555
namespace stringify {
    const char* E_SgTemplateInstantiationDecl(int64_t);
 
    std::string E_SgTemplateInstantiationDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationDecl();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 558
namespace stringify {
    const char* E_SgDerivedTypeStatement(int64_t);
 
    std::string E_SgDerivedTypeStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDerivedTypeStatement();
}
 
namespace Rose {
    std::string stringifyE_SgDerivedTypeStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDerivedTypeStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 561
namespace stringify {
    const char* E_SgModuleStatement(int64_t);
 
    std::string E_SgModuleStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModuleStatement();
}
 
namespace Rose {
    std::string stringifyE_SgModuleStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModuleStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 564
namespace stringify {
    const char* E_SgJavaPackageDeclaration(int64_t);
 
    std::string E_SgJavaPackageDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaPackageDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgJavaPackageDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaPackageDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 567
namespace stringify {
    const char* E_SgJovialTableStatement(int64_t);
 
    std::string E_SgJovialTableStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJovialTableStatement();
}
 
namespace Rose {
    std::string stringifyE_SgJovialTableStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJovialTableStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 570
namespace stringify {
    const char* E_SgClassDeclaration(int64_t);
 
    std::string E_SgClassDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgClassDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgClassDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgClassDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 573
namespace stringify {
    const char* E_SgImplicitStatement(int64_t);
 
    std::string E_SgImplicitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgImplicitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgImplicitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgImplicitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 576
namespace stringify {
    const char* E_SgTemplateFunctionDeclaration(int64_t);
 
    std::string E_SgTemplateFunctionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateFunctionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateFunctionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateFunctionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 579
namespace stringify {
    const char* E_SgTemplateMemberFunctionDeclaration(int64_t);
 
    std::string E_SgTemplateMemberFunctionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateMemberFunctionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateMemberFunctionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateMemberFunctionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 582
namespace stringify {
    const char* E_SgTemplateInstantiationMemberFunctionDecl(int64_t);
 
    std::string E_SgTemplateInstantiationMemberFunctionDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationMemberFunctionDecl();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationMemberFunctionDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationMemberFunctionDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 585
namespace stringify {
    const char* E_SgMemberFunctionDeclaration(int64_t);
 
    std::string E_SgMemberFunctionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMemberFunctionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgMemberFunctionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMemberFunctionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 588
namespace stringify {
    const char* E_SgTemplateInstantiationFunctionDecl(int64_t);
 
    std::string E_SgTemplateInstantiationFunctionDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateInstantiationFunctionDecl();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateInstantiationFunctionDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateInstantiationFunctionDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 591
namespace stringify {
    const char* E_SgProgramHeaderStatement(int64_t);
 
    std::string E_SgProgramHeaderStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgProgramHeaderStatement();
}
 
namespace Rose {
    std::string stringifyE_SgProgramHeaderStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgProgramHeaderStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 594
namespace stringify {
    const char* E_SgProcedureHeaderStatement(int64_t);
 
    std::string E_SgProcedureHeaderStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgProcedureHeaderStatement();
}
 
namespace Rose {
    std::string stringifyE_SgProcedureHeaderStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgProcedureHeaderStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 597
namespace stringify {
    const char* E_SgEntryStatement(int64_t);
 
    std::string E_SgEntryStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEntryStatement();
}
 
namespace Rose {
    std::string stringifyE_SgEntryStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEntryStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 600
namespace stringify {
    const char* E_SgAdaEntryDecl(int64_t);
 
    std::string E_SgAdaEntryDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaEntryDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaEntryDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaEntryDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 603
namespace stringify {
    const char* E_SgAdaFunctionRenamingDecl(int64_t);
 
    std::string E_SgAdaFunctionRenamingDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaFunctionRenamingDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaFunctionRenamingDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaFunctionRenamingDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 606
namespace stringify {
    const char* E_SgFunctionDeclaration(int64_t);
 
    std::string E_SgFunctionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 609
namespace stringify {
    const char* E_SgIncludeDirectiveStatement(int64_t);
 
    std::string E_SgIncludeDirectiveStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIncludeDirectiveStatement();
}
 
namespace Rose {
    std::string stringifyE_SgIncludeDirectiveStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIncludeDirectiveStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 612
namespace stringify {
    const char* E_SgOmpThreadprivateStatement(int64_t);
 
    std::string E_SgOmpThreadprivateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpThreadprivateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpThreadprivateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpThreadprivateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 615
namespace stringify {
    const char* E_SgStmtDeclarationStatement(int64_t);
 
    std::string E_SgStmtDeclarationStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStmtDeclarationStatement();
}
 
namespace Rose {
    std::string stringifyE_SgStmtDeclarationStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStmtDeclarationStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 618
namespace stringify {
    const char* E_SgStaticAssertionDeclaration(int64_t);
 
    std::string E_SgStaticAssertionDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStaticAssertionDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgStaticAssertionDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStaticAssertionDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 621
namespace stringify {
    const char* E_SgOmpDeclareSimdStatement(int64_t);
 
    std::string E_SgOmpDeclareSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDeclareSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDeclareSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDeclareSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 624
namespace stringify {
    const char* E_SgJovialOverlayDeclaration(int64_t);
 
    std::string E_SgJovialOverlayDeclaration(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJovialOverlayDeclaration();
}
 
namespace Rose {
    std::string stringifyE_SgJovialOverlayDeclaration(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJovialOverlayDeclaration();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 627
namespace stringify {
    const char* E_SgAdaPackageBodyDecl(int64_t);
 
    std::string E_SgAdaPackageBodyDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaPackageBodyDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaPackageBodyDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaPackageBodyDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 630
namespace stringify {
    const char* E_SgAdaPackageSpecDecl(int64_t);
 
    std::string E_SgAdaPackageSpecDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaPackageSpecDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaPackageSpecDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaPackageSpecDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 633
namespace stringify {
    const char* E_SgAdaRenamingDecl(int64_t);
 
    std::string E_SgAdaRenamingDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaRenamingDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaRenamingDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaRenamingDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 636
namespace stringify {
    const char* E_SgAdaTaskSpecDecl(int64_t);
 
    std::string E_SgAdaTaskSpecDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaTaskSpecDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaTaskSpecDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaTaskSpecDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 639
namespace stringify {
    const char* E_SgAdaTaskBodyDecl(int64_t);
 
    std::string E_SgAdaTaskBodyDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaTaskBodyDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaTaskBodyDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaTaskBodyDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 642
namespace stringify {
    const char* E_SgAdaTaskTypeDecl(int64_t);
 
    std::string E_SgAdaTaskTypeDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaTaskTypeDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaTaskTypeDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaTaskTypeDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 645
namespace stringify {
    const char* E_SgAdaProtectedSpecDecl(int64_t);
 
    std::string E_SgAdaProtectedSpecDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaProtectedSpecDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaProtectedSpecDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaProtectedSpecDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 648
namespace stringify {
    const char* E_SgAdaProtectedBodyDecl(int64_t);
 
    std::string E_SgAdaProtectedBodyDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaProtectedBodyDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaProtectedBodyDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaProtectedBodyDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 651
namespace stringify {
    const char* E_SgAdaProtectedTypeDecl(int64_t);
 
    std::string E_SgAdaProtectedTypeDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaProtectedTypeDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaProtectedTypeDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaProtectedTypeDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 654
namespace stringify {
    const char* E_SgAdaRepresentationClause(int64_t);
 
    std::string E_SgAdaRepresentationClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaRepresentationClause();
}
 
namespace Rose {
    std::string stringifyE_SgAdaRepresentationClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaRepresentationClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 657
namespace stringify {
    const char* E_SgAdaComponentClause(int64_t);
 
    std::string E_SgAdaComponentClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaComponentClause();
}
 
namespace Rose {
    std::string stringifyE_SgAdaComponentClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaComponentClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 660
namespace stringify {
    const char* E_SgAdaAttributeClause(int64_t);
 
    std::string E_SgAdaAttributeClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaAttributeClause();
}
 
namespace Rose {
    std::string stringifyE_SgAdaAttributeClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaAttributeClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 663
namespace stringify {
    const char* E_SgAdaEnumRepresentationClause(int64_t);
 
    std::string E_SgAdaEnumRepresentationClause(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaEnumRepresentationClause();
}
 
namespace Rose {
    std::string stringifyE_SgAdaEnumRepresentationClause(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaEnumRepresentationClause();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 666
namespace stringify {
    const char* E_SgAdaGenericDecl(int64_t);
 
    std::string E_SgAdaGenericDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaGenericDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaGenericDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaGenericDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 669
namespace stringify {
    const char* E_SgAdaFormalTypeDecl(int64_t);
 
    std::string E_SgAdaFormalTypeDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaFormalTypeDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaFormalTypeDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaFormalTypeDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 672
namespace stringify {
    const char* E_SgAdaDiscriminatedTypeDecl(int64_t);
 
    std::string E_SgAdaDiscriminatedTypeDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaDiscriminatedTypeDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaDiscriminatedTypeDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaDiscriminatedTypeDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 675
namespace stringify {
    const char* E_SgAdaGenericInstanceDecl(int64_t);
 
    std::string E_SgAdaGenericInstanceDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaGenericInstanceDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaGenericInstanceDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaGenericInstanceDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 678
namespace stringify {
    const char* E_SgAdaParameterList(int64_t);
 
    std::string E_SgAdaParameterList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaParameterList();
}
 
namespace Rose {
    std::string stringifyE_SgAdaParameterList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaParameterList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 681
namespace stringify {
    const char* E_SgAdaVariantDecl(int64_t);
 
    std::string E_SgAdaVariantDecl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaVariantDecl();
}
 
namespace Rose {
    std::string stringifyE_SgAdaVariantDecl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaVariantDecl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 684
namespace stringify {
    const char* E_SgExprStatement(int64_t);
 
    std::string E_SgExprStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExprStatement();
}
 
namespace Rose {
    std::string stringifyE_SgExprStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExprStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 687
namespace stringify {
    const char* E_SgLabelStatement(int64_t);
 
    std::string E_SgLabelStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLabelStatement();
}
 
namespace Rose {
    std::string stringifyE_SgLabelStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLabelStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 690
namespace stringify {
    const char* E_SgCaseOptionStmt(int64_t);
 
    std::string E_SgCaseOptionStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCaseOptionStmt();
}
 
namespace Rose {
    std::string stringifyE_SgCaseOptionStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCaseOptionStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 693
namespace stringify {
    const char* E_SgTryStmt(int64_t);
 
    std::string E_SgTryStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTryStmt();
}
 
namespace Rose {
    std::string stringifyE_SgTryStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTryStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 696
namespace stringify {
    const char* E_SgDefaultOptionStmt(int64_t);
 
    std::string E_SgDefaultOptionStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDefaultOptionStmt();
}
 
namespace Rose {
    std::string stringifyE_SgDefaultOptionStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDefaultOptionStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 699
namespace stringify {
    const char* E_SgReturnStmt(int64_t);
 
    std::string E_SgReturnStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgReturnStmt();
}
 
namespace Rose {
    std::string stringifyE_SgReturnStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgReturnStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 702
namespace stringify {
    const char* E_SgSpawnStmt(int64_t);
 
    std::string E_SgSpawnStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSpawnStmt();
}
 
namespace Rose {
    std::string stringifyE_SgSpawnStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSpawnStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 705
namespace stringify {
    const char* E_SgForInitStatement(int64_t);
 
    std::string E_SgForInitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgForInitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgForInitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgForInitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 708
namespace stringify {
    const char* E_SgCatchStatementSeq(int64_t);
 
    std::string E_SgCatchStatementSeq(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCatchStatementSeq();
}
 
namespace Rose {
    std::string stringifyE_SgCatchStatementSeq(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCatchStatementSeq();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 711
namespace stringify {
    const char* E_SgProcessControlStatement(int64_t);
 
    std::string E_SgProcessControlStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgProcessControlStatement();
}
 
namespace Rose {
    std::string stringifyE_SgProcessControlStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgProcessControlStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 714
namespace stringify {
    const char* E_SgPrintStatement(int64_t);
 
    std::string E_SgPrintStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPrintStatement();
}
 
namespace Rose {
    std::string stringifyE_SgPrintStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPrintStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 717
namespace stringify {
    const char* E_SgReadStatement(int64_t);
 
    std::string E_SgReadStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgReadStatement();
}
 
namespace Rose {
    std::string stringifyE_SgReadStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgReadStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 720
namespace stringify {
    const char* E_SgWriteStatement(int64_t);
 
    std::string E_SgWriteStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWriteStatement();
}
 
namespace Rose {
    std::string stringifyE_SgWriteStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWriteStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 723
namespace stringify {
    const char* E_SgOpenStatement(int64_t);
 
    std::string E_SgOpenStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOpenStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOpenStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOpenStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 726
namespace stringify {
    const char* E_SgCloseStatement(int64_t);
 
    std::string E_SgCloseStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCloseStatement();
}
 
namespace Rose {
    std::string stringifyE_SgCloseStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCloseStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 729
namespace stringify {
    const char* E_SgInquireStatement(int64_t);
 
    std::string E_SgInquireStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgInquireStatement();
}
 
namespace Rose {
    std::string stringifyE_SgInquireStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgInquireStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 732
namespace stringify {
    const char* E_SgFlushStatement(int64_t);
 
    std::string E_SgFlushStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFlushStatement();
}
 
namespace Rose {
    std::string stringifyE_SgFlushStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFlushStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 735
namespace stringify {
    const char* E_SgBackspaceStatement(int64_t);
 
    std::string E_SgBackspaceStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBackspaceStatement();
}
 
namespace Rose {
    std::string stringifyE_SgBackspaceStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBackspaceStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 738
namespace stringify {
    const char* E_SgRewindStatement(int64_t);
 
    std::string E_SgRewindStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRewindStatement();
}
 
namespace Rose {
    std::string stringifyE_SgRewindStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRewindStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 741
namespace stringify {
    const char* E_SgEndfileStatement(int64_t);
 
    std::string E_SgEndfileStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEndfileStatement();
}
 
namespace Rose {
    std::string stringifyE_SgEndfileStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEndfileStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 744
namespace stringify {
    const char* E_SgWaitStatement(int64_t);
 
    std::string E_SgWaitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWaitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgWaitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWaitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 747
namespace stringify {
    const char* E_SgIOStatement(int64_t);
 
    std::string E_SgIOStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIOStatement();
}
 
namespace Rose {
    std::string stringifyE_SgIOStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIOStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 750
namespace stringify {
    const char* E_SgWhereStatement(int64_t);
 
    std::string E_SgWhereStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWhereStatement();
}
 
namespace Rose {
    std::string stringifyE_SgWhereStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWhereStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 753
namespace stringify {
    const char* E_SgElseWhereStatement(int64_t);
 
    std::string E_SgElseWhereStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElseWhereStatement();
}
 
namespace Rose {
    std::string stringifyE_SgElseWhereStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElseWhereStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 756
namespace stringify {
    const char* E_SgNullifyStatement(int64_t);
 
    std::string E_SgNullifyStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNullifyStatement();
}
 
namespace Rose {
    std::string stringifyE_SgNullifyStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNullifyStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 759
namespace stringify {
    const char* E_SgArithmeticIfStatement(int64_t);
 
    std::string E_SgArithmeticIfStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgArithmeticIfStatement();
}
 
namespace Rose {
    std::string stringifyE_SgArithmeticIfStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgArithmeticIfStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 762
namespace stringify {
    const char* E_SgAssignStatement(int64_t);
 
    std::string E_SgAssignStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssignStatement();
}
 
namespace Rose {
    std::string stringifyE_SgAssignStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssignStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 765
namespace stringify {
    const char* E_SgComputedGotoStatement(int64_t);
 
    std::string E_SgComputedGotoStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgComputedGotoStatement();
}
 
namespace Rose {
    std::string stringifyE_SgComputedGotoStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgComputedGotoStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 768
namespace stringify {
    const char* E_SgAssignedGotoStatement(int64_t);
 
    std::string E_SgAssignedGotoStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssignedGotoStatement();
}
 
namespace Rose {
    std::string stringifyE_SgAssignedGotoStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssignedGotoStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 771
namespace stringify {
    const char* E_SgAllocateStatement(int64_t);
 
    std::string E_SgAllocateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAllocateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgAllocateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAllocateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 774
namespace stringify {
    const char* E_SgDeallocateStatement(int64_t);
 
    std::string E_SgDeallocateStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDeallocateStatement();
}
 
namespace Rose {
    std::string stringifyE_SgDeallocateStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDeallocateStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 777
namespace stringify {
    const char* E_SgUpcNotifyStatement(int64_t);
 
    std::string E_SgUpcNotifyStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcNotifyStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpcNotifyStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcNotifyStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 780
namespace stringify {
    const char* E_SgUpcWaitStatement(int64_t);
 
    std::string E_SgUpcWaitStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcWaitStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpcWaitStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcWaitStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 783
namespace stringify {
    const char* E_SgUpcBarrierStatement(int64_t);
 
    std::string E_SgUpcBarrierStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcBarrierStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUpcBarrierStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcBarrierStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 786
namespace stringify {
    const char* E_SgOmpFlushStatement(int64_t);
 
    std::string E_SgOmpFlushStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpFlushStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpFlushStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpFlushStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 789
namespace stringify {
    const char* E_SgOmpMasterStatement(int64_t);
 
    std::string E_SgOmpMasterStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpMasterStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpMasterStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpMasterStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 792
namespace stringify {
    const char* E_SgOmpOrderedStatement(int64_t);
 
    std::string E_SgOmpOrderedStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpOrderedStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpOrderedStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpOrderedStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 795
namespace stringify {
    const char* E_SgOmpCriticalStatement(int64_t);
 
    std::string E_SgOmpCriticalStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpCriticalStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpCriticalStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpCriticalStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 798
namespace stringify {
    const char* E_SgOmpSectionStatement(int64_t);
 
    std::string E_SgOmpSectionStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSectionStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSectionStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSectionStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 801
namespace stringify {
    const char* E_SgOmpWorkshareStatement(int64_t);
 
    std::string E_SgOmpWorkshareStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpWorkshareStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpWorkshareStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpWorkshareStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 804
namespace stringify {
    const char* E_SgOmpParallelStatement(int64_t);
 
    std::string E_SgOmpParallelStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpParallelStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpParallelStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpParallelStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 807
namespace stringify {
    const char* E_SgOmpSingleStatement(int64_t);
 
    std::string E_SgOmpSingleStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSingleStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSingleStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSingleStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 810
namespace stringify {
    const char* E_SgOmpAtomicStatement(int64_t);
 
    std::string E_SgOmpAtomicStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpAtomicStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpAtomicStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpAtomicStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 813
namespace stringify {
    const char* E_SgOmpTaskStatement(int64_t);
 
    std::string E_SgOmpTaskStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTaskStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTaskStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTaskStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 816
namespace stringify {
    const char* E_SgOmpForStatement(int64_t);
 
    std::string E_SgOmpForStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpForStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpForStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpForStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 819
namespace stringify {
    const char* E_SgOmpDoStatement(int64_t);
 
    std::string E_SgOmpDoStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpDoStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpDoStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpDoStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 822
namespace stringify {
    const char* E_SgOmpSectionsStatement(int64_t);
 
    std::string E_SgOmpSectionsStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSectionsStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSectionsStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSectionsStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 825
namespace stringify {
    const char* E_SgOmpTargetStatement(int64_t);
 
    std::string E_SgOmpTargetStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 828
namespace stringify {
    const char* E_SgOmpTargetDataStatement(int64_t);
 
    std::string E_SgOmpTargetDataStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpTargetDataStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpTargetDataStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpTargetDataStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 831
namespace stringify {
    const char* E_SgOmpSimdStatement(int64_t);
 
    std::string E_SgOmpSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 834
namespace stringify {
    const char* E_SgOmpForSimdStatement(int64_t);
 
    std::string E_SgOmpForSimdStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpForSimdStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpForSimdStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpForSimdStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 837
namespace stringify {
    const char* E_SgOmpClauseBodyStatement(int64_t);
 
    std::string E_SgOmpClauseBodyStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpClauseBodyStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpClauseBodyStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpClauseBodyStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 840
namespace stringify {
    const char* E_SgOmpBodyStatement(int64_t);
 
    std::string E_SgOmpBodyStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOmpBodyStatement();
}
 
namespace Rose {
    std::string stringifyE_SgOmpBodyStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOmpBodyStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 843
namespace stringify {
    const char* E_SgWithStatement(int64_t);
 
    std::string E_SgWithStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWithStatement();
}
 
namespace Rose {
    std::string stringifyE_SgWithStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWithStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 846
namespace stringify {
    const char* E_SgPythonPrintStmt(int64_t);
 
    std::string E_SgPythonPrintStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPythonPrintStmt();
}
 
namespace Rose {
    std::string stringifyE_SgPythonPrintStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPythonPrintStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 849
namespace stringify {
    const char* E_SgAssertStmt(int64_t);
 
    std::string E_SgAssertStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssertStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAssertStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssertStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 852
namespace stringify {
    const char* E_SgExecStatement(int64_t);
 
    std::string E_SgExecStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExecStatement();
}
 
namespace Rose {
    std::string stringifyE_SgExecStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExecStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 855
namespace stringify {
    const char* E_SgPythonGlobalStmt(int64_t);
 
    std::string E_SgPythonGlobalStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPythonGlobalStmt();
}
 
namespace Rose {
    std::string stringifyE_SgPythonGlobalStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPythonGlobalStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 858
namespace stringify {
    const char* E_SgJavaSynchronizedStatement(int64_t);
 
    std::string E_SgJavaSynchronizedStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaSynchronizedStatement();
}
 
namespace Rose {
    std::string stringifyE_SgJavaSynchronizedStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaSynchronizedStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 861
namespace stringify {
    const char* E_SgAsyncStmt(int64_t);
 
    std::string E_SgAsyncStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsyncStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAsyncStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsyncStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 864
namespace stringify {
    const char* E_SgFinishStmt(int64_t);
 
    std::string E_SgFinishStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFinishStmt();
}
 
namespace Rose {
    std::string stringifyE_SgFinishStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFinishStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 867
namespace stringify {
    const char* E_SgAtStmt(int64_t);
 
    std::string E_SgAtStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAtStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAtStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAtStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 870
namespace stringify {
    const char* E_SgAtomicStmt(int64_t);
 
    std::string E_SgAtomicStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAtomicStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAtomicStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAtomicStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 873
namespace stringify {
    const char* E_SgWhenStmt(int64_t);
 
    std::string E_SgWhenStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgWhenStmt();
}
 
namespace Rose {
    std::string stringifyE_SgWhenStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgWhenStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 876
namespace stringify {
    const char* E_SgSyncAllStatement(int64_t);
 
    std::string E_SgSyncAllStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSyncAllStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSyncAllStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSyncAllStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 879
namespace stringify {
    const char* E_SgSyncImagesStatement(int64_t);
 
    std::string E_SgSyncImagesStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSyncImagesStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSyncImagesStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSyncImagesStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 882
namespace stringify {
    const char* E_SgSyncMemoryStatement(int64_t);
 
    std::string E_SgSyncMemoryStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSyncMemoryStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSyncMemoryStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSyncMemoryStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 885
namespace stringify {
    const char* E_SgSyncTeamStatement(int64_t);
 
    std::string E_SgSyncTeamStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSyncTeamStatement();
}
 
namespace Rose {
    std::string stringifyE_SgSyncTeamStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSyncTeamStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 888
namespace stringify {
    const char* E_SgLockStatement(int64_t);
 
    std::string E_SgLockStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLockStatement();
}
 
namespace Rose {
    std::string stringifyE_SgLockStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLockStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 891
namespace stringify {
    const char* E_SgUnlockStatement(int64_t);
 
    std::string E_SgUnlockStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnlockStatement();
}
 
namespace Rose {
    std::string stringifyE_SgUnlockStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnlockStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 894
namespace stringify {
    const char* E_SgImageControlStatement(int64_t);
 
    std::string E_SgImageControlStatement(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgImageControlStatement();
}
 
namespace Rose {
    std::string stringifyE_SgImageControlStatement(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgImageControlStatement();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 897
namespace stringify {
    const char* E_SgAdaExitStmt(int64_t);
 
    std::string E_SgAdaExitStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaExitStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAdaExitStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaExitStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 900
namespace stringify {
    const char* E_SgAdaDelayStmt(int64_t);
 
    std::string E_SgAdaDelayStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaDelayStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAdaDelayStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaDelayStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 903
namespace stringify {
    const char* E_SgAdaLoopStmt(int64_t);
 
    std::string E_SgAdaLoopStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaLoopStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAdaLoopStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaLoopStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 906
namespace stringify {
    const char* E_SgAdaSelectStmt(int64_t);
 
    std::string E_SgAdaSelectStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaSelectStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAdaSelectStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaSelectStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 909
namespace stringify {
    const char* E_SgAdaSelectAlternativeStmt(int64_t);
 
    std::string E_SgAdaSelectAlternativeStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaSelectAlternativeStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAdaSelectAlternativeStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaSelectAlternativeStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 912
namespace stringify {
    const char* E_SgAdaUnscopedBlock(int64_t);
 
    std::string E_SgAdaUnscopedBlock(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaUnscopedBlock();
}
 
namespace Rose {
    std::string stringifyE_SgAdaUnscopedBlock(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaUnscopedBlock();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 915
namespace stringify {
    const char* E_SgAdaVariantWhenStmt(int64_t);
 
    std::string E_SgAdaVariantWhenStmt(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaVariantWhenStmt();
}
 
namespace Rose {
    std::string stringifyE_SgAdaVariantWhenStmt(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaVariantWhenStmt();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 918
namespace stringify {
    const char* E_SgExpressionRoot(int64_t);
 
    std::string E_SgExpressionRoot(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExpressionRoot();
}
 
namespace Rose {
    std::string stringifyE_SgExpressionRoot(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExpressionRoot();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 921
namespace stringify {
    const char* E_SgMinusOp(int64_t);
 
    std::string E_SgMinusOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMinusOp();
}
 
namespace Rose {
    std::string stringifyE_SgMinusOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMinusOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 924
namespace stringify {
    const char* E_SgUnaryAddOp(int64_t);
 
    std::string E_SgUnaryAddOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnaryAddOp();
}
 
namespace Rose {
    std::string stringifyE_SgUnaryAddOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnaryAddOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 927
namespace stringify {
    const char* E_SgNotOp(int64_t);
 
    std::string E_SgNotOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNotOp();
}
 
namespace Rose {
    std::string stringifyE_SgNotOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNotOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 930
namespace stringify {
    const char* E_SgPointerDerefExp(int64_t);
 
    std::string E_SgPointerDerefExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPointerDerefExp();
}
 
namespace Rose {
    std::string stringifyE_SgPointerDerefExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPointerDerefExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 933
namespace stringify {
    const char* E_SgAddressOfOp(int64_t);
 
    std::string E_SgAddressOfOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAddressOfOp();
}
 
namespace Rose {
    std::string stringifyE_SgAddressOfOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAddressOfOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 936
namespace stringify {
    const char* E_SgMinusMinusOp(int64_t);
 
    std::string E_SgMinusMinusOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMinusMinusOp();
}
 
namespace Rose {
    std::string stringifyE_SgMinusMinusOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMinusMinusOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 939
namespace stringify {
    const char* E_SgPlusPlusOp(int64_t);
 
    std::string E_SgPlusPlusOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPlusPlusOp();
}
 
namespace Rose {
    std::string stringifyE_SgPlusPlusOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPlusPlusOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 942
namespace stringify {
    const char* E_SgBitComplementOp(int64_t);
 
    std::string E_SgBitComplementOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitComplementOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitComplementOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitComplementOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 945
namespace stringify {
    const char* E_SgCastExp(int64_t);
 
    std::string E_SgCastExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCastExp();
}
 
namespace Rose {
    std::string stringifyE_SgCastExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCastExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 948
namespace stringify {
    const char* E_SgThrowOp(int64_t);
 
    std::string E_SgThrowOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgThrowOp();
}
 
namespace Rose {
    std::string stringifyE_SgThrowOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgThrowOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 951
namespace stringify {
    const char* E_SgRealPartOp(int64_t);
 
    std::string E_SgRealPartOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRealPartOp();
}
 
namespace Rose {
    std::string stringifyE_SgRealPartOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRealPartOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 954
namespace stringify {
    const char* E_SgImagPartOp(int64_t);
 
    std::string E_SgImagPartOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgImagPartOp();
}
 
namespace Rose {
    std::string stringifyE_SgImagPartOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgImagPartOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 957
namespace stringify {
    const char* E_SgConjugateOp(int64_t);
 
    std::string E_SgConjugateOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgConjugateOp();
}
 
namespace Rose {
    std::string stringifyE_SgConjugateOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgConjugateOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 960
namespace stringify {
    const char* E_SgUserDefinedUnaryOp(int64_t);
 
    std::string E_SgUserDefinedUnaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUserDefinedUnaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgUserDefinedUnaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUserDefinedUnaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 963
namespace stringify {
    const char* E_SgMatrixTransposeOp(int64_t);
 
    std::string E_SgMatrixTransposeOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMatrixTransposeOp();
}
 
namespace Rose {
    std::string stringifyE_SgMatrixTransposeOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMatrixTransposeOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 966
namespace stringify {
    const char* E_SgAbsOp(int64_t);
 
    std::string E_SgAbsOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAbsOp();
}
 
namespace Rose {
    std::string stringifyE_SgAbsOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAbsOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 969
namespace stringify {
    const char* E_SgUnaryOp(int64_t);
 
    std::string E_SgUnaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgUnaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 972
namespace stringify {
    const char* E_SgArrowExp(int64_t);
 
    std::string E_SgArrowExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgArrowExp();
}
 
namespace Rose {
    std::string stringifyE_SgArrowExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgArrowExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 975
namespace stringify {
    const char* E_SgDotExp(int64_t);
 
    std::string E_SgDotExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDotExp();
}
 
namespace Rose {
    std::string stringifyE_SgDotExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDotExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 978
namespace stringify {
    const char* E_SgDotStarOp(int64_t);
 
    std::string E_SgDotStarOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDotStarOp();
}
 
namespace Rose {
    std::string stringifyE_SgDotStarOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDotStarOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 981
namespace stringify {
    const char* E_SgArrowStarOp(int64_t);
 
    std::string E_SgArrowStarOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgArrowStarOp();
}
 
namespace Rose {
    std::string stringifyE_SgArrowStarOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgArrowStarOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 984
namespace stringify {
    const char* E_SgEqualityOp(int64_t);
 
    std::string E_SgEqualityOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEqualityOp();
}
 
namespace Rose {
    std::string stringifyE_SgEqualityOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEqualityOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 987
namespace stringify {
    const char* E_SgLessThanOp(int64_t);
 
    std::string E_SgLessThanOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLessThanOp();
}
 
namespace Rose {
    std::string stringifyE_SgLessThanOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLessThanOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 990
namespace stringify {
    const char* E_SgGreaterThanOp(int64_t);
 
    std::string E_SgGreaterThanOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgGreaterThanOp();
}
 
namespace Rose {
    std::string stringifyE_SgGreaterThanOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgGreaterThanOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 993
namespace stringify {
    const char* E_SgNotEqualOp(int64_t);
 
    std::string E_SgNotEqualOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNotEqualOp();
}
 
namespace Rose {
    std::string stringifyE_SgNotEqualOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNotEqualOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 996
namespace stringify {
    const char* E_SgLessOrEqualOp(int64_t);
 
    std::string E_SgLessOrEqualOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLessOrEqualOp();
}
 
namespace Rose {
    std::string stringifyE_SgLessOrEqualOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLessOrEqualOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 999
namespace stringify {
    const char* E_SgGreaterOrEqualOp(int64_t);
 
    std::string E_SgGreaterOrEqualOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgGreaterOrEqualOp();
}
 
namespace Rose {
    std::string stringifyE_SgGreaterOrEqualOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgGreaterOrEqualOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1002
namespace stringify {
    const char* E_SgAddOp(int64_t);
 
    std::string E_SgAddOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAddOp();
}
 
namespace Rose {
    std::string stringifyE_SgAddOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAddOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1005
namespace stringify {
    const char* E_SgSubtractOp(int64_t);
 
    std::string E_SgSubtractOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSubtractOp();
}
 
namespace Rose {
    std::string stringifyE_SgSubtractOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSubtractOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1008
namespace stringify {
    const char* E_SgMultiplyOp(int64_t);
 
    std::string E_SgMultiplyOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMultiplyOp();
}
 
namespace Rose {
    std::string stringifyE_SgMultiplyOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMultiplyOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1011
namespace stringify {
    const char* E_SgDivideOp(int64_t);
 
    std::string E_SgDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1014
namespace stringify {
    const char* E_SgIntegerDivideOp(int64_t);
 
    std::string E_SgIntegerDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIntegerDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgIntegerDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIntegerDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1017
namespace stringify {
    const char* E_SgModOp(int64_t);
 
    std::string E_SgModOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModOp();
}
 
namespace Rose {
    std::string stringifyE_SgModOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1020
namespace stringify {
    const char* E_SgAndOp(int64_t);
 
    std::string E_SgAndOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAndOp();
}
 
namespace Rose {
    std::string stringifyE_SgAndOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAndOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1023
namespace stringify {
    const char* E_SgOrOp(int64_t);
 
    std::string E_SgOrOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgOrOp();
}
 
namespace Rose {
    std::string stringifyE_SgOrOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgOrOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1026
namespace stringify {
    const char* E_SgBitXorOp(int64_t);
 
    std::string E_SgBitXorOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitXorOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitXorOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitXorOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1029
namespace stringify {
    const char* E_SgBitAndOp(int64_t);
 
    std::string E_SgBitAndOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitAndOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitAndOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitAndOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1032
namespace stringify {
    const char* E_SgBitOrOp(int64_t);
 
    std::string E_SgBitOrOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitOrOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitOrOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitOrOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1035
namespace stringify {
    const char* E_SgBitEqvOp(int64_t);
 
    std::string E_SgBitEqvOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBitEqvOp();
}
 
namespace Rose {
    std::string stringifyE_SgBitEqvOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBitEqvOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1038
namespace stringify {
    const char* E_SgCommaOpExp(int64_t);
 
    std::string E_SgCommaOpExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCommaOpExp();
}
 
namespace Rose {
    std::string stringifyE_SgCommaOpExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCommaOpExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1041
namespace stringify {
    const char* E_SgLshiftOp(int64_t);
 
    std::string E_SgLshiftOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLshiftOp();
}
 
namespace Rose {
    std::string stringifyE_SgLshiftOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLshiftOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1044
namespace stringify {
    const char* E_SgRshiftOp(int64_t);
 
    std::string E_SgRshiftOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRshiftOp();
}
 
namespace Rose {
    std::string stringifyE_SgRshiftOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRshiftOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1047
namespace stringify {
    const char* E_SgPntrArrRefExp(int64_t);
 
    std::string E_SgPntrArrRefExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPntrArrRefExp();
}
 
namespace Rose {
    std::string stringifyE_SgPntrArrRefExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPntrArrRefExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1050
namespace stringify {
    const char* E_SgScopeOp(int64_t);
 
    std::string E_SgScopeOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgScopeOp();
}
 
namespace Rose {
    std::string stringifyE_SgScopeOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgScopeOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1053
namespace stringify {
    const char* E_SgAssignOp(int64_t);
 
    std::string E_SgAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1056
namespace stringify {
    const char* E_SgExponentiationOp(int64_t);
 
    std::string E_SgExponentiationOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExponentiationOp();
}
 
namespace Rose {
    std::string stringifyE_SgExponentiationOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExponentiationOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1059
namespace stringify {
    const char* E_SgJavaUnsignedRshiftOp(int64_t);
 
    std::string E_SgJavaUnsignedRshiftOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaUnsignedRshiftOp();
}
 
namespace Rose {
    std::string stringifyE_SgJavaUnsignedRshiftOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaUnsignedRshiftOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1062
namespace stringify {
    const char* E_SgConcatenationOp(int64_t);
 
    std::string E_SgConcatenationOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgConcatenationOp();
}
 
namespace Rose {
    std::string stringifyE_SgConcatenationOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgConcatenationOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1065
namespace stringify {
    const char* E_SgPointerAssignOp(int64_t);
 
    std::string E_SgPointerAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPointerAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgPointerAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPointerAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1068
namespace stringify {
    const char* E_SgUserDefinedBinaryOp(int64_t);
 
    std::string E_SgUserDefinedBinaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUserDefinedBinaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgUserDefinedBinaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUserDefinedBinaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1071
namespace stringify {
    const char* E_SgPlusAssignOp(int64_t);
 
    std::string E_SgPlusAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPlusAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgPlusAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPlusAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1074
namespace stringify {
    const char* E_SgMinusAssignOp(int64_t);
 
    std::string E_SgMinusAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMinusAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgMinusAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMinusAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1077
namespace stringify {
    const char* E_SgAndAssignOp(int64_t);
 
    std::string E_SgAndAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAndAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgAndAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAndAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1080
namespace stringify {
    const char* E_SgIorAssignOp(int64_t);
 
    std::string E_SgIorAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIorAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgIorAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIorAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1083
namespace stringify {
    const char* E_SgMultAssignOp(int64_t);
 
    std::string E_SgMultAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMultAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgMultAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMultAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1086
namespace stringify {
    const char* E_SgDivAssignOp(int64_t);
 
    std::string E_SgDivAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDivAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgDivAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDivAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1089
namespace stringify {
    const char* E_SgModAssignOp(int64_t);
 
    std::string E_SgModAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgModAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1092
namespace stringify {
    const char* E_SgXorAssignOp(int64_t);
 
    std::string E_SgXorAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgXorAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgXorAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgXorAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1095
namespace stringify {
    const char* E_SgLshiftAssignOp(int64_t);
 
    std::string E_SgLshiftAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLshiftAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgLshiftAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLshiftAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1098
namespace stringify {
    const char* E_SgRshiftAssignOp(int64_t);
 
    std::string E_SgRshiftAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRshiftAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgRshiftAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRshiftAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1101
namespace stringify {
    const char* E_SgJavaUnsignedRshiftAssignOp(int64_t);
 
    std::string E_SgJavaUnsignedRshiftAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaUnsignedRshiftAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgJavaUnsignedRshiftAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaUnsignedRshiftAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1104
namespace stringify {
    const char* E_SgIntegerDivideAssignOp(int64_t);
 
    std::string E_SgIntegerDivideAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIntegerDivideAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgIntegerDivideAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIntegerDivideAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1107
namespace stringify {
    const char* E_SgExponentiationAssignOp(int64_t);
 
    std::string E_SgExponentiationAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExponentiationAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgExponentiationAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExponentiationAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1110
namespace stringify {
    const char* E_SgCompoundAssignOp(int64_t);
 
    std::string E_SgCompoundAssignOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCompoundAssignOp();
}
 
namespace Rose {
    std::string stringifyE_SgCompoundAssignOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCompoundAssignOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1113
namespace stringify {
    const char* E_SgMembershipOp(int64_t);
 
    std::string E_SgMembershipOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMembershipOp();
}
 
namespace Rose {
    std::string stringifyE_SgMembershipOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMembershipOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1116
namespace stringify {
    const char* E_SgSpaceshipOp(int64_t);
 
    std::string E_SgSpaceshipOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSpaceshipOp();
}
 
namespace Rose {
    std::string stringifyE_SgSpaceshipOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSpaceshipOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1119
namespace stringify {
    const char* E_SgNonMembershipOp(int64_t);
 
    std::string E_SgNonMembershipOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNonMembershipOp();
}
 
namespace Rose {
    std::string stringifyE_SgNonMembershipOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNonMembershipOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1122
namespace stringify {
    const char* E_SgIsOp(int64_t);
 
    std::string E_SgIsOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIsOp();
}
 
namespace Rose {
    std::string stringifyE_SgIsOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIsOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1125
namespace stringify {
    const char* E_SgIsNotOp(int64_t);
 
    std::string E_SgIsNotOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIsNotOp();
}
 
namespace Rose {
    std::string stringifyE_SgIsNotOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIsNotOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1128
namespace stringify {
    const char* E_SgDotDotExp(int64_t);
 
    std::string E_SgDotDotExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDotDotExp();
}
 
namespace Rose {
    std::string stringifyE_SgDotDotExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDotDotExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1131
namespace stringify {
    const char* E_SgElementwiseMultiplyOp(int64_t);
 
    std::string E_SgElementwiseMultiplyOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseMultiplyOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseMultiplyOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseMultiplyOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1134
namespace stringify {
    const char* E_SgElementwisePowerOp(int64_t);
 
    std::string E_SgElementwisePowerOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwisePowerOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwisePowerOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwisePowerOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1137
namespace stringify {
    const char* E_SgElementwiseLeftDivideOp(int64_t);
 
    std::string E_SgElementwiseLeftDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseLeftDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseLeftDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseLeftDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1140
namespace stringify {
    const char* E_SgElementwiseDivideOp(int64_t);
 
    std::string E_SgElementwiseDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1143
namespace stringify {
    const char* E_SgElementwiseAddOp(int64_t);
 
    std::string E_SgElementwiseAddOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseAddOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseAddOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseAddOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1146
namespace stringify {
    const char* E_SgElementwiseSubtractOp(int64_t);
 
    std::string E_SgElementwiseSubtractOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseSubtractOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseSubtractOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseSubtractOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1149
namespace stringify {
    const char* E_SgElementwiseOp(int64_t);
 
    std::string E_SgElementwiseOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgElementwiseOp();
}
 
namespace Rose {
    std::string stringifyE_SgElementwiseOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgElementwiseOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1152
namespace stringify {
    const char* E_SgPowerOp(int64_t);
 
    std::string E_SgPowerOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgPowerOp();
}
 
namespace Rose {
    std::string stringifyE_SgPowerOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgPowerOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1155
namespace stringify {
    const char* E_SgLeftDivideOp(int64_t);
 
    std::string E_SgLeftDivideOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLeftDivideOp();
}
 
namespace Rose {
    std::string stringifyE_SgLeftDivideOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLeftDivideOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1158
namespace stringify {
    const char* E_SgRemOp(int64_t);
 
    std::string E_SgRemOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRemOp();
}
 
namespace Rose {
    std::string stringifyE_SgRemOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRemOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1161
namespace stringify {
    const char* E_SgReplicationOp(int64_t);
 
    std::string E_SgReplicationOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgReplicationOp();
}
 
namespace Rose {
    std::string stringifyE_SgReplicationOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgReplicationOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1164
namespace stringify {
    const char* E_SgAtOp(int64_t);
 
    std::string E_SgAtOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAtOp();
}
 
namespace Rose {
    std::string stringifyE_SgAtOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAtOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1167
namespace stringify {
    const char* E_SgBinaryOp(int64_t);
 
    std::string E_SgBinaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBinaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgBinaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBinaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1170
namespace stringify {
    const char* E_SgListExp(int64_t);
 
    std::string E_SgListExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgListExp();
}
 
namespace Rose {
    std::string stringifyE_SgListExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgListExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1173
namespace stringify {
    const char* E_SgTupleExp(int64_t);
 
    std::string E_SgTupleExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTupleExp();
}
 
namespace Rose {
    std::string stringifyE_SgTupleExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTupleExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1176
namespace stringify {
    const char* E_SgMatrixExp(int64_t);
 
    std::string E_SgMatrixExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMatrixExp();
}
 
namespace Rose {
    std::string stringifyE_SgMatrixExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMatrixExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1179
namespace stringify {
    const char* E_SgExprListExp(int64_t);
 
    std::string E_SgExprListExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgExprListExp();
}
 
namespace Rose {
    std::string stringifyE_SgExprListExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgExprListExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1182
namespace stringify {
    const char* E_SgComplexVal(int64_t);
 
    std::string E_SgComplexVal(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgComplexVal();
}
 
namespace Rose {
    std::string stringifyE_SgComplexVal(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgComplexVal();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1185
namespace stringify {
    const char* E_SgCudaKernelCallExp(int64_t);
 
    std::string E_SgCudaKernelCallExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCudaKernelCallExp();
}
 
namespace Rose {
    std::string stringifyE_SgCudaKernelCallExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCudaKernelCallExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1188
namespace stringify {
    const char* E_SgFunctionCallExp(int64_t);
 
    std::string E_SgFunctionCallExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionCallExp();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionCallExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionCallExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1191
namespace stringify {
    const char* E_SgCallExpression(int64_t);
 
    std::string E_SgCallExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCallExpression();
}
 
namespace Rose {
    std::string stringifyE_SgCallExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCallExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1194
namespace stringify {
    const char* E_SgSizeOfOp(int64_t);
 
    std::string E_SgSizeOfOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSizeOfOp();
}
 
namespace Rose {
    std::string stringifyE_SgSizeOfOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSizeOfOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1197
namespace stringify {
    const char* E_SgUpcLocalsizeofExpression(int64_t);
 
    std::string E_SgUpcLocalsizeofExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcLocalsizeofExpression();
}
 
namespace Rose {
    std::string stringifyE_SgUpcLocalsizeofExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcLocalsizeofExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1200
namespace stringify {
    const char* E_SgUpcBlocksizeofExpression(int64_t);
 
    std::string E_SgUpcBlocksizeofExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcBlocksizeofExpression();
}
 
namespace Rose {
    std::string stringifyE_SgUpcBlocksizeofExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcBlocksizeofExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1203
namespace stringify {
    const char* E_SgUpcElemsizeofExpression(int64_t);
 
    std::string E_SgUpcElemsizeofExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUpcElemsizeofExpression();
}
 
namespace Rose {
    std::string stringifyE_SgUpcElemsizeofExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUpcElemsizeofExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1206
namespace stringify {
    const char* E_SgJavaInstanceOfOp(int64_t);
 
    std::string E_SgJavaInstanceOfOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaInstanceOfOp();
}
 
namespace Rose {
    std::string stringifyE_SgJavaInstanceOfOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaInstanceOfOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1209
namespace stringify {
    const char* E_SgTypeIdOp(int64_t);
 
    std::string E_SgTypeIdOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypeIdOp();
}
 
namespace Rose {
    std::string stringifyE_SgTypeIdOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypeIdOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1212
namespace stringify {
    const char* E_SgConditionalExp(int64_t);
 
    std::string E_SgConditionalExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgConditionalExp();
}
 
namespace Rose {
    std::string stringifyE_SgConditionalExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgConditionalExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1215
namespace stringify {
    const char* E_SgNewExp(int64_t);
 
    std::string E_SgNewExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNewExp();
}
 
namespace Rose {
    std::string stringifyE_SgNewExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNewExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1218
namespace stringify {
    const char* E_SgDeleteExp(int64_t);
 
    std::string E_SgDeleteExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDeleteExp();
}
 
namespace Rose {
    std::string stringifyE_SgDeleteExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDeleteExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1221
namespace stringify {
    const char* E_SgAggregateInitializer(int64_t);
 
    std::string E_SgAggregateInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAggregateInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgAggregateInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAggregateInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1224
namespace stringify {
    const char* E_SgCompoundInitializer(int64_t);
 
    std::string E_SgCompoundInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCompoundInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgCompoundInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCompoundInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1227
namespace stringify {
    const char* E_SgConstructorInitializer(int64_t);
 
    std::string E_SgConstructorInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgConstructorInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgConstructorInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgConstructorInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1230
namespace stringify {
    const char* E_SgAssignInitializer(int64_t);
 
    std::string E_SgAssignInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAssignInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgAssignInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAssignInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1233
namespace stringify {
    const char* E_SgDesignatedInitializer(int64_t);
 
    std::string E_SgDesignatedInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDesignatedInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgDesignatedInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDesignatedInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1236
namespace stringify {
    const char* E_SgBracedInitializer(int64_t);
 
    std::string E_SgBracedInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgBracedInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgBracedInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgBracedInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1239
namespace stringify {
    const char* E_SgAdaAncestorInitializer(int64_t);
 
    std::string E_SgAdaAncestorInitializer(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaAncestorInitializer();
}
 
namespace Rose {
    std::string stringifyE_SgAdaAncestorInitializer(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaAncestorInitializer();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1242
namespace stringify {
    const char* E_SgVarArgStartOp(int64_t);
 
    std::string E_SgVarArgStartOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgStartOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgStartOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgStartOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1245
namespace stringify {
    const char* E_SgVarArgOp(int64_t);
 
    std::string E_SgVarArgOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1248
namespace stringify {
    const char* E_SgVarArgEndOp(int64_t);
 
    std::string E_SgVarArgEndOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgEndOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgEndOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgEndOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1251
namespace stringify {
    const char* E_SgVarArgCopyOp(int64_t);
 
    std::string E_SgVarArgCopyOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgCopyOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgCopyOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgCopyOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1254
namespace stringify {
    const char* E_SgVarArgStartOneOperandOp(int64_t);
 
    std::string E_SgVarArgStartOneOperandOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgVarArgStartOneOperandOp();
}
 
namespace Rose {
    std::string stringifyE_SgVarArgStartOneOperandOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgVarArgStartOneOperandOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1257
namespace stringify {
    const char* E_SgSubscriptExpression(int64_t);
 
    std::string E_SgSubscriptExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSubscriptExpression();
}
 
namespace Rose {
    std::string stringifyE_SgSubscriptExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSubscriptExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1260
namespace stringify {
    const char* E_SgImpliedDo(int64_t);
 
    std::string E_SgImpliedDo(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgImpliedDo();
}
 
namespace Rose {
    std::string stringifyE_SgImpliedDo(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgImpliedDo();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1263
namespace stringify {
    const char* E_SgIOItemExpression(int64_t);
 
    std::string E_SgIOItemExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgIOItemExpression();
}
 
namespace Rose {
    std::string stringifyE_SgIOItemExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgIOItemExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1266
namespace stringify {
    const char* E_SgStatementExpression(int64_t);
 
    std::string E_SgStatementExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStatementExpression();
}
 
namespace Rose {
    std::string stringifyE_SgStatementExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStatementExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1269
namespace stringify {
    const char* E_SgAsmOp(int64_t);
 
    std::string E_SgAsmOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmOp();
}
 
namespace Rose {
    std::string stringifyE_SgAsmOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1272
namespace stringify {
    const char* E_SgActualArgumentExpression(int64_t);
 
    std::string E_SgActualArgumentExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgActualArgumentExpression();
}
 
namespace Rose {
    std::string stringifyE_SgActualArgumentExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgActualArgumentExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1275
namespace stringify {
    const char* E_SgUnknownArrayOrFunctionReference(int64_t);
 
    std::string E_SgUnknownArrayOrFunctionReference(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgUnknownArrayOrFunctionReference();
}
 
namespace Rose {
    std::string stringifyE_SgUnknownArrayOrFunctionReference(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgUnknownArrayOrFunctionReference();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1278
namespace stringify {
    const char* E_SgCAFCoExpression(int64_t);
 
    std::string E_SgCAFCoExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCAFCoExpression();
}
 
namespace Rose {
    std::string stringifyE_SgCAFCoExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCAFCoExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1281
namespace stringify {
    const char* E_SgCudaKernelExecConfig(int64_t);
 
    std::string E_SgCudaKernelExecConfig(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgCudaKernelExecConfig();
}
 
namespace Rose {
    std::string stringifyE_SgCudaKernelExecConfig(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgCudaKernelExecConfig();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1284
namespace stringify {
    const char* E_SgLambdaRefExp(int64_t);
 
    std::string E_SgLambdaRefExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLambdaRefExp();
}
 
namespace Rose {
    std::string stringifyE_SgLambdaRefExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLambdaRefExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1287
namespace stringify {
    const char* E_SgDictionaryExp(int64_t);
 
    std::string E_SgDictionaryExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDictionaryExp();
}
 
namespace Rose {
    std::string stringifyE_SgDictionaryExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDictionaryExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1290
namespace stringify {
    const char* E_SgKeyDatumPair(int64_t);
 
    std::string E_SgKeyDatumPair(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgKeyDatumPair();
}
 
namespace Rose {
    std::string stringifyE_SgKeyDatumPair(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgKeyDatumPair();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1293
namespace stringify {
    const char* E_SgComprehension(int64_t);
 
    std::string E_SgComprehension(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgComprehension();
}
 
namespace Rose {
    std::string stringifyE_SgComprehension(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgComprehension();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1296
namespace stringify {
    const char* E_SgListComprehension(int64_t);
 
    std::string E_SgListComprehension(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgListComprehension();
}
 
namespace Rose {
    std::string stringifyE_SgListComprehension(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgListComprehension();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1299
namespace stringify {
    const char* E_SgSetComprehension(int64_t);
 
    std::string E_SgSetComprehension(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgSetComprehension();
}
 
namespace Rose {
    std::string stringifyE_SgSetComprehension(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgSetComprehension();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1302
namespace stringify {
    const char* E_SgDictionaryComprehension(int64_t);
 
    std::string E_SgDictionaryComprehension(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgDictionaryComprehension();
}
 
namespace Rose {
    std::string stringifyE_SgDictionaryComprehension(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgDictionaryComprehension();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1305
namespace stringify {
    const char* E_SgNaryBooleanOp(int64_t);
 
    std::string E_SgNaryBooleanOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNaryBooleanOp();
}
 
namespace Rose {
    std::string stringifyE_SgNaryBooleanOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNaryBooleanOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1308
namespace stringify {
    const char* E_SgNaryComparisonOp(int64_t);
 
    std::string E_SgNaryComparisonOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNaryComparisonOp();
}
 
namespace Rose {
    std::string stringifyE_SgNaryComparisonOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNaryComparisonOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1311
namespace stringify {
    const char* E_SgNaryOp(int64_t);
 
    std::string E_SgNaryOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNaryOp();
}
 
namespace Rose {
    std::string stringifyE_SgNaryOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNaryOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1314
namespace stringify {
    const char* E_SgStringConversion(int64_t);
 
    std::string E_SgStringConversion(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgStringConversion();
}
 
namespace Rose {
    std::string stringifyE_SgStringConversion(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgStringConversion();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1317
namespace stringify {
    const char* E_SgYieldExpression(int64_t);
 
    std::string E_SgYieldExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgYieldExpression();
}
 
namespace Rose {
    std::string stringifyE_SgYieldExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgYieldExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1320
namespace stringify {
    const char* E_SgAlignOfOp(int64_t);
 
    std::string E_SgAlignOfOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAlignOfOp();
}
 
namespace Rose {
    std::string stringifyE_SgAlignOfOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAlignOfOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1323
namespace stringify {
    const char* E_SgRangeExp(int64_t);
 
    std::string E_SgRangeExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRangeExp();
}
 
namespace Rose {
    std::string stringifyE_SgRangeExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRangeExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1326
namespace stringify {
    const char* E_SgJavaSingleMemberAnnotation(int64_t);
 
    std::string E_SgJavaSingleMemberAnnotation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaSingleMemberAnnotation();
}
 
namespace Rose {
    std::string stringifyE_SgJavaSingleMemberAnnotation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaSingleMemberAnnotation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1329
namespace stringify {
    const char* E_SgJavaNormalAnnotation(int64_t);
 
    std::string E_SgJavaNormalAnnotation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaNormalAnnotation();
}
 
namespace Rose {
    std::string stringifyE_SgJavaNormalAnnotation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaNormalAnnotation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1332
namespace stringify {
    const char* E_SgFunctionParameterRefExp(int64_t);
 
    std::string E_SgFunctionParameterRefExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionParameterRefExp();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionParameterRefExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionParameterRefExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1335
namespace stringify {
    const char* E_SgLambdaExp(int64_t);
 
    std::string E_SgLambdaExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLambdaExp();
}
 
namespace Rose {
    std::string stringifyE_SgLambdaExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLambdaExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1338
namespace stringify {
    const char* E_SgHereExp(int64_t);
 
    std::string E_SgHereExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgHereExp();
}
 
namespace Rose {
    std::string stringifyE_SgHereExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgHereExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1341
namespace stringify {
    const char* E_SgAtExp(int64_t);
 
    std::string E_SgAtExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAtExp();
}
 
namespace Rose {
    std::string stringifyE_SgAtExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAtExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1344
namespace stringify {
    const char* E_SgFinishExp(int64_t);
 
    std::string E_SgFinishExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFinishExp();
}
 
namespace Rose {
    std::string stringifyE_SgFinishExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFinishExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1347
namespace stringify {
    const char* E_SgNoexceptOp(int64_t);
 
    std::string E_SgNoexceptOp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNoexceptOp();
}
 
namespace Rose {
    std::string stringifyE_SgNoexceptOp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNoexceptOp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1350
namespace stringify {
    const char* E_SgFoldExpression(int64_t);
 
    std::string E_SgFoldExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFoldExpression();
}
 
namespace Rose {
    std::string stringifyE_SgFoldExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFoldExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1353
namespace stringify {
    const char* E_SgAwaitExpression(int64_t);
 
    std::string E_SgAwaitExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAwaitExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAwaitExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAwaitExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1356
namespace stringify {
    const char* E_SgChooseExpression(int64_t);
 
    std::string E_SgChooseExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgChooseExpression();
}
 
namespace Rose {
    std::string stringifyE_SgChooseExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgChooseExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1359
namespace stringify {
    const char* E_SgAdaAttributeExp(int64_t);
 
    std::string E_SgAdaAttributeExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaAttributeExp();
}
 
namespace Rose {
    std::string stringifyE_SgAdaAttributeExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaAttributeExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1362
namespace stringify {
    const char* E_SgJovialTablePresetExp(int64_t);
 
    std::string E_SgJovialTablePresetExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJovialTablePresetExp();
}
 
namespace Rose {
    std::string stringifyE_SgJovialTablePresetExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJovialTablePresetExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1365
namespace stringify {
    const char* E_SgJovialPresetPositionExp(int64_t);
 
    std::string E_SgJovialPresetPositionExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJovialPresetPositionExp();
}
 
namespace Rose {
    std::string stringifyE_SgJovialPresetPositionExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJovialPresetPositionExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1368
namespace stringify {
    const char* E_SgNonrealSymbol(int64_t);
 
    std::string E_SgNonrealSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNonrealSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgNonrealSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNonrealSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1371
namespace stringify {
    const char* E_SgTemplateMemberFunctionSymbol(int64_t);
 
    std::string E_SgTemplateMemberFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateMemberFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateMemberFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateMemberFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1374
namespace stringify {
    const char* E_SgMemberFunctionSymbol(int64_t);
 
    std::string E_SgMemberFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgMemberFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgMemberFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgMemberFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1377
namespace stringify {
    const char* E_SgTemplateFunctionSymbol(int64_t);
 
    std::string E_SgTemplateFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1380
namespace stringify {
    const char* E_SgRenameSymbol(int64_t);
 
    std::string E_SgRenameSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgRenameSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgRenameSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgRenameSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1383
namespace stringify {
    const char* E_SgAdaInheritedFunctionSymbol(int64_t);
 
    std::string E_SgAdaInheritedFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaInheritedFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAdaInheritedFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaInheritedFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1386
namespace stringify {
    const char* E_SgFunctionSymbol(int64_t);
 
    std::string E_SgFunctionSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgFunctionSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgFunctionSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgFunctionSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1389
namespace stringify {
    const char* E_SgTemplateClassSymbol(int64_t);
 
    std::string E_SgTemplateClassSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateClassSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateClassSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateClassSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1392
namespace stringify {
    const char* E_SgClassSymbol(int64_t);
 
    std::string E_SgClassSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgClassSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgClassSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgClassSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1395
namespace stringify {
    const char* E_SgTemplateSymbol(int64_t);
 
    std::string E_SgTemplateSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1398
namespace stringify {
    const char* E_SgEnumSymbol(int64_t);
 
    std::string E_SgEnumSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgEnumSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgEnumSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgEnumSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1401
namespace stringify {
    const char* E_SgTemplateTypedefSymbol(int64_t);
 
    std::string E_SgTemplateTypedefSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTemplateTypedefSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTemplateTypedefSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTemplateTypedefSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1404
namespace stringify {
    const char* E_SgTypedefSymbol(int64_t);
 
    std::string E_SgTypedefSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgTypedefSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgTypedefSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgTypedefSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1407
namespace stringify {
    const char* E_SgLabelSymbol(int64_t);
 
    std::string E_SgLabelSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgLabelSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgLabelSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgLabelSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1410
namespace stringify {
    const char* E_SgNamespaceSymbol(int64_t);
 
    std::string E_SgNamespaceSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgNamespaceSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgNamespaceSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgNamespaceSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1413
namespace stringify {
    const char* E_SgModuleSymbol(int64_t);
 
    std::string E_SgModuleSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgModuleSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgModuleSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgModuleSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1416
namespace stringify {
    const char* E_SgAliasSymbol(int64_t);
 
    std::string E_SgAliasSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAliasSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAliasSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAliasSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1419
namespace stringify {
    const char* E_SgJavaLabelSymbol(int64_t);
 
    std::string E_SgJavaLabelSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgJavaLabelSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgJavaLabelSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgJavaLabelSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1422
namespace stringify {
    const char* E_SgAdaPackageSymbol(int64_t);
 
    std::string E_SgAdaPackageSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaPackageSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAdaPackageSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaPackageSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1425
namespace stringify {
    const char* E_SgAdaTaskSymbol(int64_t);
 
    std::string E_SgAdaTaskSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaTaskSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAdaTaskSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaTaskSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1428
namespace stringify {
    const char* E_SgAdaProtectedSymbol(int64_t);
 
    std::string E_SgAdaProtectedSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaProtectedSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAdaProtectedSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaProtectedSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1431
namespace stringify {
    const char* E_SgAdaRenamingSymbol(int64_t);
 
    std::string E_SgAdaRenamingSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaRenamingSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAdaRenamingSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaRenamingSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1434
namespace stringify {
    const char* E_SgAdaGenericSymbol(int64_t);
 
    std::string E_SgAdaGenericSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaGenericSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAdaGenericSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaGenericSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1437
namespace stringify {
    const char* E_SgAdaGenericInstanceSymbol(int64_t);
 
    std::string E_SgAdaGenericInstanceSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaGenericInstanceSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAdaGenericInstanceSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaGenericInstanceSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1440
namespace stringify {
    const char* E_SgAdaFormalPackageSymbol(int64_t);
 
    std::string E_SgAdaFormalPackageSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAdaFormalPackageSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAdaFormalPackageSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAdaFormalPackageSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1443
namespace stringify {
    const char* E_SgAsmCilMetadataHeap(int64_t);
 
    std::string E_SgAsmCilMetadataHeap(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilMetadataHeap();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilMetadataHeap(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilMetadataHeap();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1446
namespace stringify {
    const char* E_SgAsmCilAssemblyOSTable(int64_t);
 
    std::string E_SgAsmCilAssemblyOSTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilAssemblyOSTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilAssemblyOSTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilAssemblyOSTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1449
namespace stringify {
    const char* E_SgAsmCilAssemblyProcessorTable(int64_t);
 
    std::string E_SgAsmCilAssemblyProcessorTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilAssemblyProcessorTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilAssemblyProcessorTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilAssemblyProcessorTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1452
namespace stringify {
    const char* E_SgAsmCilAssemblyRefOSTable(int64_t);
 
    std::string E_SgAsmCilAssemblyRefOSTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilAssemblyRefOSTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilAssemblyRefOSTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilAssemblyRefOSTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1455
namespace stringify {
    const char* E_SgAsmCilAssemblyRefProcessorTable(int64_t);
 
    std::string E_SgAsmCilAssemblyRefProcessorTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilAssemblyRefProcessorTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilAssemblyRefProcessorTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilAssemblyRefProcessorTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1458
namespace stringify {
    const char* E_SgAsmCilAssemblyRefTable(int64_t);
 
    std::string E_SgAsmCilAssemblyRefTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilAssemblyRefTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilAssemblyRefTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilAssemblyRefTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1461
namespace stringify {
    const char* E_SgAsmCilAssemblyTable(int64_t);
 
    std::string E_SgAsmCilAssemblyTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilAssemblyTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilAssemblyTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilAssemblyTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1464
namespace stringify {
    const char* E_SgAsmCilClassLayoutTable(int64_t);
 
    std::string E_SgAsmCilClassLayoutTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilClassLayoutTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilClassLayoutTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilClassLayoutTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1467
namespace stringify {
    const char* E_SgAsmCilConstantTable(int64_t);
 
    std::string E_SgAsmCilConstantTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilConstantTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilConstantTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilConstantTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1470
namespace stringify {
    const char* E_SgAsmCilCustomAttributeTable(int64_t);
 
    std::string E_SgAsmCilCustomAttributeTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilCustomAttributeTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilCustomAttributeTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilCustomAttributeTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1473
namespace stringify {
    const char* E_SgAsmCilDeclSecurityTable(int64_t);
 
    std::string E_SgAsmCilDeclSecurityTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilDeclSecurityTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilDeclSecurityTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilDeclSecurityTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1476
namespace stringify {
    const char* E_SgAsmCilEventMapTable(int64_t);
 
    std::string E_SgAsmCilEventMapTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilEventMapTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilEventMapTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilEventMapTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1479
namespace stringify {
    const char* E_SgAsmCilEventTable(int64_t);
 
    std::string E_SgAsmCilEventTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilEventTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilEventTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilEventTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1482
namespace stringify {
    const char* E_SgAsmCilExportedTypeTable(int64_t);
 
    std::string E_SgAsmCilExportedTypeTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilExportedTypeTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilExportedTypeTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilExportedTypeTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1485
namespace stringify {
    const char* E_SgAsmCilFieldLayoutTable(int64_t);
 
    std::string E_SgAsmCilFieldLayoutTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilFieldLayoutTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilFieldLayoutTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilFieldLayoutTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1488
namespace stringify {
    const char* E_SgAsmCilFieldMarshalTable(int64_t);
 
    std::string E_SgAsmCilFieldMarshalTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilFieldMarshalTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilFieldMarshalTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilFieldMarshalTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1491
namespace stringify {
    const char* E_SgAsmCilFieldRVATable(int64_t);
 
    std::string E_SgAsmCilFieldRVATable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilFieldRVATable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilFieldRVATable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilFieldRVATable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1494
namespace stringify {
    const char* E_SgAsmCilFieldTable(int64_t);
 
    std::string E_SgAsmCilFieldTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilFieldTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilFieldTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilFieldTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1497
namespace stringify {
    const char* E_SgAsmCilFileTable(int64_t);
 
    std::string E_SgAsmCilFileTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilFileTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilFileTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilFileTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1500
namespace stringify {
    const char* E_SgAsmCilGenericParamConstraintTable(int64_t);
 
    std::string E_SgAsmCilGenericParamConstraintTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilGenericParamConstraintTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilGenericParamConstraintTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilGenericParamConstraintTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1503
namespace stringify {
    const char* E_SgAsmCilGenericParamTable(int64_t);
 
    std::string E_SgAsmCilGenericParamTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilGenericParamTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilGenericParamTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilGenericParamTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1506
namespace stringify {
    const char* E_SgAsmCilImplMapTable(int64_t);
 
    std::string E_SgAsmCilImplMapTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilImplMapTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilImplMapTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilImplMapTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1509
namespace stringify {
    const char* E_SgAsmCilInterfaceImplTable(int64_t);
 
    std::string E_SgAsmCilInterfaceImplTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilInterfaceImplTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilInterfaceImplTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilInterfaceImplTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1512
namespace stringify {
    const char* E_SgAsmCilManifestResourceTable(int64_t);
 
    std::string E_SgAsmCilManifestResourceTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilManifestResourceTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilManifestResourceTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilManifestResourceTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1515
namespace stringify {
    const char* E_SgAsmCilMemberRefTable(int64_t);
 
    std::string E_SgAsmCilMemberRefTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilMemberRefTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilMemberRefTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilMemberRefTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1518
namespace stringify {
    const char* E_SgAsmCilMethodDefTable(int64_t);
 
    std::string E_SgAsmCilMethodDefTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilMethodDefTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilMethodDefTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilMethodDefTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1521
namespace stringify {
    const char* E_SgAsmCilMethodImplTable(int64_t);
 
    std::string E_SgAsmCilMethodImplTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilMethodImplTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilMethodImplTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilMethodImplTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1524
namespace stringify {
    const char* E_SgAsmCilMethodSemanticsTable(int64_t);
 
    std::string E_SgAsmCilMethodSemanticsTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilMethodSemanticsTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilMethodSemanticsTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilMethodSemanticsTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1527
namespace stringify {
    const char* E_SgAsmCilMethodSpecTable(int64_t);
 
    std::string E_SgAsmCilMethodSpecTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilMethodSpecTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilMethodSpecTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilMethodSpecTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1530
namespace stringify {
    const char* E_SgAsmCilModuleRefTable(int64_t);
 
    std::string E_SgAsmCilModuleRefTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilModuleRefTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilModuleRefTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilModuleRefTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1533
namespace stringify {
    const char* E_SgAsmCilModuleTable(int64_t);
 
    std::string E_SgAsmCilModuleTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilModuleTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilModuleTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilModuleTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1536
namespace stringify {
    const char* E_SgAsmCilNestedClassTable(int64_t);
 
    std::string E_SgAsmCilNestedClassTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilNestedClassTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilNestedClassTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilNestedClassTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1539
namespace stringify {
    const char* E_SgAsmCilParamTable(int64_t);
 
    std::string E_SgAsmCilParamTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilParamTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilParamTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilParamTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1542
namespace stringify {
    const char* E_SgAsmCilPropertyMapTable(int64_t);
 
    std::string E_SgAsmCilPropertyMapTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilPropertyMapTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilPropertyMapTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilPropertyMapTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1545
namespace stringify {
    const char* E_SgAsmCilPropertyTable(int64_t);
 
    std::string E_SgAsmCilPropertyTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilPropertyTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilPropertyTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilPropertyTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1548
namespace stringify {
    const char* E_SgAsmCilStandAloneSigTable(int64_t);
 
    std::string E_SgAsmCilStandAloneSigTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilStandAloneSigTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilStandAloneSigTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilStandAloneSigTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1551
namespace stringify {
    const char* E_SgAsmCilTypeDefTable(int64_t);
 
    std::string E_SgAsmCilTypeDefTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilTypeDefTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilTypeDefTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilTypeDefTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1554
namespace stringify {
    const char* E_SgAsmCilTypeRefTable(int64_t);
 
    std::string E_SgAsmCilTypeRefTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilTypeRefTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilTypeRefTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilTypeRefTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1557
namespace stringify {
    const char* E_SgAsmCilTypeSpecTable(int64_t);
 
    std::string E_SgAsmCilTypeSpecTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilTypeSpecTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilTypeSpecTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilTypeSpecTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1560
namespace stringify {
    const char* E_SgAsmCilMetadataRoot(int64_t);
 
    std::string E_SgAsmCilMetadataRoot(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilMetadataRoot();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilMetadataRoot(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilMetadataRoot();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1563
namespace stringify {
    const char* E_SgAsmCoffSymbolList(int64_t);
 
    std::string E_SgAsmCoffSymbolList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCoffSymbolList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCoffSymbolList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCoffSymbolList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1566
namespace stringify {
    const char* E_SgAsmDwarfCompilationUnitList(int64_t);
 
    std::string E_SgAsmDwarfCompilationUnitList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfCompilationUnitList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfCompilationUnitList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfCompilationUnitList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1569
namespace stringify {
    const char* E_SgAsmDwarfArrayType(int64_t);
 
    std::string E_SgAsmDwarfArrayType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfArrayType();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfArrayType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfArrayType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1572
namespace stringify {
    const char* E_SgAsmDwarfClassType(int64_t);
 
    std::string E_SgAsmDwarfClassType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfClassType();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfClassType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfClassType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1575
namespace stringify {
    const char* E_SgAsmDwarfCommonBlock(int64_t);
 
    std::string E_SgAsmDwarfCommonBlock(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfCommonBlock();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfCommonBlock(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfCommonBlock();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1578
namespace stringify {
    const char* E_SgAsmDwarfCompilationUnit(int64_t);
 
    std::string E_SgAsmDwarfCompilationUnit(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfCompilationUnit();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfCompilationUnit(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfCompilationUnit();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1581
namespace stringify {
    const char* E_SgAsmDwarfEnumerationType(int64_t);
 
    std::string E_SgAsmDwarfEnumerationType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfEnumerationType();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfEnumerationType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfEnumerationType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1584
namespace stringify {
    const char* E_SgAsmDwarfInlinedSubroutine(int64_t);
 
    std::string E_SgAsmDwarfInlinedSubroutine(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfInlinedSubroutine();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfInlinedSubroutine(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfInlinedSubroutine();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1587
namespace stringify {
    const char* E_SgAsmDwarfLexicalBlock(int64_t);
 
    std::string E_SgAsmDwarfLexicalBlock(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfLexicalBlock();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfLexicalBlock(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfLexicalBlock();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1590
namespace stringify {
    const char* E_SgAsmDwarfNamespace(int64_t);
 
    std::string E_SgAsmDwarfNamespace(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfNamespace();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfNamespace(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfNamespace();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1593
namespace stringify {
    const char* E_SgAsmDwarfStructureType(int64_t);
 
    std::string E_SgAsmDwarfStructureType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfStructureType();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfStructureType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfStructureType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1596
namespace stringify {
    const char* E_SgAsmDwarfSubprogram(int64_t);
 
    std::string E_SgAsmDwarfSubprogram(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfSubprogram();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfSubprogram(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfSubprogram();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1599
namespace stringify {
    const char* E_SgAsmDwarfSubroutineType(int64_t);
 
    std::string E_SgAsmDwarfSubroutineType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfSubroutineType();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfSubroutineType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfSubroutineType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1602
namespace stringify {
    const char* E_SgAsmDwarfUnionType(int64_t);
 
    std::string E_SgAsmDwarfUnionType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfUnionType();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfUnionType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfUnionType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1605
namespace stringify {
    const char* E_SgAsmDwarfConstructList(int64_t);
 
    std::string E_SgAsmDwarfConstructList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfConstructList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfConstructList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfConstructList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1608
namespace stringify {
    const char* E_SgAsmDwarfLineList(int64_t);
 
    std::string E_SgAsmDwarfLineList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfLineList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfLineList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfLineList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1611
namespace stringify {
    const char* E_SgAsmDwarfMacroList(int64_t);
 
    std::string E_SgAsmDwarfMacroList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDwarfMacroList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDwarfMacroList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDwarfMacroList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1614
namespace stringify {
    const char* E_SgAsmElfDynamicEntry(int64_t);
 
    std::string E_SgAsmElfDynamicEntry(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfDynamicEntry();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfDynamicEntry(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfDynamicEntry();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1617
namespace stringify {
    const char* E_SgAsmElfEHFrameEntryCI(int64_t);
 
    std::string E_SgAsmElfEHFrameEntryCI(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfEHFrameEntryCI();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfEHFrameEntryCI(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfEHFrameEntryCI();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1620
namespace stringify {
    const char* E_SgAsmElfNoteEntry(int64_t);
 
    std::string E_SgAsmElfNoteEntry(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfNoteEntry();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfNoteEntry(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfNoteEntry();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1623
namespace stringify {
    const char* E_SgAsmElfRelocEntryList(int64_t);
 
    std::string E_SgAsmElfRelocEntryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfRelocEntryList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfRelocEntryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfRelocEntryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1626
namespace stringify {
    const char* E_SgAsmElfSegmentTableEntryList(int64_t);
 
    std::string E_SgAsmElfSegmentTableEntryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSegmentTableEntryList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSegmentTableEntryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSegmentTableEntryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1629
namespace stringify {
    const char* E_SgAsmElfSymbolList(int64_t);
 
    std::string E_SgAsmElfSymbolList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymbolList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymbolList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymbolList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1632
namespace stringify {
    const char* E_SgAsmElfSymverDefinedAux(int64_t);
 
    std::string E_SgAsmElfSymverDefinedAux(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverDefinedAux();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverDefinedAux(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverDefinedAux();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1635
namespace stringify {
    const char* E_SgAsmElfSymverDefinedAuxList(int64_t);
 
    std::string E_SgAsmElfSymverDefinedAuxList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverDefinedAuxList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverDefinedAuxList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverDefinedAuxList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1638
namespace stringify {
    const char* E_SgAsmElfSymverDefinedEntry(int64_t);
 
    std::string E_SgAsmElfSymverDefinedEntry(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverDefinedEntry();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverDefinedEntry(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverDefinedEntry();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1641
namespace stringify {
    const char* E_SgAsmElfSymverDefinedEntryList(int64_t);
 
    std::string E_SgAsmElfSymverDefinedEntryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverDefinedEntryList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverDefinedEntryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverDefinedEntryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1644
namespace stringify {
    const char* E_SgAsmElfSymverEntryList(int64_t);
 
    std::string E_SgAsmElfSymverEntryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverEntryList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverEntryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverEntryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1647
namespace stringify {
    const char* E_SgAsmElfSymverNeededAux(int64_t);
 
    std::string E_SgAsmElfSymverNeededAux(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverNeededAux();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverNeededAux(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverNeededAux();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1650
namespace stringify {
    const char* E_SgAsmElfSymverNeededAuxList(int64_t);
 
    std::string E_SgAsmElfSymverNeededAuxList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverNeededAuxList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverNeededAuxList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverNeededAuxList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1653
namespace stringify {
    const char* E_SgAsmElfSymverNeededEntry(int64_t);
 
    std::string E_SgAsmElfSymverNeededEntry(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverNeededEntry();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverNeededEntry(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverNeededEntry();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1656
namespace stringify {
    const char* E_SgAsmElfSymverNeededEntryList(int64_t);
 
    std::string E_SgAsmElfSymverNeededEntryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverNeededEntryList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverNeededEntryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverNeededEntryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1659
namespace stringify {
    const char* E_SgAsmGenericDLL(int64_t);
 
    std::string E_SgAsmGenericDLL(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmGenericDLL();
}
 
namespace Rose {
    std::string stringifyE_SgAsmGenericDLL(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmGenericDLL();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1662
namespace stringify {
    const char* E_SgAsmGenericFile(int64_t);
 
    std::string E_SgAsmGenericFile(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmGenericFile();
}
 
namespace Rose {
    std::string stringifyE_SgAsmGenericFile(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmGenericFile();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1665
namespace stringify {
    const char* E_SgAsmGenericHeaderList(int64_t);
 
    std::string E_SgAsmGenericHeaderList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmGenericHeaderList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmGenericHeaderList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmGenericHeaderList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1668
namespace stringify {
    const char* E_SgAsmCliHeader(int64_t);
 
    std::string E_SgAsmCliHeader(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCliHeader();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCliHeader(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCliHeader();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1671
namespace stringify {
    const char* E_SgAsmCoffSymbolTable(int64_t);
 
    std::string E_SgAsmCoffSymbolTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCoffSymbolTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCoffSymbolTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCoffSymbolTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1674
namespace stringify {
    const char* E_SgAsmElfDynamicSection(int64_t);
 
    std::string E_SgAsmElfDynamicSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfDynamicSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfDynamicSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfDynamicSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1677
namespace stringify {
    const char* E_SgAsmElfEHFrameSection(int64_t);
 
    std::string E_SgAsmElfEHFrameSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfEHFrameSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfEHFrameSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfEHFrameSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1680
namespace stringify {
    const char* E_SgAsmElfNoteSection(int64_t);
 
    std::string E_SgAsmElfNoteSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfNoteSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfNoteSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfNoteSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1683
namespace stringify {
    const char* E_SgAsmElfRelocSection(int64_t);
 
    std::string E_SgAsmElfRelocSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfRelocSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfRelocSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfRelocSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1686
namespace stringify {
    const char* E_SgAsmElfStringSection(int64_t);
 
    std::string E_SgAsmElfStringSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfStringSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfStringSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfStringSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1689
namespace stringify {
    const char* E_SgAsmElfSymbolSection(int64_t);
 
    std::string E_SgAsmElfSymbolSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymbolSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymbolSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymbolSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1692
namespace stringify {
    const char* E_SgAsmElfSymverDefinedSection(int64_t);
 
    std::string E_SgAsmElfSymverDefinedSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverDefinedSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverDefinedSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverDefinedSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1695
namespace stringify {
    const char* E_SgAsmElfSymverNeededSection(int64_t);
 
    std::string E_SgAsmElfSymverNeededSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverNeededSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverNeededSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverNeededSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1698
namespace stringify {
    const char* E_SgAsmElfSymverSection(int64_t);
 
    std::string E_SgAsmElfSymverSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymverSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymverSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymverSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1701
namespace stringify {
    const char* E_SgAsmElfSection(int64_t);
 
    std::string E_SgAsmElfSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1704
namespace stringify {
    const char* E_SgAsmDOSFileHeader(int64_t);
 
    std::string E_SgAsmDOSFileHeader(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmDOSFileHeader();
}
 
namespace Rose {
    std::string stringifyE_SgAsmDOSFileHeader(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmDOSFileHeader();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1707
namespace stringify {
    const char* E_SgAsmElfFileHeader(int64_t);
 
    std::string E_SgAsmElfFileHeader(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfFileHeader();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfFileHeader(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfFileHeader();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1710
namespace stringify {
    const char* E_SgAsmJvmFileHeader(int64_t);
 
    std::string E_SgAsmJvmFileHeader(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmJvmFileHeader();
}
 
namespace Rose {
    std::string stringifyE_SgAsmJvmFileHeader(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmJvmFileHeader();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1713
namespace stringify {
    const char* E_SgAsmLEFileHeader(int64_t);
 
    std::string E_SgAsmLEFileHeader(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmLEFileHeader();
}
 
namespace Rose {
    std::string stringifyE_SgAsmLEFileHeader(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmLEFileHeader();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1716
namespace stringify {
    const char* E_SgAsmNEFileHeader(int64_t);
 
    std::string E_SgAsmNEFileHeader(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmNEFileHeader();
}
 
namespace Rose {
    std::string stringifyE_SgAsmNEFileHeader(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmNEFileHeader();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1719
namespace stringify {
    const char* E_SgAsmPEFileHeader(int64_t);
 
    std::string E_SgAsmPEFileHeader(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEFileHeader();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEFileHeader(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEFileHeader();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1722
namespace stringify {
    const char* E_SgAsmGenericHeader(int64_t);
 
    std::string E_SgAsmGenericHeader(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmGenericHeader();
}
 
namespace Rose {
    std::string stringifyE_SgAsmGenericHeader(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmGenericHeader();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1725
namespace stringify {
    const char* E_SgAsmJvmAttributeTable(int64_t);
 
    std::string E_SgAsmJvmAttributeTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmJvmAttributeTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmJvmAttributeTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmJvmAttributeTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1728
namespace stringify {
    const char* E_SgAsmJvmFieldTable(int64_t);
 
    std::string E_SgAsmJvmFieldTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmJvmFieldTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmJvmFieldTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmJvmFieldTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1731
namespace stringify {
    const char* E_SgAsmJvmMethodTable(int64_t);
 
    std::string E_SgAsmJvmMethodTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmJvmMethodTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmJvmMethodTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmJvmMethodTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1734
namespace stringify {
    const char* E_SgAsmLEEntryTable(int64_t);
 
    std::string E_SgAsmLEEntryTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmLEEntryTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmLEEntryTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmLEEntryTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1737
namespace stringify {
    const char* E_SgAsmLEPageTable(int64_t);
 
    std::string E_SgAsmLEPageTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmLEPageTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmLEPageTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmLEPageTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1740
namespace stringify {
    const char* E_SgAsmLERelocTable(int64_t);
 
    std::string E_SgAsmLERelocTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmLERelocTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmLERelocTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmLERelocTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1743
namespace stringify {
    const char* E_SgAsmLESection(int64_t);
 
    std::string E_SgAsmLESection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmLESection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmLESection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmLESection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1746
namespace stringify {
    const char* E_SgAsmNEEntryTable(int64_t);
 
    std::string E_SgAsmNEEntryTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmNEEntryTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmNEEntryTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmNEEntryTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1749
namespace stringify {
    const char* E_SgAsmNEModuleTable(int64_t);
 
    std::string E_SgAsmNEModuleTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmNEModuleTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmNEModuleTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmNEModuleTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1752
namespace stringify {
    const char* E_SgAsmNERelocTable(int64_t);
 
    std::string E_SgAsmNERelocTable(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmNERelocTable();
}
 
namespace Rose {
    std::string stringifyE_SgAsmNERelocTable(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmNERelocTable();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1755
namespace stringify {
    const char* E_SgAsmNESection(int64_t);
 
    std::string E_SgAsmNESection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmNESection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmNESection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmNESection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1758
namespace stringify {
    const char* E_SgAsmPEExportSection(int64_t);
 
    std::string E_SgAsmPEExportSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEExportSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEExportSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEExportSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1761
namespace stringify {
    const char* E_SgAsmPEImportSection(int64_t);
 
    std::string E_SgAsmPEImportSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEImportSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEImportSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEImportSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1764
namespace stringify {
    const char* E_SgAsmPEStringSection(int64_t);
 
    std::string E_SgAsmPEStringSection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEStringSection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEStringSection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEStringSection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1767
namespace stringify {
    const char* E_SgAsmPESection(int64_t);
 
    std::string E_SgAsmPESection(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPESection();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPESection(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPESection();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1770
namespace stringify {
    const char* E_SgAsmGenericSectionList(int64_t);
 
    std::string E_SgAsmGenericSectionList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmGenericSectionList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmGenericSectionList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmGenericSectionList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1773
namespace stringify {
    const char* E_SgAsmCoffSymbol(int64_t);
 
    std::string E_SgAsmCoffSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCoffSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCoffSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCoffSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1776
namespace stringify {
    const char* E_SgAsmElfSymbol(int64_t);
 
    std::string E_SgAsmElfSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmElfSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAsmElfSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmElfSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1779
namespace stringify {
    const char* E_SgAsmGenericSymbol(int64_t);
 
    std::string E_SgAsmGenericSymbol(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmGenericSymbol();
}
 
namespace Rose {
    std::string stringifyE_SgAsmGenericSymbol(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmGenericSymbol();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1782
namespace stringify {
    const char* E_SgAsmLEEntryPoint(int64_t);
 
    std::string E_SgAsmLEEntryPoint(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmLEEntryPoint();
}
 
namespace Rose {
    std::string stringifyE_SgAsmLEEntryPoint(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmLEEntryPoint();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1785
namespace stringify {
    const char* E_SgAsmPEExportDirectory(int64_t);
 
    std::string E_SgAsmPEExportDirectory(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEExportDirectory();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEExportDirectory(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEExportDirectory();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1788
namespace stringify {
    const char* E_SgAsmPEExportEntry(int64_t);
 
    std::string E_SgAsmPEExportEntry(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEExportEntry();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEExportEntry(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEExportEntry();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1791
namespace stringify {
    const char* E_SgAsmPEExportEntryList(int64_t);
 
    std::string E_SgAsmPEExportEntryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEExportEntryList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEExportEntryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEExportEntryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1794
namespace stringify {
    const char* E_SgAsmPEImportDirectory(int64_t);
 
    std::string E_SgAsmPEImportDirectory(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEImportDirectory();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEImportDirectory(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEImportDirectory();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1797
namespace stringify {
    const char* E_SgAsmPEImportDirectoryList(int64_t);
 
    std::string E_SgAsmPEImportDirectoryList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEImportDirectoryList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEImportDirectoryList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEImportDirectoryList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1800
namespace stringify {
    const char* E_SgAsmPEImportItem(int64_t);
 
    std::string E_SgAsmPEImportItem(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEImportItem();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEImportItem(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEImportItem();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1803
namespace stringify {
    const char* E_SgAsmPEImportItemList(int64_t);
 
    std::string E_SgAsmPEImportItemList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPEImportItemList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPEImportItemList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPEImportItemList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1806
namespace stringify {
    const char* E_SgAsmPERVASizePairList(int64_t);
 
    std::string E_SgAsmPERVASizePairList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPERVASizePairList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPERVASizePairList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPERVASizePairList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1809
namespace stringify {
    const char* E_SgAsmBinaryAdd(int64_t);
 
    std::string E_SgAsmBinaryAdd(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryAdd();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryAdd(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryAdd();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1812
namespace stringify {
    const char* E_SgAsmBinaryAsr(int64_t);
 
    std::string E_SgAsmBinaryAsr(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryAsr();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryAsr(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryAsr();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1815
namespace stringify {
    const char* E_SgAsmBinaryConcat(int64_t);
 
    std::string E_SgAsmBinaryConcat(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryConcat();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryConcat(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryConcat();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1818
namespace stringify {
    const char* E_SgAsmBinaryDivide(int64_t);
 
    std::string E_SgAsmBinaryDivide(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryDivide();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryDivide(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryDivide();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1821
namespace stringify {
    const char* E_SgAsmBinaryLsl(int64_t);
 
    std::string E_SgAsmBinaryLsl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryLsl();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryLsl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryLsl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1824
namespace stringify {
    const char* E_SgAsmBinaryLsr(int64_t);
 
    std::string E_SgAsmBinaryLsr(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryLsr();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryLsr(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryLsr();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1827
namespace stringify {
    const char* E_SgAsmBinaryMod(int64_t);
 
    std::string E_SgAsmBinaryMod(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryMod();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryMod(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryMod();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1830
namespace stringify {
    const char* E_SgAsmBinaryMsl(int64_t);
 
    std::string E_SgAsmBinaryMsl(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryMsl();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryMsl(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryMsl();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1833
namespace stringify {
    const char* E_SgAsmBinaryMultiply(int64_t);
 
    std::string E_SgAsmBinaryMultiply(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryMultiply();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryMultiply(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryMultiply();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1836
namespace stringify {
    const char* E_SgAsmBinaryPostupdate(int64_t);
 
    std::string E_SgAsmBinaryPostupdate(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryPostupdate();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryPostupdate(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryPostupdate();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1839
namespace stringify {
    const char* E_SgAsmBinaryPreupdate(int64_t);
 
    std::string E_SgAsmBinaryPreupdate(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryPreupdate();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryPreupdate(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryPreupdate();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1842
namespace stringify {
    const char* E_SgAsmBinaryRor(int64_t);
 
    std::string E_SgAsmBinaryRor(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryRor();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryRor(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryRor();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1845
namespace stringify {
    const char* E_SgAsmBinarySubtract(int64_t);
 
    std::string E_SgAsmBinarySubtract(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinarySubtract();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinarySubtract(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinarySubtract();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1848
namespace stringify {
    const char* E_SgAsmBinaryExpression(int64_t);
 
    std::string E_SgAsmBinaryExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBinaryExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBinaryExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBinaryExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1851
namespace stringify {
    const char* E_SgAsmCommonSubExpression(int64_t);
 
    std::string E_SgAsmCommonSubExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCommonSubExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCommonSubExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCommonSubExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1854
namespace stringify {
    const char* E_SgAsmExprListExp(int64_t);
 
    std::string E_SgAsmExprListExp(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmExprListExp();
}
 
namespace Rose {
    std::string stringifyE_SgAsmExprListExp(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmExprListExp();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1857
namespace stringify {
    const char* E_SgAsmMemoryReferenceExpression(int64_t);
 
    std::string E_SgAsmMemoryReferenceExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmMemoryReferenceExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAsmMemoryReferenceExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmMemoryReferenceExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1860
namespace stringify {
    const char* E_SgAsmRegisterNames(int64_t);
 
    std::string E_SgAsmRegisterNames(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmRegisterNames();
}
 
namespace Rose {
    std::string stringifyE_SgAsmRegisterNames(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmRegisterNames();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1863
namespace stringify {
    const char* E_SgAsmRiscOperation(int64_t);
 
    std::string E_SgAsmRiscOperation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmRiscOperation();
}
 
namespace Rose {
    std::string stringifyE_SgAsmRiscOperation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmRiscOperation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1866
namespace stringify {
    const char* E_SgAsmUnaryMinus(int64_t);
 
    std::string E_SgAsmUnaryMinus(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmUnaryMinus();
}
 
namespace Rose {
    std::string stringifyE_SgAsmUnaryMinus(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmUnaryMinus();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1869
namespace stringify {
    const char* E_SgAsmUnaryPlus(int64_t);
 
    std::string E_SgAsmUnaryPlus(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmUnaryPlus();
}
 
namespace Rose {
    std::string stringifyE_SgAsmUnaryPlus(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmUnaryPlus();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1872
namespace stringify {
    const char* E_SgAsmUnaryRrx(int64_t);
 
    std::string E_SgAsmUnaryRrx(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmUnaryRrx();
}
 
namespace Rose {
    std::string stringifyE_SgAsmUnaryRrx(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmUnaryRrx();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1875
namespace stringify {
    const char* E_SgAsmUnarySignedExtend(int64_t);
 
    std::string E_SgAsmUnarySignedExtend(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmUnarySignedExtend();
}
 
namespace Rose {
    std::string stringifyE_SgAsmUnarySignedExtend(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmUnarySignedExtend();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1878
namespace stringify {
    const char* E_SgAsmUnaryTruncate(int64_t);
 
    std::string E_SgAsmUnaryTruncate(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmUnaryTruncate();
}
 
namespace Rose {
    std::string stringifyE_SgAsmUnaryTruncate(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmUnaryTruncate();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1881
namespace stringify {
    const char* E_SgAsmUnaryUnsignedExtend(int64_t);
 
    std::string E_SgAsmUnaryUnsignedExtend(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmUnaryUnsignedExtend();
}
 
namespace Rose {
    std::string stringifyE_SgAsmUnaryUnsignedExtend(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmUnaryUnsignedExtend();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1884
namespace stringify {
    const char* E_SgAsmUnaryExpression(int64_t);
 
    std::string E_SgAsmUnaryExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmUnaryExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAsmUnaryExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmUnaryExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1887
namespace stringify {
    const char* E_SgAsmFloatValueExpression(int64_t);
 
    std::string E_SgAsmFloatValueExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmFloatValueExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAsmFloatValueExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmFloatValueExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1890
namespace stringify {
    const char* E_SgAsmIntegerValueExpression(int64_t);
 
    std::string E_SgAsmIntegerValueExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmIntegerValueExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAsmIntegerValueExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmIntegerValueExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1893
namespace stringify {
    const char* E_SgAsmConstantExpression(int64_t);
 
    std::string E_SgAsmConstantExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmConstantExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAsmConstantExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmConstantExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1896
namespace stringify {
    const char* E_SgAsmValueExpression(int64_t);
 
    std::string E_SgAsmValueExpression(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmValueExpression();
}
 
namespace Rose {
    std::string stringifyE_SgAsmValueExpression(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmValueExpression();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1899
namespace stringify {
    const char* E_SgAsmGenericFileList(int64_t);
 
    std::string E_SgAsmGenericFileList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmGenericFileList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmGenericFileList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmGenericFileList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1902
namespace stringify {
    const char* E_SgAsmInterpretation(int64_t);
 
    std::string E_SgAsmInterpretation(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmInterpretation();
}
 
namespace Rose {
    std::string stringifyE_SgAsmInterpretation(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmInterpretation();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1905
namespace stringify {
    const char* E_SgAsmInterpretationList(int64_t);
 
    std::string E_SgAsmInterpretationList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmInterpretationList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmInterpretationList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmInterpretationList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1908
namespace stringify {
    const char* E_SgAsmJvmField(int64_t);
 
    std::string E_SgAsmJvmField(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmJvmField();
}
 
namespace Rose {
    std::string stringifyE_SgAsmJvmField(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmJvmField();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1911
namespace stringify {
    const char* E_SgAsmJvmMethod(int64_t);
 
    std::string E_SgAsmJvmMethod(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmJvmMethod();
}
 
namespace Rose {
    std::string stringifyE_SgAsmJvmMethod(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmJvmMethod();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1914
namespace stringify {
    const char* E_SgAsmOperandList(int64_t);
 
    std::string E_SgAsmOperandList(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmOperandList();
}
 
namespace Rose {
    std::string stringifyE_SgAsmOperandList(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmOperandList();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1917
namespace stringify {
    const char* E_SgAsmBlock(int64_t);
 
    std::string E_SgAsmBlock(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmBlock();
}
 
namespace Rose {
    std::string stringifyE_SgAsmBlock(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmBlock();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1920
namespace stringify {
    const char* E_SgAsmAarch32Instruction(int64_t);
 
    std::string E_SgAsmAarch32Instruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmAarch32Instruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmAarch32Instruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmAarch32Instruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1923
namespace stringify {
    const char* E_SgAsmAarch64Instruction(int64_t);
 
    std::string E_SgAsmAarch64Instruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmAarch64Instruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmAarch64Instruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmAarch64Instruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1926
namespace stringify {
    const char* E_SgAsmCilInstruction(int64_t);
 
    std::string E_SgAsmCilInstruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmCilInstruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmCilInstruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmCilInstruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1929
namespace stringify {
    const char* E_SgAsmJvmInstruction(int64_t);
 
    std::string E_SgAsmJvmInstruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmJvmInstruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmJvmInstruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmJvmInstruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1932
namespace stringify {
    const char* E_SgAsmM68kInstruction(int64_t);
 
    std::string E_SgAsmM68kInstruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmM68kInstruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmM68kInstruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmM68kInstruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1935
namespace stringify {
    const char* E_SgAsmMipsInstruction(int64_t);
 
    std::string E_SgAsmMipsInstruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmMipsInstruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmMipsInstruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmMipsInstruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1938
namespace stringify {
    const char* E_SgAsmNullInstruction(int64_t);
 
    std::string E_SgAsmNullInstruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmNullInstruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmNullInstruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmNullInstruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1941
namespace stringify {
    const char* E_SgAsmPowerpcInstruction(int64_t);
 
    std::string E_SgAsmPowerpcInstruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPowerpcInstruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPowerpcInstruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPowerpcInstruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1944
namespace stringify {
    const char* E_SgAsmUserInstruction(int64_t);
 
    std::string E_SgAsmUserInstruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmUserInstruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmUserInstruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmUserInstruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1947
namespace stringify {
    const char* E_SgAsmX86Instruction(int64_t);
 
    std::string E_SgAsmX86Instruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmX86Instruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmX86Instruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmX86Instruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1950
namespace stringify {
    const char* E_SgAsmInstruction(int64_t);
 
    std::string E_SgAsmInstruction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmInstruction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmInstruction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmInstruction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1953
namespace stringify {
    const char* E_SgAsmFunction(int64_t);
 
    std::string E_SgAsmFunction(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmFunction();
}
 
namespace Rose {
    std::string stringifyE_SgAsmFunction(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmFunction();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarTreeTraversalAccessEnums.h line 1956
namespace stringify {
    const char* E_SgAsmPointerType(int64_t);
 
    std::string E_SgAsmPointerType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& E_SgAsmPointerType();
}
 
namespace Rose {
    std::string stringifyE_SgAsmPointerType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyE_SgAsmPointerType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarVariants.h line 10
namespace stringify {
    const char* Cxx_GrammarVariants(int64_t);
 
    std::string Cxx_GrammarVariants(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Cxx_GrammarVariants();
}
 
namespace Rose {
    std::string stringifyCxx_GrammarVariants(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyCxx_GrammarVariants();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_GrammarVariants.h line 1066
namespace stringify {
    const char* VariantT(int64_t);
 
    std::string VariantT(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& VariantT();
}
 
namespace Rose {
    std::string stringifyVariantT(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifyVariantT();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 4330
namespace stringify { namespace SgConstVolatileModifier {
    const char* cv_modifier_enum(int64_t);
 
    std::string cv_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& cv_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgConstVolatileModifier_cv_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgConstVolatileModifier_cv_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 5451
namespace stringify { namespace SgStorageModifier {
    const char* storage_modifier_enum(int64_t);
 
    std::string storage_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& storage_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgStorageModifier_storage_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgStorageModifier_storage_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 6749
namespace stringify { namespace SgAccessModifier {
    const char* access_modifier_enum(int64_t);
 
    std::string access_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& access_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgAccessModifier_access_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAccessModifier_access_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 7847
namespace stringify { namespace SgFunctionModifier {
    const char* function_modifier_enum(int64_t);
 
    std::string function_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& function_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgFunctionModifier_function_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgFunctionModifier_function_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 9464
namespace stringify { namespace SgUPC_AccessModifier {
    const char* upc_access_modifier_enum(int64_t);
 
    std::string upc_access_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& upc_access_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgUPC_AccessModifier_upc_access_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgUPC_AccessModifier_upc_access_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 10591
namespace stringify { namespace SgSpecialFunctionModifier {
    const char* special_function_modifier_enum(int64_t);
 
    std::string special_function_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& special_function_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgSpecialFunctionModifier_special_function_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgSpecialFunctionModifier_special_function_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 11728
namespace stringify { namespace SgElaboratedTypeModifier {
    const char* elaborated_type_modifier_enum(int64_t);
 
    std::string elaborated_type_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& elaborated_type_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgElaboratedTypeModifier_elaborated_type_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgElaboratedTypeModifier_elaborated_type_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 12834
namespace stringify { namespace SgLinkageModifier {
    const char* linkage_modifier_enum(int64_t);
 
    std::string linkage_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& linkage_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgLinkageModifier_linkage_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgLinkageModifier_linkage_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 13924
namespace stringify { namespace SgBaseClassModifier {
    const char* baseclass_modifier_enum(int64_t);
 
    std::string baseclass_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& baseclass_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgBaseClassModifier_baseclass_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgBaseClassModifier_baseclass_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 15015
namespace stringify { namespace SgStructureModifier {
    const char* jovial_structure_modifier_enum(int64_t);
 
    std::string jovial_structure_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& jovial_structure_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgStructureModifier_jovial_structure_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgStructureModifier_jovial_structure_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 16116
namespace stringify { namespace SgTypeModifier {
    const char* type_modifier_enum(int64_t);
 
    std::string type_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& type_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgTypeModifier_type_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTypeModifier_type_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 16210
namespace stringify { namespace SgTypeModifier {
    const char* gnu_extension_machine_mode_enum(int64_t);
 
    std::string gnu_extension_machine_mode_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_extension_machine_mode_enum();
}}
 
namespace Rose {
    std::string stringifySgTypeModifier_gnu_extension_machine_mode_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTypeModifier_gnu_extension_machine_mode_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 17993
namespace stringify { namespace SgDeclarationModifier {
    const char* declaration_modifier_enum(int64_t);
 
    std::string declaration_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& declaration_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgDeclarationModifier_declaration_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDeclarationModifier_declaration_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 18051
namespace stringify { namespace SgDeclarationModifier {
    const char* gnu_declaration_visability_enum(int64_t);
 
    std::string gnu_declaration_visability_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_declaration_visability_enum();
}}
 
namespace Rose {
    std::string stringifySgDeclarationModifier_gnu_declaration_visability_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDeclarationModifier_gnu_declaration_visability_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 19666
namespace stringify { namespace SgOpenclAccessModeModifier {
    const char* access_mode_modifier_enum(int64_t);
 
    std::string access_mode_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& access_mode_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgOpenclAccessModeModifier_access_mode_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOpenclAccessModeModifier_access_mode_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 28963
namespace stringify { namespace Sg_File_Info {
    const char* classifier(int64_t);
 
    std::string classifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& classifier();
}}
 
namespace Rose {
    std::string stringifySg_File_Info_classifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySg_File_Info_classifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 29207
namespace stringify { namespace Sg_File_Info {
    const char* p_fileflags(int64_t);
 
    std::string p_fileflags(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& p_fileflags();
}}
 
namespace Rose {
    std::string stringifySg_File_Info_p_fileflags(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySg_File_Info_p_fileflags();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 30641
namespace stringify { namespace SgFile {
    const char* outputFormatOption_enum(int64_t);
 
    std::string outputFormatOption_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& outputFormatOption_enum();
}}
 
namespace Rose {
    std::string stringifySgFile_outputFormatOption_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgFile_outputFormatOption_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 30655
namespace stringify { namespace SgFile {
    const char* languageOption_enum(int64_t);
 
    std::string languageOption_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& languageOption_enum();
}}
 
namespace Rose {
    std::string stringifySgFile_languageOption_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgFile_languageOption_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 30675
namespace stringify { namespace SgFile {
    const char* standard_enum(int64_t);
 
    std::string standard_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& standard_enum();
}}
 
namespace Rose {
    std::string stringifySgFile_standard_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgFile_standard_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 39199
namespace stringify { namespace SgProject {
    const char* template_instantiation_enum(int64_t);
 
    std::string template_instantiation_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_instantiation_enum();
}}
 
namespace Rose {
    std::string stringifySgProject_template_instantiation_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgProject_template_instantiation_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 43333
namespace stringify { namespace SgUnparse_Info {
    const char* unparse_type_num(int64_t);
 
    std::string unparse_type_num(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& unparse_type_num();
}}
 
namespace Rose {
    std::string stringifySgUnparse_Info_unparse_type_num(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgUnparse_Info_unparse_type_num();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 43510
namespace stringify { namespace SgUnparse_Info {
    const char* access_attr_enum(int64_t);
 
    std::string access_attr_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& access_attr_enum();
}}
 
namespace Rose {
    std::string stringifySgUnparse_Info_access_attr_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgUnparse_Info_access_attr_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 50091
namespace stringify { namespace SgTemplateParameter {
    const char* template_parameter_enum(int64_t);
 
    std::string template_parameter_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_parameter_enum();
}}
 
namespace Rose {
    std::string stringifySgTemplateParameter_template_parameter_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTemplateParameter_template_parameter_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 51268
namespace stringify { namespace SgTemplateArgument {
    const char* template_argument_enum(int64_t);
 
    std::string template_argument_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_argument_enum();
}}
 
namespace Rose {
    std::string stringifySgTemplateArgument_template_argument_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTemplateArgument_template_argument_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 60008
namespace stringify { namespace SgGraph {
    const char* GraphEdgeType(int64_t);
 
    std::string GraphEdgeType(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& GraphEdgeType();
}}
 
namespace Rose {
    std::string stringifySgGraphGraphEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgGraphGraphEdgeType();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 60022
namespace stringify { namespace SgGraph {
    const char* GraphProperties(int64_t);
 
    std::string GraphProperties(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& GraphProperties();
}}
 
namespace Rose {
    std::string stringifySgGraphGraphProperties(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgGraphGraphProperties();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 81271
namespace stringify { namespace SgDataStatementValue {
    const char* data_statement_value_enum(int64_t);
 
    std::string data_statement_value_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& data_statement_value_enum();
}}
 
namespace Rose {
    std::string stringifySgDataStatementValue_data_statement_value_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDataStatementValue_data_statement_value_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 85467
namespace stringify { namespace SgType {
    const char* fortran_attribute_specifiers_enum(int64_t);
 
    std::string fortran_attribute_specifiers_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& fortran_attribute_specifiers_enum();
}}
 
namespace Rose {
    std::string stringifySgType_fortran_attribute_specifiers_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgType_fortran_attribute_specifiers_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 120854
namespace stringify { namespace SgJovialTableType {
    const char* StructureSpecifier(int64_t);
 
    std::string StructureSpecifier(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& StructureSpecifier();
}}
 
namespace Rose {
    std::string stringifySgJovialTableTypeStructureSpecifier(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgJovialTableTypeStructureSpecifier();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 135082
namespace stringify { namespace SgMemberFunctionType {
    const char* mfunc_specifier_enum(int64_t);
 
    std::string mfunc_specifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& mfunc_specifier_enum();
}}
 
namespace Rose {
    std::string stringifySgMemberFunctionType_mfunc_specifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgMemberFunctionType_mfunc_specifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 171299
namespace stringify { namespace SgToken {
    const char* ROSE_Fortran_Keywords(int64_t);
 
    std::string ROSE_Fortran_Keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Keywords();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_Fortran_Keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_Fortran_Keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 171466
namespace stringify { namespace SgToken {
    const char* ROSE_C_CXX_keywords(int64_t);
 
    std::string ROSE_C_CXX_keywords(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_keywords();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_C_CXX_keywords(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_C_CXX_keywords();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 171535
namespace stringify { namespace SgToken {
    const char* ROSE_Fortran_Operators(int64_t);
 
    std::string ROSE_Fortran_Operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Operators();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_Fortran_Operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_Fortran_Operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 171562
namespace stringify { namespace SgToken {
    const char* ROSE_C_CXX_Operators(int64_t);
 
    std::string ROSE_C_CXX_Operators(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_C_CXX_Operators();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_C_CXX_Operators(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_C_CXX_Operators();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 171642
namespace stringify { namespace SgToken {
    const char* ROSE_Fortran_Additional_Info(int64_t);
 
    std::string ROSE_Fortran_Additional_Info(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& ROSE_Fortran_Additional_Info();
}}
 
namespace Rose {
    std::string stringifySgTokenROSE_Fortran_Additional_Info(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTokenROSE_Fortran_Additional_Info();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 175028
namespace stringify { namespace SgInitializedName {
    const char* preinitialization_enum(int64_t);
 
    std::string preinitialization_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& preinitialization_enum();
}}
 
namespace Rose {
    std::string stringifySgInitializedName_preinitialization_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInitializedName_preinitialization_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 175043
namespace stringify { namespace SgInitializedName {
    const char* asm_register_name_enum(int64_t);
 
    std::string asm_register_name_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& asm_register_name_enum();
}}
 
namespace Rose {
    std::string stringifySgInitializedName_asm_register_name_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInitializedName_asm_register_name_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 175110
namespace stringify { namespace SgInitializedName {
    const char* gnu_variable_attribute_enum(int64_t);
 
    std::string gnu_variable_attribute_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_variable_attribute_enum();
}}
 
namespace Rose {
    std::string stringifySgInitializedName_gnu_variable_attribute_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInitializedName_gnu_variable_attribute_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 175145
namespace stringify { namespace SgInitializedName {
    const char* excess_specifier_enum(int64_t);
 
    std::string excess_specifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& excess_specifier_enum();
}}
 
namespace Rose {
    std::string stringifySgInitializedName_excess_specifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInitializedName_excess_specifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 181602
namespace stringify { namespace SgOmpClause {
    const char* omp_default_option_enum(int64_t);
 
    std::string omp_default_option_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_default_option_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_default_option_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_default_option_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 181614
namespace stringify { namespace SgOmpClause {
    const char* omp_schedule_kind_enum(int64_t);
 
    std::string omp_schedule_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_schedule_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_schedule_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_schedule_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 181624
namespace stringify { namespace SgOmpClause {
    const char* omp_reduction_operator_enum(int64_t);
 
    std::string omp_reduction_operator_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_reduction_operator_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_reduction_operator_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_reduction_operator_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 181652
namespace stringify { namespace SgOmpClause {
    const char* omp_dependence_type_enum(int64_t);
 
    std::string omp_dependence_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_dependence_type_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_dependence_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_dependence_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 181662
namespace stringify { namespace SgOmpClause {
    const char* omp_map_operator_enum(int64_t);
 
    std::string omp_map_operator_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_map_operator_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_map_operator_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_map_operator_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 181673
namespace stringify { namespace SgOmpClause {
    const char* omp_map_dist_data_enum(int64_t);
 
    std::string omp_map_dist_data_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_map_dist_data_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_map_dist_data_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_map_dist_data_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 181683
namespace stringify { namespace SgOmpClause {
    const char* omp_proc_bind_policy_enum(int64_t);
 
    std::string omp_proc_bind_policy_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_proc_bind_policy_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_proc_bind_policy_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_proc_bind_policy_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 181692
namespace stringify { namespace SgOmpClause {
    const char* omp_atomic_clause_enum(int64_t);
 
    std::string omp_atomic_clause_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& omp_atomic_clause_enum();
}}
 
namespace Rose {
    std::string stringifySgOmpClause_omp_atomic_clause_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgOmpClause_omp_atomic_clause_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 248016
namespace stringify { namespace SgForAllStatement {
    const char* forall_statement_kind_enum(int64_t);
 
    std::string forall_statement_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& forall_statement_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgForAllStatement_forall_statement_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgForAllStatement_forall_statement_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 257796
namespace stringify { namespace SgJovialForThenStatement {
    const char* loop_statement_type_enum(int64_t);
 
    std::string loop_statement_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& loop_statement_type_enum();
}}
 
namespace Rose {
    std::string stringifySgJovialForThenStatement_loop_statement_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgJovialForThenStatement_loop_statement_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 268273
namespace stringify { namespace SgDeclarationStatement {
    const char* template_specialization_enum(int64_t);
 
    std::string template_specialization_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_specialization_enum();
}}
 
namespace Rose {
    std::string stringifySgDeclarationStatement_template_specialization_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDeclarationStatement_template_specialization_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 268288
namespace stringify { namespace SgDeclarationStatement {
    const char* gnu_extension_visability_attribute_enum(int64_t);
 
    std::string gnu_extension_visability_attribute_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_extension_visability_attribute_enum();
}}
 
namespace Rose {
    std::string stringifySgDeclarationStatement_gnu_extension_visability_attribute_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgDeclarationStatement_gnu_extension_visability_attribute_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 271324
namespace stringify { namespace SgVariableDeclaration {
    const char* gnu_extension_declaration_attributes_enum(int64_t);
 
    std::string gnu_extension_declaration_attributes_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& gnu_extension_declaration_attributes_enum();
}}
 
namespace Rose {
    std::string stringifySgVariableDeclaration_gnu_extension_declaration_attributes_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgVariableDeclaration_gnu_extension_declaration_attributes_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 280600
namespace stringify { namespace SgAttributeSpecificationStatement {
    const char* attribute_spec_enum(int64_t);
 
    std::string attribute_spec_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& attribute_spec_enum();
}}
 
namespace Rose {
    std::string stringifySgAttributeSpecificationStatement_attribute_spec_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAttributeSpecificationStatement_attribute_spec_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 282812
namespace stringify { namespace SgTemplateDeclaration {
    const char* template_type_enum(int64_t);
 
    std::string template_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& template_type_enum();
}}
 
namespace Rose {
    std::string stringifySgTemplateDeclaration_template_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTemplateDeclaration_template_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 289248
namespace stringify { namespace SgInterfaceStatement {
    const char* generic_spec_enum(int64_t);
 
    std::string generic_spec_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& generic_spec_enum();
}}
 
namespace Rose {
    std::string stringifySgInterfaceStatement_generic_spec_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgInterfaceStatement_generic_spec_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 300265
namespace stringify { namespace SgClassDeclaration {
    const char* class_types(int64_t);
 
    std::string class_types(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& class_types();
}}
 
namespace Rose {
    std::string stringifySgClassDeclaration_class_types(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgClassDeclaration_class_types();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 301750
namespace stringify { namespace SgTemplateClassDeclaration {
    const char* class_types(int64_t);
 
    std::string class_types(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& class_types();
}}
 
namespace Rose {
    std::string stringifySgTemplateClassDeclaration_class_types(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgTemplateClassDeclaration_class_types();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 307034
namespace stringify { namespace SgJovialTableStatement {
    const char* WordsPerEntry(int64_t);
 
    std::string WordsPerEntry(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& WordsPerEntry();
}}
 
namespace Rose {
    std::string stringifySgJovialTableStatementWordsPerEntry(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgJovialTableStatementWordsPerEntry();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 308126
namespace stringify { namespace SgImplicitStatement {
    const char* implicit_spec_enum(int64_t);
 
    std::string implicit_spec_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& implicit_spec_enum();
}}
 
namespace Rose {
    std::string stringifySgImplicitStatement_implicit_spec_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgImplicitStatement_implicit_spec_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 320942
namespace stringify { namespace SgProcedureHeaderStatement {
    const char* subprogram_kind_enum(int64_t);
 
    std::string subprogram_kind_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& subprogram_kind_enum();
}}
 
namespace Rose {
    std::string stringifySgProcedureHeaderStatement_subprogram_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgProcedureHeaderStatement_subprogram_kind_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 352921
namespace stringify { namespace SgJovialDirectiveStatement {
    const char* directive_types(int64_t);
 
    std::string directive_types(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& directive_types();
}}
 
namespace Rose {
    std::string stringifySgJovialDirectiveStatement_directive_types(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgJovialDirectiveStatement_directive_types();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 355029
namespace stringify { namespace SgJovialLabelDeclaration {
    const char* label_type_enum(int64_t);
 
    std::string label_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& label_type_enum();
}}
 
namespace Rose {
    std::string stringifySgJovialLabelDeclaration_label_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgJovialLabelDeclaration_label_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 381466
namespace stringify { namespace SgLabelStatement {
    const char* label_type_enum(int64_t);
 
    std::string label_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& label_type_enum();
}}
 
namespace Rose {
    std::string stringifySgLabelStatement_label_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgLabelStatement_label_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 395298
namespace stringify { namespace SgProcessControlStatement {
    const char* control_enum(int64_t);
 
    std::string control_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& control_enum();
}}
 
namespace Rose {
    std::string stringifySgProcessControlStatement_control_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgProcessControlStatement_control_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 396383
namespace stringify { namespace SgIOStatement {
    const char* io_statement_enum(int64_t);
 
    std::string io_statement_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& io_statement_enum();
}}
 
namespace Rose {
    std::string stringifySgIOStatement_io_statement_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgIOStatement_io_statement_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 458966
namespace stringify { namespace SgImageControlStatement {
    const char* image_control_statement_enum(int64_t);
 
    std::string image_control_statement_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& image_control_statement_enum();
}}
 
namespace Rose {
    std::string stringifySgImageControlStatement_image_control_statement_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgImageControlStatement_image_control_statement_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 469336
namespace stringify { namespace SgAdaSelectStmt {
    const char* select_type_enum(int64_t);
 
    std::string select_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& select_type_enum();
}}
 
namespace Rose {
    std::string stringifySgAdaSelectStmt_select_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAdaSelectStmt_select_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 475816
namespace stringify { namespace SgUnaryOp {
    const char* Sgop_mode(int64_t);
 
    std::string Sgop_mode(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& Sgop_mode();
}}
 
namespace Rose {
    std::string stringifySgUnaryOpSgop_mode(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgUnaryOpSgop_mode();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 485912
namespace stringify { namespace SgCastExp {
    const char* cast_type_enum(int64_t);
 
    std::string cast_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& cast_type_enum();
}}
 
namespace Rose {
    std::string stringifySgCastExp_cast_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgCastExp_cast_type_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 487177
namespace stringify { namespace SgThrowOp {
    const char* e_throw_kind(int64_t);
 
    std::string e_throw_kind(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& e_throw_kind();
}}
 
namespace Rose {
    std::string stringifySgThrowOp_e_throw_kind(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgThrowOp_e_throw_kind();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 637972
namespace stringify { namespace SgAsmOp {
    const char* asm_operand_modifier_enum(int64_t);
 
    std::string asm_operand_modifier_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& asm_operand_modifier_enum();
}}
 
namespace Rose {
    std::string stringifySgAsmOp_asm_operand_modifier_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmOp_asm_operand_modifier_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 637991
namespace stringify { namespace SgAsmOp {
    const char* asm_operand_constraint_enum(int64_t);
 
    std::string asm_operand_constraint_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& asm_operand_constraint_enum();
}}
 
namespace Rose {
    std::string stringifySgAsmOp_asm_operand_constraint_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgAsmOp_asm_operand_constraint_enum();
}
 
// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /_build/src/ROSETTA/src/Cxx_Grammar.h line 709438
namespace stringify { namespace SgLabelSymbol {
    const char* label_type_enum(int64_t);
 
    std::string label_type_enum(int64_t, const std::string &strip);
 
    const std::vector<int64_t>& label_type_enum();
}}
 
namespace Rose {
    std::string stringifySgLabelSymbol_label_type_enum(int64_t n, const char *strip=NULL, bool canonic=false);
    const std::vector<int64_t>& stringifySgLabelSymbol_label_type_enum();
}
 
namespace stringify {
    namespace Rose {
        namespace AST {
            namespace Defects {
            }
            namespace Traversal {
            }
            namespace cmdline {
                namespace graphviz_t {
                }
                namespace checker_t {
                }
            }
        }
        namespace FormattedTable {
        }
        namespace BinaryAnalysis {
            namespace FeasiblePath {
                namespace PathProcessor {
                }
            }
            namespace HotPatch {
                namespace Record {
                }
            }
            namespace SRecord {
            }
            namespace SymbolicExpression {
                namespace TypeStyle {
                }
                namespace Formatter {
                }
                namespace Type {
                }
            }
            namespace SymbolicExpressionParser {
                namespace Token {
                }
            }
            namespace PointerDetection {
                namespace PointerDescriptor {
                }
            }
            namespace ModelChecker {
                namespace PartitionerModel {
                    namespace Settings {
                    }
                }
            }
            namespace ByteOrder {
            }
            namespace MemoryMap {
                namespace Attach {
                }
            }
            namespace InstructionSemantics {
                namespace DataFlowSemantics {
                    namespace DataFlowEdge {
                    }
                }
                namespace IntervalSemantics {
                }
                namespace SymbolicSemantics {
                    namespace AllowSideEffects {
                    }
                }
                namespace DispatcherX86 {
                }
                namespace BaseSemantics {
                    namespace RiscOperators {
                    }
                }
                namespace DispatcherAarch32 {
                }
                namespace UpdateCr {
                }
                namespace SaveLink {
                }
                namespace TaintSemantics {
                }
            }
            namespace Unparser {
                namespace ArrowMargin {
                }
                namespace EdgeArrows {
                }
            }
            namespace Partitioner2 {
                namespace Reference {
                }
                namespace BasicBlockCallback {
                }
                namespace Inliner {
                }
                namespace DataFlow {
                    namespace DfCfgVertex {
                    }
                }
                namespace ModulesElf {
                    namespace FixUndefinedSymbols {
                    }
                }
                namespace Partitioner {
                    namespace MayReturnVertexInfo {
                    }
                }
                namespace Function {
                }
                namespace ModulesX86 {
                    namespace SwitchSuccessors {
                    }
                }
                namespace Precision {
                }
                namespace AllowParallelEdges {
                }
            }
            namespace Dwarf {
            }
            namespace SmtSolver {
            }
            namespace Concolic {
                namespace ExecutionEvent {
                }
            }
            namespace RegisterDictionary {
                namespace SortBySize {
                }
            }
            namespace Debugger {
                namespace Gdb {
                    namespace Response {
                        namespace ResultRecord {
                        }
                    }
                }
                namespace Linux {
                }
                namespace GdbResponse {
                }
            }
            namespace Strings {
            }
            namespace MagicNumber {
            }
            namespace Variables {
                namespace StackVariable {
                }
                namespace StackFrame {
                }
            }
            namespace ConcreteLocation {
            }
            namespace FunctionSimilarity {
            }
            namespace Architecture {
                namespace ArmAarch32 {
                }
            }
            namespace SerialIo {
            }
            namespace Commit {
            }
            namespace CodeInserter {
            }
            namespace BinaryLoader {
            }
            namespace Disassembler {
                namespace Aarch64 {
                }
                namespace Aarch32 {
                }
                namespace Mips {
                    namespace Decoder {
                    }
                }
                namespace X86 {
                }
            }
            namespace TaintedFlow {
            }
            namespace CallingConvention {
            }
            namespace Reachability {
            }
            namespace AsmUnparser {
            }
            namespace Assembler {
            }
            namespace AssemblerX86 {
            }
        }
        namespace Color {
        }
        namespace Sarif {
        }
        namespace CodeGen {
        }
        namespace CommandLine {
            namespace FailedAssertionBehaviorAdjuster {
            }
            namespace SuffixMultiplierParser {
            }
        }
        namespace Logger {
        }
        namespace StringUtility {
        }
        namespace Snippet {
        }
        namespace EditDistance {
            namespace TreeEditDistance {
            }
        }
        namespace Callbacks {
        }
        namespace builder {
            namespace SageTreeBuilder {
            }
        }
    }
    namespace AstNodeClass {
    }
    namespace SgAsmRiscOperation {
    }
    namespace SgAsmPESectionTableEntry {
    }
    namespace SgAsmPEFileHeader {
    }
    namespace SgAsmNullInstruction {
    }
    namespace SgAsmNESectionTableEntry {
    }
    namespace SgAsmNERelocEntry {
    }
    namespace SgAsmNEFileHeader {
    }
    namespace SgAsmNEEntryPoint {
    }
    namespace SgAsmLESectionTableEntry {
    }
    namespace SgAsmLEFileHeader {
    }
    namespace SgAsmJvmStackMapVerificationType {
    }
    namespace SgAsmJvmConstantPoolEntry {
    }
    namespace SgAsmGenericFile {
    }
    namespace SgAsmFunction {
    }
    namespace SgAsmFloatType {
    }
    namespace SgAsmElfSymbol {
    }
    namespace SgAsmElfSegmentTableEntry {
    }
    namespace SgAsmElfSectionTableEntry {
    }
    namespace SgAsmElfRelocEntry {
    }
    namespace SgAsmElfFileHeader {
    }
    namespace SgAsmElfDynamicEntry {
    }
    namespace SgAsmGenericSymbol {
    }
    namespace SgAsmGenericSection {
    }
    namespace SgAsmCilMetadataHeap {
    }
    namespace SgAsmBlock {
    }
    namespace SgAsmExecutableFileFormat {
    }
    namespace AstAttribute {
    }
    namespace AstUnparseAttribute {
    }
    namespace MatchStatus {
    }
    namespace LibraryIdentification {
    }
    namespace MidLevelCollectionTypedefs {
    }
    namespace HighLevelCollectionTypedefs {
    }
    namespace AstUtilInterface {
    }
    namespace AstNodePtr {
    }
    namespace CodeThorn {
        namespace LabelProperty {
        }
        namespace VariableIdMapping {
        }
    }
    namespace SgNodeHelper {
        namespace Pattern {
            namespace OutputTarget {
            }
        }
    }
    namespace OmpSupport {
    }
    namespace FunctionCallInfo {
    }
    namespace BooleanQuery {
    }
    namespace NameQuery {
    }
    namespace AstQueryNamespace {
    }
    namespace NodeQuery {
    }
    namespace NumberQuery {
    }
    namespace AbstractMemoryObject {
        namespace IndexSet {
        }
    }
    namespace ReachingDef {
    }
    namespace CallGraph {
    }
    namespace BaseGraph {
        namespace BiDirNodesIterator {
        }
    }
    namespace CFG {
    }
    namespace RIFG {
    }
    namespace SDG {
        namespace PDGEdge {
        }
        namespace SDGNode {
        }
        namespace SDGEdge {
        }
    }
    namespace CGFunction {
        namespace iterator {
        }
    }
    namespace ConstrGraph {
    }
    namespace TaintLattice {
    }
    namespace ssa_unfiltered_cfg {
        namespace ReachingDef {
        }
    }
    namespace DominatorTreesAndDominanceFrontiers {
        namespace DominatorTree {
        }
    }
    namespace ReadWriteSets {
    }
    namespace ArithmeticIntensityMeasurement {
    }
    namespace PtrAliasAnalysis {
    }
    namespace CollectAliasRelations {
    }
    namespace TransformationSupport {
    }
    namespace DisplayEdge {
    }
    namespace AstDisplayInfo {
    }
    namespace DependencyInfo {
    }
    namespace CompilerOutputWidget {
    }
    namespace Task {
    }
    namespace QtGradientWidgetPrivate {
    }
    namespace QtColorLine {
    }
    namespace QPanelLayout {
    }
    namespace QNFAAction {
    }
    namespace QNFADefinition {
        namespace PMatch {
        }
    }
    namespace QReliableFileWatch {
    }
    namespace QDocumentCursor {
    }
    namespace QParenthesis {
    }
    namespace QDocumentLine {
    }
    namespace QDocument {
    }
    namespace QDocumentSearch {
    }
    namespace QDocumentCommand {
    }
    namespace QDocumentCursorHandle {
    }
    namespace QLanguageDefinition {
    }
    namespace QEditor {
    }
    namespace QCodeEdit {
    }
    namespace FailSafe {
    }
    namespace GenRepresentation {
    }
    namespace Rosebud {
        namespace Ast {
            namespace CppStack {
            }
        }
    }
    namespace Sawyer {
        namespace Document {
            namespace Markup {
            }
        }
        namespace CommandLine {
            namespace Parser {
            }
        }
        namespace Container {
            namespace Graph {
            }
            namespace Algorithm {
            }
        }
        namespace Tree {
            namespace Vertex {
            }
        }
        namespace Access {
        }
        namespace Language {
            namespace Clexer {
            }
        }
        namespace Yaml {
            namespace Exception {
            }
            namespace Iterator {
            }
            namespace ConstIterator {
            }
            namespace Node {
            }
        }
        namespace Database {
            namespace Statement {
            }
        }
        namespace Message {
            namespace Prefix {
            }
        }
    }
    namespace Unparse_ExprStmt {
    }
    namespace UnparseLanguageIndependentConstructs {
    }
    namespace Jovial {
    }
    namespace Jovial_ROSE_Translation {
    }
    namespace ROSE_token_ids {
    }
    namespace VirtualBinCFG {
    }
    namespace VirtualCFG {
    }
    namespace SageInterface {
        namespace DeferredTransformation {
        }
    }
    namespace SageBuilder {
    }
    namespace PreprocessingInfo {
    }
    namespace ROSEAttributesList {
    }
    namespace AstAttributeDOT {
    }
    namespace DOTGraphNode {
    }
    namespace DOTGraphEdge {
    }
    namespace AST_Graph {
    }
    namespace LanguageTranslation {
    }
    namespace csharp_translator {
    }
    namespace dot {
    }
    namespace __cxxabiv1 {
        namespace __base_class_type_info {
        }
        namespace __vmi_class_type_info {
        }
        namespace __pbase_type_info {
        }
    }
    namespace a_type_wrapper {
    }
    namespace a_class_type_wrapper {
    }
    namespace a_type_indirection {
    }
    namespace an_array_type_wrapper {
    }
    namespace an_accessibility {
    }
    namespace a_type_definition {
    }
    namespace an_ifc_module {
    }
    namespace ClangToSageTranslator {
    }
    namespace ClangToDotTranslator {
        namespace ClangToDotTranslator {
        }
    }
    namespace ROSE_Fortran_defs {
    }
    namespace nlohmann {
        namespace detail {
            namespace lexer_base {
            }
        }
        namespace basic_json {
        }
    }
    namespace qrs {
        namespace QRSelect {
        }
        namespace QRButtons {
        }
        namespace QREdit {
        }
        namespace QRTreeBox {
        }
        namespace Paren {
        }
        namespace ParenMatcher {
        }
        namespace Symbol {
        }
        namespace Q3TextStringChar {
        }
        namespace Q3TextCursor {
        }
        namespace Q3TextCommand {
        }
        namespace Q3TextCustomItem {
        }
        namespace Q3TextDocument {
        }
        namespace Q3TextPreProcessor {
        }
        namespace Q3TextFormat {
        }
        namespace QSourceColorizer {
        }
        namespace QEditor {
        }
        namespace QRSourceBox {
        }
    }
    namespace DOTGeneration {
    }
    namespace SgConstVolatileModifier {
    }
    namespace SgStorageModifier {
    }
    namespace SgAccessModifier {
    }
    namespace SgFunctionModifier {
    }
    namespace SgUPC_AccessModifier {
    }
    namespace SgSpecialFunctionModifier {
    }
    namespace SgElaboratedTypeModifier {
    }
    namespace SgLinkageModifier {
    }
    namespace SgBaseClassModifier {
    }
    namespace SgStructureModifier {
    }
    namespace SgTypeModifier {
    }
    namespace SgDeclarationModifier {
    }
    namespace SgOpenclAccessModeModifier {
    }
    namespace Sg_File_Info {
    }
    namespace SgFile {
    }
    namespace SgProject {
    }
    namespace SgUnparse_Info {
    }
    namespace SgTemplateParameter {
    }
    namespace SgTemplateArgument {
    }
    namespace SgGraph {
    }
    namespace SgDataStatementValue {
    }
    namespace SgType {
    }
    namespace SgJovialTableType {
    }
    namespace SgMemberFunctionType {
    }
    namespace SgToken {
    }
    namespace SgInitializedName {
    }
    namespace SgOmpClause {
    }
    namespace SgForAllStatement {
    }
    namespace SgJovialForThenStatement {
    }
    namespace SgDeclarationStatement {
    }
    namespace SgVariableDeclaration {
    }
    namespace SgAttributeSpecificationStatement {
    }
    namespace SgTemplateDeclaration {
    }
    namespace SgInterfaceStatement {
    }
    namespace SgClassDeclaration {
    }
    namespace SgTemplateClassDeclaration {
    }
    namespace SgJovialTableStatement {
    }
    namespace SgImplicitStatement {
    }
    namespace SgProcedureHeaderStatement {
    }
    namespace SgJovialDirectiveStatement {
    }
    namespace SgJovialLabelDeclaration {
    }
    namespace SgLabelStatement {
    }
    namespace SgProcessControlStatement {
    }
    namespace SgIOStatement {
    }
    namespace SgImageControlStatement {
    }
    namespace SgAdaSelectStmt {
    }
    namespace SgUnaryOp {
    }
    namespace SgCastExp {
    }
    namespace SgThrowOp {
    }
    namespace SgAsmOp {
    }
    namespace SgLabelSymbol {
    }
}
 
#endif