stringify.C

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

// 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 i) {
        switch (i) {
            case 0L: return "e_unknown";
            case 1L: return "e_constructor";
            case 2L: return "e_destructor";
            case 3L: return "e_copy_constructor";
            case 4L: return "e_assignment_operator";
            case 5L: return "e_last_type";
            default: return "";
        }
    }

    std::string defaultEnumFunctionType(int64_t i, const std::string &strip) {
        std::string s = defaultEnumFunctionType(i);
        if (s.empty())
            s = "(defaultEnumFunctionType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& defaultEnumFunctionType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L
        };
        static const std::vector<int64_t> retval(values, values + 6);
        return retval;
    }

}

namespace Rose {
    std::string stringify_defaultEnumFunctionType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::defaultEnumFunctionType(i);
        if (retval.empty()) {
            retval = "(defaultEnumFunctionType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "defaultEnumFunctionType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringify_defaultEnumFunctionType() {
        return 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 i) {
        switch (i) {
            case 0L: return "INSERT_BEFORE";
            case 1L: return "APPEND_SCOPE";
            case 2L: return "INVALID";
            default: return "";
        }
    }

    std::string InsertionMode(int64_t i, const std::string &strip) {
        std::string s = InsertionMode(i);
        if (s.empty())
            s = "(FunctionCallInfo::InsertionMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& InsertionMode() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyFunctionCallInfoInsertionMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::FunctionCallInfo::InsertionMode(i);
        if (retval.empty()) {
            retval = "(FunctionCallInfo::InsertionMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "FunctionCallInfo::InsertionMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyFunctionCallInfoInsertionMode() {
        return stringify::FunctionCallInfo::InsertionMode();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "e_gomp";
            case 1L: return "e_omni";
            case 2L: return "e_last_rtl";
            default: return "";
        }
    }

    std::string omp_rtl_enum(int64_t i, const std::string &strip) {
        std::string s = omp_rtl_enum(i);
        if (s.empty())
            s = "(OmpSupport::omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& omp_rtl_enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyOmpSupport_omp_rtl_enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::OmpSupport::omp_rtl_enum(i);
        if (retval.empty()) {
            retval = "(OmpSupport::omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "OmpSupport::omp_rtl_enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyOmpSupport_omp_rtl_enum() {
        return stringify::OmpSupport::omp_rtl_enum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/ompLowering/xomp.c line 62
namespace stringify {
    const char* omp_rtl_enum(int64_t i) {
        switch (i) {
            case 0L: return "e_undefined";
            case 1L: return "e_gomp";
            case 2L: return "e_omni";
            case 3L: return "e_last_rtl";
            default: return "";
        }
    }

    std::string omp_rtl_enum(int64_t i, const std::string &strip) {
        std::string s = omp_rtl_enum(i);
        if (s.empty())
            s = "(omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& omp_rtl_enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}

namespace Rose {
    std::string stringify_omp_rtl_enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::omp_rtl_enum(i);
        if (retval.empty()) {
            retval = "(omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "omp_rtl_enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringify_omp_rtl_enum() {
        return stringify::omp_rtl_enum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/libraryIdentification/FunctionIdDatabaseInterface.h line 30
namespace stringify { namespace LibraryIdentification {
    const char* DUPLICATE_OPTION(int64_t i) {
        switch (i) {
            case 0L: return "UNKNOWN";
            case 1L: return "COMBINE";
            case 2L: return "REPLACE";
            case 3L: return "NO_ADD";
            default: return "";
        }
    }

    std::string DUPLICATE_OPTION(int64_t i, const std::string &strip) {
        std::string s = DUPLICATE_OPTION(i);
        if (s.empty())
            s = "(LibraryIdentification::DUPLICATE_OPTION)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& DUPLICATE_OPTION() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyLibraryIdentificationDUPLICATE_OPTION(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::LibraryIdentification::DUPLICATE_OPTION(i);
        if (retval.empty()) {
            retval = "(LibraryIdentification::DUPLICATE_OPTION)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "LibraryIdentification::DUPLICATE_OPTION::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyLibraryIdentificationDUPLICATE_OPTION() {
        return stringify::LibraryIdentification::DUPLICATE_OPTION();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySymbolicExprParser.h line 57
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExprParser { namespace Token {
    const char* Type(int64_t i) {
        switch (i) {
            case 0L: return "NONE";
            case 1L: return "LTPAREN";
            case 2L: return "RTPAREN";
            case 3L: return "BITVECTOR";
            case 4L: return "SYMBOL";
            default: return "";
        }
    }

    std::string Type(int64_t i, const std::string &strip) {
        std::string s = Type(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SymbolicExprParser::Token::Type)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Type() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L
        };
        static const std::vector<int64_t> retval(values, values + 5);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprParserTokenType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SymbolicExprParser::Token::Type(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SymbolicExprParser::Token::Type)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SymbolicExprParser::Token::Type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprParserTokenType() {
        return stringify::Rose::BinaryAnalysis::SymbolicExprParser::Token::Type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/Concolic/ConcolicExecutor.h line 25
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic { namespace InputVariables { namespace Variable {
    const char* Whence(int64_t i) {
        switch (i) {
            case 0L: return "INVALID";
            case 1L: return "PROGRAM_ARGUMENT_COUNT";
            case 2L: return "PROGRAM_ARGUMENT";
            case 3L: return "ENVIRONMENT";
            case 4L: return "SYSTEM_CALL_RETVAL";
            default: return "";
        }
    }

    std::string Whence(int64_t i, const std::string &strip) {
        std::string s = Whence(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Whence() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L
        };
        static const std::vector<int64_t> retval(values, values + 5);
        return retval;
    }

}}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisConcolicInputVariablesVariableWhence(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicInputVariablesVariableWhence() {
        return stringify::Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/Concolic/BasicTypes.h line 17
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic { namespace Update {
    const char* Flag(int64_t i) {
        switch (i) {
            case 0L: return "NO";
            case 1L: return "YES";
            default: return "";
        }
    }

    std::string Flag(int64_t i, const std::string &strip) {
        std::string s = Flag(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Concolic::Update::Flag)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Flag() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisConcolicUpdateFlag(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Concolic::Update::Flag(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Concolic::Update::Flag)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Concolic::Update::Flag::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisConcolicUpdateFlag() {
        return stringify::Rose::BinaryAnalysis::Concolic::Update::Flag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/DwarfLineMapper.h line 20
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DwarfLineMapper {
    const char* Direction(int64_t i) {
        switch (i) {
            case 1L: return "ADDR2SRC";
            case 2L: return "SRC2ADDR";
            case 3L: return "BIDIRECTIONAL";
            default: return "";
        }
    }

    std::string Direction(int64_t i, const std::string &strip) {
        std::string s = Direction(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::DwarfLineMapper::Direction)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Direction() {
        static const int64_t values[] = {
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDwarfLineMapperDirection(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::DwarfLineMapper::Direction(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::DwarfLineMapper::Direction)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::DwarfLineMapper::Direction::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisDwarfLineMapperDirection() {
        return stringify::Rose::BinaryAnalysis::DwarfLineMapper::Direction();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryDebugger.C line 28
namespace stringify {
    const char* __ptrace_request(int64_t i) {
        switch (i) {
            case 0L: return "PTRACE_ATTACH";
            case 1L: return "PTRACE_CONT";
            case 2L: return "PTRACE_DETACH";
            case 3L: return "PTRACE_GETREGS";
            case 4L: return "PTRACE_GETFPREGS";
            case 5L: return "PTRACE_KILL";
            case 6L: return "PTRACE_SETREGS";
            case 7L: return "PTRACE_SINGLESTEP";
            case 8L: return "PTRACE_TRACEME";
            case 9L: return "PTRACE_PEEKUSER";
            default: return "";
        }
    }

    std::string __ptrace_request(int64_t i, const std::string &strip) {
        std::string s = __ptrace_request(i);
        if (s.empty())
            s = "(__ptrace_request)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& __ptrace_request() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L
        };
        static const std::vector<int64_t> retval(values, values + 10);
        return retval;
    }

}

namespace Rose {
    std::string stringify__ptrace_request(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::__ptrace_request(i);
        if (retval.empty()) {
            retval = "(__ptrace_request)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "__ptrace_request::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringify__ptrace_request() {
        return stringify::__ptrace_request();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryReachability.h line 25
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Reachability {
    const char* Reason(int64_t i) {
        switch (i) {
            case 0L: return "NOT_REACHABLE";
            case 1L: return "PROGRAM_ENTRY_POINT";
            case 2L: return "EXPORTED_FUNCTION";
            case 4L: return "SIGNAL_HANDLER";
            case 128L: return "ASSUMED";
            case 256L: return "EXPLICIT_MEM_CONSTANT";
            case 512L: return "EXPLICIT_INSN_CONSTANT";
            case 1024L: return "IMPLICIT_FUNC_CONSTANT";
            case 65536L: return "USER_DEFINED_0";
            case 131072L: return "USER_DEFINED_1";
            case 262144L: return "USER_DEFINED_2";
            case 524288L: return "USER_DEFINED_3";
            case 1048576L: return "USER_DEFINED_4";
            case 2097152L: return "USER_DEFINED_5";
            case 4194304L: return "USER_DEFINED_6";
            case 8388608L: return "USER_DEFINED_7";
            case 16777216L: return "USER_DEFINED_8";
            case 33554432L: return "USER_DEFINED_9";
            case 67108864L: return "USER_DEFINED_10";
            case 134217728L: return "USER_DEFINED_11";
            case 268435456L: return "USER_DEFINED_12";
            case 536870912L: return "USER_DEFINED_13";
            case 1073741824L: return "USER_DEFINED_14";
            case 2147483648L: return "USER_DEFINED_15";
            default: return "";
        }
    }

    std::string Reason(int64_t i, const std::string &strip) {
        std::string s = Reason(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Reachability::Reason)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Reason() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            4L,
            128L,
            256L,
            512L,
            1024L,
            65536L,
            131072L,
            262144L,
            524288L,
            1048576L,
            2097152L,
            4194304L,
            8388608L,
            16777216L,
            33554432L,
            67108864L,
            134217728L,
            268435456L,
            536870912L,
            1073741824L,
            2147483648L
        };
        static const std::vector<int64_t> retval(values, values + 24);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisReachabilityReason(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Reachability::Reason(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Reachability::Reason)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Reachability::Reason::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisReachabilityReason() {
        return stringify::Rose::BinaryAnalysis::Reachability::Reason();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryFunctionSimilarity.h line 73
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FunctionSimilarity {
    const char* CValKind(int64_t i) {
        switch (i) {
            case 0L: return "CARTESIAN_POINT";
            case 1L: return "ORDERED_LIST";
            default: return "";
        }
    }

    std::string CValKind(int64_t i, const std::string &strip) {
        std::string s = CValKind(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::FunctionSimilarity::CValKind)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& CValKind() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFunctionSimilarityCValKind(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::FunctionSimilarity::CValKind(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::FunctionSimilarity::CValKind)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::FunctionSimilarity::CValKind::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityCValKind() {
        return stringify::Rose::BinaryAnalysis::FunctionSimilarity::CValKind();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryFunctionSimilarity.h line 85
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FunctionSimilarity {
    const char* Statistic(int64_t i) {
        switch (i) {
            case 0L: return "AVERAGE";
            case 1L: return "MEDIAN";
            case 2L: return "MAXIMUM";
            default: return "";
        }
    }

    std::string Statistic(int64_t i, const std::string &strip) {
        std::string s = Statistic(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::FunctionSimilarity::Statistic)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Statistic() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFunctionSimilarityStatistic(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::FunctionSimilarity::Statistic(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::FunctionSimilarity::Statistic)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::FunctionSimilarity::Statistic::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityStatistic() {
        return stringify::Rose::BinaryAnalysis::FunctionSimilarity::Statistic();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySmtSolver.h line 45
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
    const char* LinkMode(int64_t i) {
        switch (i) {
            case 0L: return "LM_NONE";
            case 1L: return "LM_LIBRARY";
            case 2L: return "LM_EXECUTABLE";
            case 3L: return "LM_ANY";
            default: return "";
        }
    }

    std::string LinkMode(int64_t i, const std::string &strip) {
        std::string s = LinkMode(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SmtSolver::LinkMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& LinkMode() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverLinkMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SmtSolver::LinkMode(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SmtSolver::LinkMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SmtSolver::LinkMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverLinkMode() {
        return stringify::Rose::BinaryAnalysis::SmtSolver::LinkMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySmtSolver.h line 57
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
    const char* Type(int64_t i) {
        switch (i) {
            case 0L: return "NO_TYPE";
            case 1L: return "BOOLEAN";
            case 2L: return "BIT_VECTOR";
            case 3L: return "MEM_STATE";
            default: return "";
        }
    }

    std::string Type(int64_t i, const std::string &strip) {
        std::string s = Type(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SmtSolver::Type)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Type() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SmtSolver::Type(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SmtSolver::Type)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SmtSolver::Type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverType() {
        return stringify::Rose::BinaryAnalysis::SmtSolver::Type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySmtSolver.h line 81
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
    const char* Satisfiable(int64_t i) {
        switch (i) {
            case 0L: return "SAT_NO";
            case 1L: return "SAT_YES";
            case 2L: return "SAT_UNKNOWN";
            default: return "";
        }
    }

    std::string Satisfiable(int64_t i, const std::string &strip) {
        std::string s = Satisfiable(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SmtSolver::Satisfiable)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Satisfiable() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSmtSolverSatisfiable(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SmtSolver::Satisfiable(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SmtSolver::Satisfiable)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SmtSolver::Satisfiable::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverSatisfiable() {
        return stringify::Rose::BinaryAnalysis::SmtSolver::Satisfiable();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/DataFlowSemantics2.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace DataFlowSemantics { namespace DataFlowEdge {
    const char* EdgeType(int64_t i) {
        switch (i) {
            case 0L: return "CLOBBER";
            case 1L: return "AUGMENT";
            default: return "";
        }
    }

    std::string EdgeType(int64_t i, const std::string &strip) {
        std::string s = EdgeType(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& EdgeType() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/BaseSemanticsTypes.h line 78
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace BaseSemantics {
    const char* InputOutputProperty(int64_t i) {
        switch (i) {
            case 0L: return "IO_READ";
            case 1L: return "IO_WRITE";
            case 2L: return "IO_INIT";
            case 3L: return "IO_READ_BEFORE_WRITE";
            case 4L: return "IO_READ_AFTER_WRITE";
            case 5L: return "IO_READ_UNINITIALIZED";
            default: return "";
        }
    }

    std::string InputOutputProperty(int64_t i, const std::string &strip) {
        std::string s = InputOutputProperty(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& InputOutputProperty() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L
        };
        static const std::vector<int64_t> retval(values, values + 6);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/DispatcherPowerpc.C line 18
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace UpdateCr {
    const char* Flag(int64_t i) {
        switch (i) {
            case 0L: return "NO";
            case 1L: return "YES";
            default: return "";
        }
    }

    std::string Flag(int64_t i, const std::string &strip) {
        std::string s = Flag(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Flag() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2UpdateCrFlag(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2UpdateCrFlag() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/DispatcherPowerpc.C line 22
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SaveLink {
    const char* Flag(int64_t i) {
        switch (i) {
            case 0L: return "NO";
            case 1L: return "YES";
            default: return "";
        }
    }

    std::string Flag(int64_t i, const std::string &strip) {
        std::string s = Flag(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Flag() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2SaveLinkFlag(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SaveLinkFlag() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/IntervalSemantics2.C line 654
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace IntervalSemantics {
    const char* Carry(int64_t i) {
        switch (i) {
            case 0L: return "C_FALSE";
            case 1L: return "C_TRUE";
            case 2L: return "C_UNKNOWN";
            default: return "";
        }
    }

    std::string Carry(int64_t i, const std::string &strip) {
        std::string s = Carry(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Carry() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/SymbolicSemantics2.h line 65
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics { namespace AllowSideEffects {
    const char* Flag(int64_t i) {
        switch (i) {
            case 0L: return "NO";
            case 1L: return "YES";
            default: return "";
        }
    }

    std::string Flag(int64_t i, const std::string &strip) {
        std::string s = Flag(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Flag() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsAllowSideEffectsFlag(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsAllowSideEffectsFlag() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/SymbolicSemantics2.h line 769
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics {
    const char* WritersMode(int64_t i) {
        switch (i) {
            case 0L: return "TRACK_NO_WRITERS";
            case 1L: return "TRACK_LATEST_WRITER";
            case 2L: return "TRACK_ALL_WRITERS";
            default: return "";
        }
    }

    std::string WritersMode(int64_t i, const std::string &strip) {
        std::string s = WritersMode(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& WritersMode() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/SymbolicSemantics2.h line 776
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics {
    const char* DefinersMode(int64_t i) {
        switch (i) {
            case 0L: return "TRACK_NO_DEFINERS";
            case 1L: return "TRACK_LATEST_DEFINER";
            case 2L: return "TRACK_ALL_DEFINERS";
            default: return "";
        }
    }

    std::string DefinersMode(int64_t i, const std::string &strip) {
        std::string s = DefinersMode(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& DefinersMode() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/instructionSemantics/DispatcherX86.h line 181
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace DispatcherX86 {
    const char* AccessMode(int64_t i) {
        switch (i) {
            case 0L: return "READ_REGISTER";
            case 1L: return "PEEK_REGISTER";
            default: return "";
        }
    }

    std::string AccessMode(int64_t i, const std::string &strip) {
        std::string s = AccessMode(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& AccessMode() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode() {
        return stringify::Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryTaintedFlow.h line 25
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace TaintedFlow {
    const char* Taintedness(int64_t i) {
        switch (i) {
            case 0L: return "BOTTOM";
            case 1L: return "NOT_TAINTED";
            case 2L: return "TAINTED";
            case 3L: return "TOP";
            default: return "";
        }
    }

    std::string Taintedness(int64_t i, const std::string &strip) {
        std::string s = Taintedness(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::TaintedFlow::Taintedness)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Taintedness() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisTaintedFlowTaintedness(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::TaintedFlow::Taintedness(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::TaintedFlow::Taintedness)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::TaintedFlow::Taintedness::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowTaintedness() {
        return stringify::Rose::BinaryAnalysis::TaintedFlow::Taintedness();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryTaintedFlow.h line 32
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace TaintedFlow {
    const char* Approximation(int64_t i) {
        switch (i) {
            case 0L: return "UNDER_APPROXIMATE";
            case 1L: return "OVER_APPROXIMATE";
            default: return "";
        }
    }

    std::string Approximation(int64_t i, const std::string &strip) {
        std::string s = Approximation(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::TaintedFlow::Approximation)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Approximation() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisTaintedFlowApproximation(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::TaintedFlow::Approximation(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::TaintedFlow::Approximation)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::TaintedFlow::Approximation::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowApproximation() {
        return stringify::Rose::BinaryAnalysis::TaintedFlow::Approximation();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 55
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace TypeStyle {
    const char* Flag(int64_t i) {
        switch (i) {
            case 0L: return "FULL";
            case 1L: return "ABBREVIATED";
            default: return "";
        }
    }

    std::string Flag(int64_t i, const std::string &strip) {
        std::string s = Flag(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Flag() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprTypeStyleFlag(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprTypeStyleFlag() {
        return stringify::Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 73
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr {
    const char* Operator(int64_t i) {
        switch (i) {
            case 0L: return "OP_ADD";
            case 1L: return "OP_AND";
            case 2L: return "OP_ASR";
            case 3L: return "OP_CONCAT";
            case 4L: return "OP_EQ";
            case 5L: return "OP_EXTRACT";
            case 6L: return "OP_INVERT";
            case 7L: return "OP_ITE";
            case 8L: return "OP_LET";
            case 9L: return "OP_LSSB";
            case 10L: return "OP_MSSB";
            case 11L: return "OP_NE";
            case 12L: return "OP_NEGATE";
            case 13L: return "OP_NOOP";
            case 14L: return "OP_OR";
            case 15L: return "OP_READ";
            case 16L: return "OP_ROL";
            case 17L: return "OP_ROR";
            case 18L: return "OP_SDIV";
            case 19L: return "OP_SET";
            case 20L: return "OP_SEXTEND";
            case 21L: return "OP_SGE";
            case 22L: return "OP_SGT";
            case 23L: return "OP_SHL0";
            case 24L: return "OP_SHL1";
            case 25L: return "OP_SHR0";
            case 26L: return "OP_SHR1";
            case 27L: return "OP_SLE";
            case 28L: return "OP_SLT";
            case 29L: return "OP_SMOD";
            case 30L: return "OP_SMUL";
            case 31L: return "OP_UDIV";
            case 32L: return "OP_UEXTEND";
            case 33L: return "OP_UGE";
            case 34L: return "OP_UGT";
            case 35L: return "OP_ULE";
            case 36L: return "OP_ULT";
            case 37L: return "OP_UMOD";
            case 38L: return "OP_UMUL";
            case 39L: return "OP_WRITE";
            case 40L: return "OP_XOR";
            case 41L: return "OP_ZEROP";
            case 42L: return "OP_FP_ABS";
            case 43L: return "OP_FP_NEGATE";
            case 44L: return "OP_FP_ADD";
            case 45L: return "OP_FP_MUL";
            case 46L: return "OP_FP_DIV";
            case 47L: return "OP_FP_MULADD";
            case 48L: return "OP_FP_SQRT";
            case 49L: return "OP_FP_MOD";
            case 50L: return "OP_FP_ROUND";
            case 51L: return "OP_FP_MIN";
            case 52L: return "OP_FP_MAX";
            case 53L: return "OP_FP_LE";
            case 54L: return "OP_FP_LT";
            case 55L: return "OP_FP_GE";
            case 56L: return "OP_FP_GT";
            case 57L: return "OP_FP_EQ";
            case 58L: return "OP_FP_ISNORM";
            case 59L: return "OP_FP_ISSUBNORM";
            case 60L: return "OP_FP_ISZERO";
            case 61L: return "OP_FP_ISINFINITE";
            case 62L: return "OP_FP_ISNAN";
            case 63L: return "OP_FP_ISNEG";
            case 64L: return "OP_FP_ISPOS";
            case 65L: return "OP_CONVERT";
            case 66L: return "OP_REINTERPRET";
            case 67L: return "OP_NONE";
            default: return "";
        }
    }

    std::string Operator(int64_t i, const std::string &strip) {
        std::string s = Operator(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SymbolicExpr::Operator)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Operator() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L,
            10L,
            11L,
            12L,
            13L,
            14L,
            15L,
            16L,
            17L,
            18L,
            19L,
            20L,
            21L,
            22L,
            23L,
            24L,
            25L,
            26L,
            27L,
            28L,
            29L,
            30L,
            31L,
            32L,
            33L,
            34L,
            35L,
            36L,
            37L,
            38L,
            39L,
            40L,
            41L,
            42L,
            43L,
            44L,
            45L,
            46L,
            47L,
            48L,
            49L,
            50L,
            51L,
            52L,
            53L,
            54L,
            55L,
            56L,
            57L,
            58L,
            59L,
            60L,
            61L,
            62L,
            63L,
            64L,
            65L,
            66L,
            67L
        };
        static const std::vector<int64_t> retval(values, values + 68);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprOperator(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SymbolicExpr::Operator(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SymbolicExpr::Operator)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SymbolicExpr::Operator::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprOperator() {
        return stringify::Rose::BinaryAnalysis::SymbolicExpr::Operator();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 175
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace Formatter {
    const char* ShowComments(int64_t i) {
        switch (i) {
            case 0L: return "CMT_SILENT";
            case 1L: return "CMT_AFTER";
            case 2L: return "CMT_INSTEAD";
            default: return "";
        }
    }

    std::string ShowComments(int64_t i, const std::string &strip) {
        std::string s = ShowComments(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& ShowComments() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprFormatterShowComments(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprFormatterShowComments() {
        return stringify::Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 195
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr {
    const char* VisitAction(int64_t i) {
        switch (i) {
            case 0L: return "CONTINUE";
            case 1L: return "TRUNCATE";
            case 2L: return "TERMINATE";
            default: return "";
        }
    }

    std::string VisitAction(int64_t i, const std::string &strip) {
        std::string s = VisitAction(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SymbolicExpr::VisitAction)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& VisitAction() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprVisitAction(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SymbolicExpr::VisitAction(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SymbolicExpr::VisitAction)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SymbolicExpr::VisitAction::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprVisitAction() {
        return stringify::Rose::BinaryAnalysis::SymbolicExpr::VisitAction();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 228
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace Type {
    const char* TypeClass(int64_t i) {
        switch (i) {
            case 0L: return "INTEGER";
            case 1L: return "FP";
            case 2L: return "MEMORY";
            case 3L: return "INVALID";
            default: return "";
        }
    }

    std::string TypeClass(int64_t i, const std::string &strip) {
        std::string s = TypeClass(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TypeClass() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSymbolicExprTypeTypeClass(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprTypeTypeClass() {
        return stringify::Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 14
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Commit {
    const char* Boolean(int64_t i) {
        switch (i) {
            case 0L: return "NO";
            case 1L: return "YES";
            default: return "";
        }
    }

    std::string Boolean(int64_t i, const std::string &strip) {
        std::string s = Boolean(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Commit::Boolean)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Boolean() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCommitBoolean(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Commit::Boolean(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Commit::Boolean)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Commit::Boolean::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisCommitBoolean() {
        return stringify::Rose::BinaryAnalysis::Commit::Boolean();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 24
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
    const char* AggregationDirection(int64_t i) {
        switch (i) {
            case 1L: return "AGGREGATE_PREDECESSORS";
            case 2L: return "AGGREGATE_SUCCESSORS";
            default: return "";
        }
    }

    std::string AggregationDirection(int64_t i, const std::string &strip) {
        std::string s = AggregationDirection(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::CodeInserter::AggregationDirection)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& AggregationDirection() {
        static const int64_t values[] = {
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterAggregationDirection(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::CodeInserter::AggregationDirection(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::CodeInserter::AggregationDirection)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::CodeInserter::AggregationDirection::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterAggregationDirection() {
        return stringify::Rose::BinaryAnalysis::CodeInserter::AggregationDirection();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 30
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
    const char* NopPadding(int64_t i) {
        switch (i) {
            case 0L: return "PAD_NOP_BACK";
            case 1L: return "PAD_NOP_FRONT";
            case 2L: return "PAD_RANDOM_BACK";
            default: return "";
        }
    }

    std::string NopPadding(int64_t i, const std::string &strip) {
        std::string s = NopPadding(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::CodeInserter::NopPadding)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& NopPadding() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterNopPadding(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::CodeInserter::NopPadding(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::CodeInserter::NopPadding)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::CodeInserter::NopPadding::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterNopPadding() {
        return stringify::Rose::BinaryAnalysis::CodeInserter::NopPadding();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 54
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
    const char* RelocType(int64_t i) {
        switch (i) {
            case 0L: return "RELOC_INDEX_ABS_LE32";
            case 1L: return "RELOC_INDEX_ABS_LE32HI";
            case 2L: return "RELOC_INDEX_ABS_BE32";
            case 3L: return "RELOC_ADDR_REL_LE32";
            case 4L: return "RELOC_ADDR_REL_BE32";
            case 5L: return "RELOC_INSN_ABS_LE32";
            case 6L: return "RELOC_INSN_REL_LE32";
            case 7L: return "RELOC_INSN_REL_BE32";
            default: return "";
        }
    }

    std::string RelocType(int64_t i, const std::string &strip) {
        std::string s = RelocType(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::CodeInserter::RelocType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& RelocType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L
        };
        static const std::vector<int64_t> retval(values, values + 8);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCodeInserterRelocType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::CodeInserter::RelocType(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::CodeInserter::RelocType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::CodeInserter::RelocType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterRelocType() {
        return stringify::Rose::BinaryAnalysis::CodeInserter::RelocType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCallingConvention.h line 53
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
    const char* StackParameterOrder(int64_t i) {
        switch (i) {
            case 0L: return "LEFT_TO_RIGHT";
            case 1L: return "RIGHT_TO_LEFT";
            case 2L: return "ORDER_UNSPECIFIED";
            default: return "";
        }
    }

    std::string StackParameterOrder(int64_t i, const std::string &strip) {
        std::string s = StackParameterOrder(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::CallingConvention::StackParameterOrder)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& StackParameterOrder() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackParameterOrder(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::CallingConvention::StackParameterOrder(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::CallingConvention::StackParameterOrder)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::CallingConvention::StackParameterOrder::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackParameterOrder() {
        return stringify::Rose::BinaryAnalysis::CallingConvention::StackParameterOrder();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCallingConvention.h line 60
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
    const char* StackDirection(int64_t i) {
        switch (i) {
            case 0L: return "GROWS_UP";
            case 1L: return "GROWS_DOWN";
            default: return "";
        }
    }

    std::string StackDirection(int64_t i, const std::string &strip) {
        std::string s = StackDirection(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::CallingConvention::StackDirection)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& StackDirection() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackDirection(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::CallingConvention::StackDirection(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::CallingConvention::StackDirection)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::CallingConvention::StackDirection::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackDirection() {
        return stringify::Rose::BinaryAnalysis::CallingConvention::StackDirection();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCallingConvention.h line 66
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
    const char* StackCleanup(int64_t i) {
        switch (i) {
            case 0L: return "CLEANUP_BY_CALLER";
            case 1L: return "CLEANUP_BY_CALLEE";
            case 2L: return "CLEANUP_UNSPECIFIED";
            default: return "";
        }
    }

    std::string StackCleanup(int64_t i, const std::string &strip) {
        std::string s = StackCleanup(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::CallingConvention::StackCleanup)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& StackCleanup() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionStackCleanup(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::CallingConvention::StackCleanup(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::CallingConvention::StackCleanup)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::CallingConvention::StackCleanup::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackCleanup() {
        return stringify::Rose::BinaryAnalysis::CallingConvention::StackCleanup();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryCallingConvention.h line 90
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention { namespace ParameterLocation {
    const char* Type(int64_t i) {
        switch (i) {
            case 0L: return "NO_LOCATION";
            case 1L: return "REGISTER";
            case 2L: return "STACK";
            case 3L: return "ABSOLUTE";
            default: return "";
        }
    }

    std::string Type(int64_t i, const std::string &strip) {
        std::string s = Type(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Type() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisCallingConventionParameterLocationType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionParameterLocationType() {
        return stringify::Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 36
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* SearchMode(int64_t i) {
        switch (i) {
            case 0L: return "SEARCH_SINGLE_DFS";
            case 1L: return "SEARCH_SINGLE_BFS";
            case 2L: return "SEARCH_MULTI";
            default: return "";
        }
    }

    std::string SearchMode(int64_t i, const std::string &strip) {
        std::string s = SearchMode(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::FeasiblePath::SearchMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& SearchMode() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathSearchMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::FeasiblePath::SearchMode(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::FeasiblePath::SearchMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::FeasiblePath::SearchMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSearchMode() {
        return stringify::Rose::BinaryAnalysis::FeasiblePath::SearchMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 43
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* SemanticMemoryParadigm(int64_t i) {
        switch (i) {
            case 0L: return "LIST_BASED_MEMORY";
            case 1L: return "MAP_BASED_MEMORY";
            default: return "";
        }
    }

    std::string SemanticMemoryParadigm(int64_t i, const std::string &strip) {
        std::string s = SemanticMemoryParadigm(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& SemanticMemoryParadigm() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm() {
        return stringify::Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 49
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* EdgeVisitOrder(int64_t i) {
        switch (i) {
            case 0L: return "VISIT_NATURAL";
            case 1L: return "VISIT_REVERSE";
            case 2L: return "VISIT_RANDOM";
            default: return "";
        }
    }

    std::string EdgeVisitOrder(int64_t i, const std::string &strip) {
        std::string s = EdgeVisitOrder(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& EdgeVisitOrder() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder() {
        return stringify::Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 56
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* IoMode(int64_t i) {
        switch (i) {
            case 0L: return "READ";
            case 1L: return "WRITE";
            default: return "";
        }
    }

    std::string IoMode(int64_t i, const std::string &strip) {
        std::string s = IoMode(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::FeasiblePath::IoMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& IoMode() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathIoMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::FeasiblePath::IoMode(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::FeasiblePath::IoMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::FeasiblePath::IoMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathIoMode() {
        return stringify::Rose::BinaryAnalysis::FeasiblePath::IoMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 59
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
    const char* MayOrMust(int64_t i) {
        switch (i) {
            case 0L: return "MAY";
            case 1L: return "MUST";
            default: return "";
        }
    }

    std::string MayOrMust(int64_t i, const std::string &strip) {
        std::string s = MayOrMust(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::FeasiblePath::MayOrMust)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& MayOrMust() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathMayOrMust(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::FeasiblePath::MayOrMust(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::FeasiblePath::MayOrMust)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::FeasiblePath::MayOrMust::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathMayOrMust() {
        return stringify::Rose::BinaryAnalysis::FeasiblePath::MayOrMust();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 178
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath { namespace PathProcessor {
    const char* Action(int64_t i) {
        switch (i) {
            case 0L: return "BREAK";
            case 1L: return "CONTINUE";
            default: return "";
        }
    }

    std::string Action(int64_t i, const std::string &strip) {
        std::string s = Action(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Action() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisFeasiblePathPathProcessorAction(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathPathProcessorAction() {
        return stringify::Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryMagic.h line 19
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MagicNumber {
    const char* Mechanism(int64_t i) {
        switch (i) {
            case 0L: return "FAST";
            case 1L: return "SLOW";
            case 2L: return "NONE";
            default: return "";
        }
    }

    std::string Mechanism(int64_t i, const std::string &strip) {
        std::string s = Mechanism(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::MagicNumber::Mechanism)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Mechanism() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisMagicNumberMechanism(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::MagicNumber::Mechanism(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::MagicNumber::Mechanism)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::MagicNumber::Mechanism::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisMagicNumberMechanism() {
        return stringify::Rose::BinaryAnalysis::MagicNumber::Mechanism();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryHotPatch.h line 31
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace HotPatch { namespace Record {
    const char* Type(int64_t i) {
        switch (i) {
            case 0L: return "PATCH_REGISTER";
            case 1L: return "PATCH_NONE";
            default: return "";
        }
    }

    std::string Type(int64_t i, const std::string &strip) {
        std::string s = Type(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::HotPatch::Record::Type)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Type() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisHotPatchRecordType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::HotPatch::Record::Type(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::HotPatch::Record::Type)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::HotPatch::Record::Type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisHotPatchRecordType() {
        return stringify::Rose::BinaryAnalysis::HotPatch::Record::Type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryHotPatch.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace HotPatch { namespace Record {
    const char* Behavior(int64_t i) {
        switch (i) {
            case 0L: return "MATCH_CONTINUE";
            case 1L: return "MATCH_BREAK";
            default: return "";
        }
    }

    std::string Behavior(int64_t i, const std::string &strip) {
        std::string s = Behavior(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::HotPatch::Record::Behavior)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Behavior() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisHotPatchRecordBehavior(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::HotPatch::Record::Behavior(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::HotPatch::Record::Behavior)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::HotPatch::Record::Behavior::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisHotPatchRecordBehavior() {
        return stringify::Rose::BinaryAnalysis::HotPatch::Record::Behavior();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryString.h line 198
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Strings {
    const char* State(int64_t i) {
        switch (i) {
            case -4L: return "ERROR_STATE";
            case -3L: return "INITIAL_STATE";
            case -2L: return "COMPLETED_STATE";
            case -1L: return "FINAL_STATE";
            case 0L: return "USER_DEFINED_0";
            case 1L: return "USER_DEFINED_1";
            case 2L: return "USER_DEFINED_2";
            case 128L: return "USER_DEFINED_MAX";
            default: return "";
        }
    }

    std::string State(int64_t i, const std::string &strip) {
        std::string s = State(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Strings::State)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& State() {
        static const int64_t values[] = {
            -4L,
            -3L,
            -2L,
            -1L,
            0L,
            1L,
            2L,
            128L
        };
        static const std::vector<int64_t> retval(values, values + 8);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisStringsState(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Strings::State(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Strings::State)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Strings::State::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisStringsState() {
        return stringify::Rose::BinaryAnalysis::Strings::State();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryDebugger.h line 32
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
    const char* DetachMode(int64_t i) {
        switch (i) {
            case 0L: return "KILL";
            case 1L: return "DETACH";
            case 2L: return "CONTINUE";
            case 3L: return "NOTHING";
            default: return "";
        }
    }

    std::string DetachMode(int64_t i, const std::string &strip) {
        std::string s = DetachMode(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Debugger::DetachMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& DetachMode() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerDetachMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Debugger::DetachMode(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Debugger::DetachMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Debugger::DetachMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerDetachMode() {
        return stringify::Rose::BinaryAnalysis::Debugger::DetachMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryDebugger.h line 40
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
    const char* Flag(int64_t i) {
        switch (i) {
            case 1L: return "ATTACH";
            case 2L: return "REDIRECT_INPUT";
            case 4L: return "REDIRECT_OUTPUT";
            case 8L: return "REDIRECT_ERROR";
            case 16L: return "CLOSE_FILES";
            case 19L: return "DEFAULT_FLAGS";
            default: return "";
        }
    }

    std::string Flag(int64_t i, const std::string &strip) {
        std::string s = Flag(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Debugger::Flag)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Flag() {
        static const int64_t values[] = {
            1L,
            2L,
            4L,
            8L,
            16L,
            19L
        };
        static const std::vector<int64_t> retval(values, values + 6);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerFlag(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Debugger::Flag(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Debugger::Flag)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Debugger::Flag::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerFlag() {
        return stringify::Rose::BinaryAnalysis::Debugger::Flag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryDebugger.h line 227
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
    const char* RegPageStatus(int64_t i) {
        switch (i) {
            case 0L: return "REGPAGE_NONE";
            case 1L: return "REGPAGE_REGS";
            case 2L: return "REGPAGE_FPREGS";
            default: return "";
        }
    }

    std::string RegPageStatus(int64_t i, const std::string &strip) {
        std::string s = RegPageStatus(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Debugger::RegPageStatus)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& RegPageStatus() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerRegPageStatus(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Debugger::RegPageStatus(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Debugger::RegPageStatus)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Debugger::RegPageStatus::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerRegPageStatus() {
        return stringify::Rose::BinaryAnalysis::Debugger::RegPageStatus();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/BinaryAnalysis/BinaryDebugger.h line 341
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
    const char* FilterActionFlags(int64_t i) {
        switch (i) {
            case 1L: return "REJECT";
            case 2L: return "STOP";
            default: return "";
        }
    }

    std::string FilterActionFlags(int64_t i, const std::string &strip) {
        std::string s = FilterActionFlags(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::Debugger::FilterActionFlags)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& FilterActionFlags() {
        static const int64_t values[] = {
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisDebuggerFilterActionFlags(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Debugger::FilterActionFlags(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Debugger::FilterActionFlags)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::BinaryAnalysis::Debugger::FilterActionFlags::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerFilterActionFlags() {
        return stringify::Rose::BinaryAnalysis::Debugger::FilterActionFlags();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "PHI_FUNCTION";
            case 1L: return "ORIGINAL_DEF";
            case 2L: return "EXPANDED_DEF";
            case 3L: return "EXTERNAL_DEF";
            default: return "";
        }
    }

    std::string Type(int64_t i, const std::string &strip) {
        std::string s = Type(i);
        if (s.empty())
            s = "(ssa_unfiltered_cfg::ReachingDef::Type)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Type() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}}

namespace Rose {
    std::string stringify_ssa_unfiltered_cfgReachingDefType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::ssa_unfiltered_cfg::ReachingDef::Type(i);
        if (retval.empty()) {
            retval = "(ssa_unfiltered_cfg::ReachingDef::Type)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "ssa_unfiltered_cfg::ReachingDef::Type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringify_ssa_unfiltered_cfgReachingDefType() {
        return stringify::ssa_unfiltered_cfg::ReachingDef::Type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/lattice/ConstrGraph.h line 42
namespace stringify { namespace ConstrGraph {
    const char* levels(int64_t i) {
        switch (i) {
            case 0L: return "uninitialized";
            case 1L: return "bottom";
            case 2L: return "constrKnown";
            case 3L: return "top";
            default: return "";
        }
    }

    std::string levels(int64_t i, const std::string &strip) {
        std::string s = levels(i);
        if (s.empty())
            s = "(ConstrGraph::levels)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& levels() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyConstrGraph_levels(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::ConstrGraph::levels(i);
        if (retval.empty()) {
            retval = "(ConstrGraph::levels)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "ConstrGraph::levels::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyConstrGraph_levels() {
        return stringify::ConstrGraph::levels();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/cfgUtils/CallGraphTraverse.h line 121
namespace stringify { namespace CGFunction { namespace iterator {
    const char* direction(int64_t i) {
        switch (i) {
            case 0L: return "fw";
            case 1L: return "bw";
            default: return "";
        }
    }

    std::string direction(int64_t i, const std::string &strip) {
        std::string s = direction(i);
        if (s.empty())
            s = "(CGFunction::iterator::direction)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& direction() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifyCGFunction_iterator_direction(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::CGFunction::iterator::direction(i);
        if (retval.empty()) {
            retval = "(CGFunction::iterator::direction)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "CGFunction::iterator::direction::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyCGFunction_iterator_direction() {
        return stringify::CGFunction::iterator::direction();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/genericDataflow/simpleAnalyses/taintAnalysis.h line 60
namespace stringify { namespace TaintLattice {
    const char* Vertex(int64_t i) {
        switch (i) {
            case 0L: return "VERTEX_BOTTOM";
            case 1L: return "VERTEX_UNTAINTED";
            case 2L: return "VERTEX_TAINTED";
            default: return "";
        }
    }

    std::string Vertex(int64_t i, const std::string &strip) {
        std::string s = Vertex(i);
        if (s.empty())
            s = "(TaintLattice::Vertex)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Vertex() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyTaintLatticeVertex(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::TaintLattice::Vertex(i);
        if (retval.empty()) {
            retval = "(TaintLattice::Vertex)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "TaintLattice::Vertex::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyTaintLatticeVertex() {
        return stringify::TaintLattice::Vertex();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "INSERT";
            case 1L: return "DELETE";
            case 2L: return "SUBSTITUTE";
            default: return "";
        }
    }

    std::string EditType(int64_t i, const std::string &strip) {
        std::string s = EditType(i);
        if (s.empty())
            s = "(Rose::EditDistance::TreeEditDistance::EditType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& EditType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyEditDistanceTreeEditDistanceEditType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::EditDistance::TreeEditDistance::EditType(i);
        if (retval.empty()) {
            retval = "(Rose::EditDistance::TreeEditDistance::EditType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::EditDistance::TreeEditDistance::EditType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyEditDistanceTreeEditDistanceEditType() {
        return stringify::Rose::EditDistance::TreeEditDistance::EditType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "TRUE_EDGE";
            case 1L: return "FALLTHROUGH_EDGE";
            case 2L: return "FALSE_EDGE";
            case 3L: return "BACK_EDGE";
            case 4L: return "MULTIWAY_EDGE";
            case 5L: return "BREAK_EDGE";
            case 6L: return "CONTINUE_EDGE";
            case 7L: return "RETURN_EDGE";
            default: return "";
        }
    }

    std::string EdgeType(int64_t i, const std::string &strip) {
        std::string s = EdgeType(i);
        if (s.empty())
            s = "(CFG::EdgeType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& EdgeType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L
        };
        static const std::vector<int64_t> retval(values, values + 8);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyCFG_EdgeType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::CFG::EdgeType(i);
        if (retval.empty()) {
            retval = "(CFG::EdgeType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "CFG::EdgeType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyCFG_EdgeType() {
        return stringify::CFG::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 i) {
        switch (i) {
            case 0L: return "ED_INCOMING";
            case 1L: return "ED_OUTGOING";
            default: return "";
        }
    }

    std::string EdgeDirection(int64_t i, const std::string &strip) {
        std::string s = EdgeDirection(i);
        if (s.empty())
            s = "(RIFG::EdgeDirection)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& EdgeDirection() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyRIFG_EdgeDirection(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::RIFG::EdgeDirection(i);
        if (retval.empty()) {
            retval = "(RIFG::EdgeDirection)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "RIFG::EdgeDirection::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyRIFG_EdgeDirection() {
        return stringify::RIFG::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 i) {
        switch (i) {
            case 0L: return "FORWARD";
            case 1L: return "BACKWARD";
            default: return "";
        }
    }

    std::string ForwardBackward(int64_t i, const std::string &strip) {
        std::string s = ForwardBackward(i);
        if (s.empty())
            s = "(RIFG::ForwardBackward)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& ForwardBackward() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyRIFG_ForwardBackward(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::RIFG::ForwardBackward(i);
        if (retval.empty()) {
            retval = "(RIFG::ForwardBackward)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "RIFG::ForwardBackward::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyRIFG_ForwardBackward() {
        return stringify::RIFG::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 i) {
        switch (i) {
            case 0L: return "RI_TARJ_NOTHING";
            case 1L: return "RI_TARJ_ACYCLIC";
            case 2L: return "RI_TARJ_INTERVAL";
            case 3L: return "RI_TARJ_IRREDUCIBLE";
            default: return "";
        }
    }

    std::string RITarjType(int64_t i, const std::string &strip) {
        std::string s = RITarjType(i);
        if (s.empty())
            s = "(RITarjType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& RITarjType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}

namespace Rose {
    std::string stringifyRITarjType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::RITarjType(i);
        if (retval.empty()) {
            retval = "(RITarjType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "RITarjType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyRITarjType() {
        return stringify::RITarjType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "RI_TARJ_NORMAL";
            case 1L: return "RI_TARJ_LOOP_ENTRY";
            case 2L: return "RI_TARJ_IRRED_ENTRY";
            case 3L: return "RI_TARJ_ITERATE";
            default: return "";
        }
    }

    std::string RITarjEdgeType(int64_t i, const std::string &strip) {
        std::string s = RITarjEdgeType(i);
        if (s.empty())
            s = "(RITarjEdgeType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& RITarjEdgeType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}

namespace Rose {
    std::string stringifyRITarjEdgeType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::RITarjEdgeType(i);
        if (retval.empty()) {
            retval = "(RITarjEdgeType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "RITarjEdgeType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyRITarjEdgeType() {
        return stringify::RITarjEdgeType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "NORMAL_EDGE";
            default: return "";
        }
    }

    std::string EdgeType(int64_t i, const std::string &strip) {
        std::string s = EdgeType(i);
        if (s.empty())
            s = "(CallGraph::EdgeType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& EdgeType() {
        static const int64_t values[] = {
            0L
        };
        static const std::vector<int64_t> retval(values, values + 1);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyCallGraphEdgeType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::CallGraph::EdgeType(i);
        if (retval.empty()) {
            retval = "(CallGraph::EdgeType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "CallGraph::EdgeType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyCallGraphEdgeType() {
        return stringify::CallGraph::EdgeType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "Forward";
            case 1L: return "Reverse";
            default: return "";
        }
    }

    std::string dirType(int64_t i, const std::string &strip) {
        std::string s = dirType(i);
        if (s.empty())
            s = "(BaseGraph::BiDirNodesIterator::dirType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& dirType() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifyBaseGraphBiDirNodesIterator_dirType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::BaseGraph::BiDirNodesIterator::dirType(i);
        if (retval.empty()) {
            retval = "(BaseGraph::BiDirNodesIterator::dirType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "BaseGraph::BiDirNodesIterator::dirType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBaseGraphBiDirNodesIterator_dirType() {
        return stringify::BaseGraph::BiDirNodesIterator::dirType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 163
namespace stringify {
    const char* IRProcType(int64_t i) {
        switch (i) {
            case 0L: return "ProcType_PGM";
            case 1L: return "ProcType_SUB";
            case 2L: return "ProcType_FUNC";
            case 3L: return "ProcType_BDATA";
            case 4L: return "ProcType_ILLEGAL";
            default: return "";
        }
    }

    std::string IRProcType(int64_t i, const std::string &strip) {
        std::string s = IRProcType(i);
        if (s.empty())
            s = "(IRProcType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& IRProcType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L
        };
        static const std::vector<int64_t> retval(values, values + 5);
        return retval;
    }

}

namespace Rose {
    std::string stringifyIRProcType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::IRProcType(i);
        if (retval.empty()) {
            retval = "(IRProcType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "IRProcType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyIRProcType() {
        return stringify::IRProcType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "SIMPLE";
            case 1L: return "COMPOUND";
            case 2L: return "LOOP";
            case 3L: return "END_TESTED_LOOP";
            case 4L: return "STRUCT_TWOWAY_CONDITIONAL";
            case 5L: return "STRUCT_MULTIWAY_CONDITIONAL";
            case 6L: return "USTRUCT_TWOWAY_CONDITIONAL_T";
            case 7L: return "USTRUCT_TWOWAY_CONDITIONAL_F";
            case 8L: return "USTRUCT_MULTIWAY_CONDITIONAL";
            case 9L: return "RETURN";
            case 10L: return "BREAK";
            case 11L: return "LOOP_CONTINUE";
            case 12L: return "ALTERNATE_PROC_ENTRY";
            case 13L: return "UNCONDITIONAL_JUMP";
            case 14L: return "UNCONDITIONAL_JUMP_I";
            case 15L: return "NONE";
            default: return "";
        }
    }

    std::string IRStmtType(int64_t i, const std::string &strip) {
        std::string s = IRStmtType(i);
        if (s.empty())
            s = "(IRStmtType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& IRStmtType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L,
            10L,
            11L,
            12L,
            13L,
            14L,
            15L
        };
        static const std::vector<int64_t> retval(values, values + 16);
        return retval;
    }

}

namespace Rose {
    std::string stringifyIRStmtType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::IRStmtType(i);
        if (retval.empty()) {
            retval = "(IRStmtType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "IRStmtType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyIRStmtType() {
        return stringify::IRStmtType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "WHITE";
            case 1L: return "GREY";
            case 2L: return "BLACK";
            default: return "";
        }
    }

    std::string COLOR(int64_t i, const std::string &strip) {
        std::string s = COLOR(i);
        if (s.empty())
            s = "(PtrAliasAnalysis::COLOR)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& COLOR() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyPtrAliasAnalysisCOLOR(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::PtrAliasAnalysis::COLOR(i);
        if (retval.empty()) {
            retval = "(PtrAliasAnalysis::COLOR)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "PtrAliasAnalysis::COLOR::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyPtrAliasAnalysisCOLOR() {
        return stringify::PtrAliasAnalysis::COLOR();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "TOPOLOGICAL";
            case 1L: return "REVERSE_TOPOLOGICAL";
            default: return "";
        }
    }

    std::string TRAVERSAL_TYPE(int64_t i, const std::string &strip) {
        std::string s = TRAVERSAL_TYPE(i);
        if (s.empty())
            s = "(PtrAliasAnalysis::TRAVERSAL_TYPE)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TRAVERSAL_TYPE() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyPtrAliasAnalysisTRAVERSAL_TYPE(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::PtrAliasAnalysis::TRAVERSAL_TYPE(i);
        if (retval.empty()) {
            retval = "(PtrAliasAnalysis::TRAVERSAL_TYPE)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "PtrAliasAnalysis::TRAVERSAL_TYPE::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyPtrAliasAnalysisTRAVERSAL_TYPE() {
        return stringify::PtrAliasAnalysis::TRAVERSAL_TYPE();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/IntraProcAliasAnalysis.h line 279
namespace stringify { namespace CollectAliasRelations {
    const char* COLOR(int64_t i) {
        switch (i) {
            case 0L: return "WHITE";
            case 1L: return "GREY";
            case 2L: return "BLACK";
            default: return "";
        }
    }

    std::string COLOR(int64_t i, const std::string &strip) {
        std::string s = COLOR(i);
        if (s.empty())
            s = "(CollectAliasRelations::COLOR)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& COLOR() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyCollectAliasRelationsCOLOR(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::CollectAliasRelations::COLOR(i);
        if (retval.empty()) {
            retval = "(CollectAliasRelations::COLOR)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "CollectAliasRelations::COLOR::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyCollectAliasRelationsCOLOR() {
        return stringify::CollectAliasRelations::COLOR();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/VirtualFunctionAnalysis/IntraProcAliasAnalysis.h line 280
namespace stringify { namespace CollectAliasRelations {
    const char* TRAVERSAL_TYPE(int64_t i) {
        switch (i) {
            case 0L: return "TOPOLOGICAL";
            case 1L: return "NON_TOPOLOGICAL";
            default: return "";
        }
    }

    std::string TRAVERSAL_TYPE(int64_t i, const std::string &strip) {
        std::string s = TRAVERSAL_TYPE(i);
        if (s.empty())
            s = "(CollectAliasRelations::TRAVERSAL_TYPE)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TRAVERSAL_TYPE() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyCollectAliasRelationsTRAVERSAL_TYPE(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::CollectAliasRelations::TRAVERSAL_TYPE(i);
        if (retval.empty()) {
            retval = "(CollectAliasRelations::TRAVERSAL_TYPE)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "CollectAliasRelations::TRAVERSAL_TYPE::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyCollectAliasRelationsTRAVERSAL_TYPE() {
        return stringify::CollectAliasRelations::TRAVERSAL_TYPE();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/dominatorTreesAndDominanceFrontiers/DominatorTree.h line 50
namespace stringify { namespace DominatorTreesAndDominanceFrontiers { namespace DominatorTree {
    const char* Direction(int64_t i) {
        switch (i) {
            case 0L: return "PRE";
            case 1L: return "POST";
            default: return "";
        }
    }

    std::string Direction(int64_t i, const std::string &strip) {
        std::string s = Direction(i);
        if (s.empty())
            s = "(DominatorTreesAndDominanceFrontiers::DominatorTree::Direction)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Direction() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::DominatorTreesAndDominanceFrontiers::DominatorTree::Direction(i);
        if (retval.empty()) {
            retval = "(DominatorTreesAndDominanceFrontiers::DominatorTree::Direction)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "DominatorTreesAndDominanceFrontiers::DominatorTree::Direction::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection() {
        return stringify::DominatorTreesAndDominanceFrontiers::DominatorTree::Direction();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "PHI_FUNCTION";
            case 1L: return "ORIGINAL_DEF";
            case 2L: return "EXPANDED_DEF";
            default: return "";
        }
    }

    std::string Type(int64_t i, const std::string &strip) {
        std::string s = Type(i);
        if (s.empty())
            s = "(ReachingDef::Type)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Type() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyReachingDefType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::ReachingDef::Type(i);
        if (retval.empty()) {
            retval = "(ReachingDef::Type)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "ReachingDef::Type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyReachingDefType() {
        return stringify::ReachingDef::Type();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "e_analysis_and_instrument";
            case 1L: return "e_static_counting";
            default: return "";
        }
    }

    std::string running_mode_enum(int64_t i, const std::string &strip) {
        std::string s = running_mode_enum(i);
        if (s.empty())
            s = "(ArithmeticIntensityMeasurement::running_mode_enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& running_mode_enum() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyArithmeticIntensityMeasurement_running_mode_enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::ArithmeticIntensityMeasurement::running_mode_enum(i);
        if (retval.empty()) {
            retval = "(ArithmeticIntensityMeasurement::running_mode_enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "ArithmeticIntensityMeasurement::running_mode_enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_running_mode_enum() {
        return stringify::ArithmeticIntensityMeasurement::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 i) {
        switch (i) {
            case 0L: return "e_unknown";
            case 1L: return "e_total";
            case 2L: return "e_plus";
            case 3L: return "e_minus";
            case 4L: return "e_multiply";
            case 5L: return "e_divide";
            default: return "";
        }
    }

    std::string fp_operation_kind_enum(int64_t i, const std::string &strip) {
        std::string s = fp_operation_kind_enum(i);
        if (s.empty())
            s = "(ArithmeticIntensityMeasurement::fp_operation_kind_enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& fp_operation_kind_enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L
        };
        static const std::vector<int64_t> retval(values, values + 6);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::ArithmeticIntensityMeasurement::fp_operation_kind_enum(i);
        if (retval.empty()) {
            retval = "(ArithmeticIntensityMeasurement::fp_operation_kind_enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "ArithmeticIntensityMeasurement::fp_operation_kind_enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum() {
        return stringify::ArithmeticIntensityMeasurement::fp_operation_kind_enum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/PDG.h line 32
namespace stringify { namespace SDG { namespace PDGEdge {
    const char* EdgeType(int64_t i) {
        switch (i) {
            case 0L: return "ControlDependence";
            case 1L: return "DataDependence";
            default: return "";
        }
    }

    std::string EdgeType(int64_t i, const std::string &strip) {
        std::string s = EdgeType(i);
        if (s.empty())
            s = "(SDG::PDGEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& EdgeType() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifySDG_PDGEdgeEdgeType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SDG::PDGEdge::EdgeType(i);
        if (retval.empty()) {
            retval = "(SDG::PDGEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SDG::PDGEdge::EdgeType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySDG_PDGEdgeEdgeType() {
        return stringify::SDG::PDGEdge::EdgeType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "Entry";
            case 1L: return "ASTNode";
            case 2L: return "FunctionCall";
            case 3L: return "ActualIn";
            case 4L: return "ActualOut";
            case 5L: return "FormalIn";
            case 6L: return "FormalOut";
            default: return "";
        }
    }

    std::string NodeType(int64_t i, const std::string &strip) {
        std::string s = NodeType(i);
        if (s.empty())
            s = "(SDG::SDGNode::NodeType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& NodeType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L
        };
        static const std::vector<int64_t> retval(values, values + 7);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifySDG_SDGNodeNodeType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SDG::SDGNode::NodeType(i);
        if (retval.empty()) {
            retval = "(SDG::SDGNode::NodeType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SDG::SDGNode::NodeType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySDG_SDGNodeNodeType() {
        return stringify::SDG::SDGNode::NodeType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "ControlDependence";
            case 1L: return "DataDependence";
            case 2L: return "ParameterIn";
            case 3L: return "ParameterOut";
            case 4L: return "Call";
            case 5L: return "Summary";
            default: return "";
        }
    }

    std::string EdgeType(int64_t i, const std::string &strip) {
        std::string s = EdgeType(i);
        if (s.empty())
            s = "(SDG::SDGEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& EdgeType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L
        };
        static const std::vector<int64_t> retval(values, values + 6);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifySDG_SDGEdgeEdgeType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SDG::SDGEdge::EdgeType(i);
        if (retval.empty()) {
            retval = "(SDG::SDGEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SDG::SDGEdge::EdgeType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySDG_SDGEdgeEdgeType() {
        return stringify::SDG::SDGEdge::EdgeType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "cdTrue";
            case 1L: return "cdFalse";
            case 2L: return "cdCase";
            case 3L: return "cdDefault";
            default: return "";
        }
    }

    std::string ControlDependenceType(int64_t i, const std::string &strip) {
        std::string s = ControlDependenceType(i);
        if (s.empty())
            s = "(SDG::SDGEdge::ControlDependenceType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& ControlDependenceType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifySDG_SDGEdgeControlDependenceType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SDG::SDGEdge::ControlDependenceType(i);
        if (retval.empty()) {
            retval = "(SDG::SDGEdge::ControlDependenceType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SDG::SDGEdge::ControlDependenceType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySDG_SDGEdgeControlDependenceType() {
        return stringify::SDG::SDGEdge::ControlDependenceType();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "PRE_DOMINATOR";
            case 1L: return "POST_DOMINATOR";
            default: return "";
        }
    }

    std::string Dir_ection(int64_t i, const std::string &strip) {
        std::string s = Dir_ection(i);
        if (s.empty())
            s = "(DominatorTreesAndDominanceFrontiers::Dir_ection)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Dir_ection() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyDominatorTreesAndDominanceFrontiersDir_ection(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::DominatorTreesAndDominanceFrontiers::Dir_ection(i);
        if (retval.empty()) {
            retval = "(DominatorTreesAndDominanceFrontiers::Dir_ection)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "DominatorTreesAndDominanceFrontiers::Dir_ection::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDir_ection() {
        return stringify::DominatorTreesAndDominanceFrontiers::Dir_ection();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 52
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* ScopeIdentifier_Enum(int64_t i) {
        switch (i) {
            case 0L: return "unknownScope";
            case 1L: return "StatementScope";
            case 2L: return "SurroundingScope";
            case 3L: return "Preamble";
            case 4L: return "LAST_SCOPE_TAG";
            default: return "";
        }
    }

    std::string ScopeIdentifier_Enum(int64_t i, const std::string &strip) {
        std::string s = ScopeIdentifier_Enum(i);
        if (s.empty())
            s = "(MidLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& ScopeIdentifier_Enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L
        };
        static const std::vector<int64_t> retval(values, values + 5);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::MidLevelCollectionTypedefs::ScopeIdentifier_Enum(i);
        if (retval.empty()) {
            retval = "(MidLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "MidLevelCollectionTypedefs::ScopeIdentifier_Enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum() {
        return stringify::MidLevelCollectionTypedefs::ScopeIdentifier_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 i) {
        switch (i) {
            case 0L: return "unknownPositionInScope";
            case 1L: return "PreamblePositionInScope";
            case 2L: return "TopOfCurrentScope";
            case 3L: return "BeforeCurrentPosition";
            case 4L: return "ReplaceCurrentPosition";
            case 5L: return "AfterCurrentPosition";
            case 6L: return "BottomOfCurrentScope";
            case 7L: return "LAST_PLACEMENT_TAG";
            default: return "";
        }
    }

    std::string PlacementPosition_Enum(int64_t i, const std::string &strip) {
        std::string s = PlacementPosition_Enum(i);
        if (s.empty())
            s = "(MidLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& PlacementPosition_Enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L
        };
        static const std::vector<int64_t> retval(values, values + 8);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsPlacementPosition_Enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::MidLevelCollectionTypedefs::PlacementPosition_Enum(i);
        if (retval.empty()) {
            retval = "(MidLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "MidLevelCollectionTypedefs::PlacementPosition_Enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsPlacementPosition_Enum() {
        return stringify::MidLevelCollectionTypedefs::PlacementPosition_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 i) {
        switch (i) {
            case 0L: return "unknownIntermediatePositionInScope";
            case 1L: return "GlobalScopePreamble";
            case 2L: return "CurrentLocationTopOfScope";
            case 3L: return "CurrentLocationAfter";
            case 4L: return "LAST_INTERMEDIATE_SOURCE_CODE_PLACEMENT_TAG";
            case 6L: return "CurrentLocationBottomOfScope";
            default: return "";
        }
    }

    std::string IntermediateFileStringPosition_Enum(int64_t i, const std::string &strip) {
        std::string s = IntermediateFileStringPosition_Enum(i);
        if (s.empty())
            s = "(MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& IntermediateFileStringPosition_Enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            6L
        };
        static const std::vector<int64_t> retval(values, values + 6);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum(i);
        if (retval.empty()) {
            retval = "(MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum() {
        return stringify::MidLevelCollectionTypedefs::IntermediateFileStringPosition_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 i) {
        switch (i) {
            case 0L: return "unknownScope";
            case 1L: return "SurroundingScope";
            case 2L: return "ParentScope";
            case 3L: return "NestedLoopScope";
            case 4L: return "NestedConditionalScope";
            case 5L: return "FunctionScope";
            case 6L: return "FileScope";
            case 7L: return "GlobalScope";
            case 8L: return "Preamble";
            case 9L: return "LAST_SCOPE_TAG";
            default: return "";
        }
    }

    std::string ScopeIdentifier_Enum(int64_t i, const std::string &strip) {
        std::string s = ScopeIdentifier_Enum(i);
        if (s.empty())
            s = "(HighLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& ScopeIdentifier_Enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L
        };
        static const std::vector<int64_t> retval(values, values + 10);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::HighLevelCollectionTypedefs::ScopeIdentifier_Enum(i);
        if (retval.empty()) {
            retval = "(HighLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "HighLevelCollectionTypedefs::ScopeIdentifier_Enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum() {
        return stringify::HighLevelCollectionTypedefs::ScopeIdentifier_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 i) {
        switch (i) {
            case 0L: return "unknownPositionInScope";
            case 1L: return "PreamblePositionInScope";
            case 2L: return "TopOfScope";
            case 3L: return "TopOfIncludeRegion";
            case 4L: return "BottomOfIncludeRegion";
            case 5L: return "BeforeCurrentPosition";
            case 6L: return "ReplaceCurrentPosition";
            case 7L: return "AfterCurrentPosition";
            case 8L: return "BottomOfScope";
            case 9L: return "LAST_PLACEMENT_TAG";
            default: return "";
        }
    }

    std::string PlacementPosition_Enum(int64_t i, const std::string &strip) {
        std::string s = PlacementPosition_Enum(i);
        if (s.empty())
            s = "(HighLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& PlacementPosition_Enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L
        };
        static const std::vector<int64_t> retval(values, values + 10);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsPlacementPosition_Enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::HighLevelCollectionTypedefs::PlacementPosition_Enum(i);
        if (retval.empty()) {
            retval = "(HighLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "HighLevelCollectionTypedefs::PlacementPosition_Enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsPlacementPosition_Enum() {
        return stringify::HighLevelCollectionTypedefs::PlacementPosition_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 i) {
        switch (i) {
            case 0L: return "unknownIntermediatePositionInScope";
            case 1L: return "GlobalScopePreamble";
            case 2L: return "GlobalScopeTopOfScope";
            case 3L: return "GlobalScopeTopOfIncludeRegion";
            case 4L: return "GlobalScopeBottomOfIncludeRegion";
            case 5L: return "GlobalScopeBeforeCurrentPosition";
            case 6L: return "GlobalScopeReplaceCurrentPosition";
            case 7L: return "FunctionScopePreamble";
            case 8L: return "FunctionScopeTopOfScope";
            case 9L: return "FunctionScopeBeforeCurrentPosition";
            case 10L: return "FunctionScopeReplaceCurrentPosition";
            case 11L: return "FunctionScopeAfterCurrentPosition";
            case 12L: return "FunctionScopeBottomOfScope";
            case 13L: return "GlobalScopeAfterCurrentPosition";
            case 14L: return "GlobalScopeBottomOfScope";
            case 15L: return "LAST_INTERMEDIATE_SOURCE_CODE_PLACEMENT_TAG";
            default: return "";
        }
    }

    std::string IntermediateFileStringPosition_Enum(int64_t i, const std::string &strip) {
        std::string s = IntermediateFileStringPosition_Enum(i);
        if (s.empty())
            s = "(HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& IntermediateFileStringPosition_Enum() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L,
            10L,
            11L,
            12L,
            13L,
            14L,
            15L
        };
        static const std::vector<int64_t> retval(values, values + 16);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum(i);
        if (retval.empty()) {
            retval = "(HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum() {
        return stringify::HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astSnippet/Snippet.h line 319
namespace stringify { namespace Rose { namespace Snippet {
    const char* InsertMechanism(int64_t i) {
        switch (i) {
            case 0L: return "INSERT_BODY";
            case 1L: return "INSERT_STMTS";
            default: return "";
        }
    }

    std::string InsertMechanism(int64_t i, const std::string &strip) {
        std::string s = InsertMechanism(i);
        if (s.empty())
            s = "(Rose::Snippet::InsertMechanism)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& InsertMechanism() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifySnippetInsertMechanism(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::Snippet::InsertMechanism(i);
        if (retval.empty()) {
            retval = "(Rose::Snippet::InsertMechanism)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::Snippet::InsertMechanism::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySnippetInsertMechanism() {
        return stringify::Rose::Snippet::InsertMechanism();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "LOCDECLS_AT_BEGINNING";
            case 1L: return "LOCDECLS_AT_END";
            case 2L: return "LOCDECLS_AT_CURSOR";
            default: return "";
        }
    }

    std::string LocalDeclarationPosition(int64_t i, const std::string &strip) {
        std::string s = LocalDeclarationPosition(i);
        if (s.empty())
            s = "(Rose::Snippet::LocalDeclarationPosition)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& LocalDeclarationPosition() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifySnippetLocalDeclarationPosition(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::Snippet::LocalDeclarationPosition(i);
        if (retval.empty()) {
            retval = "(Rose::Snippet::LocalDeclarationPosition)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Rose::Snippet::LocalDeclarationPosition::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySnippetLocalDeclarationPosition() {
        return stringify::Rose::Snippet::LocalDeclarationPosition();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/KLT/include/KLT/RTL/tile.h line 7
namespace stringify { namespace klt_tile_desc_t {
    const char* tile_kind_e(int64_t i) {
        switch (i) {
            case 0L: return "e_tile_static";
            case 1L: return "e_tile_dynamic";
            default: return "";
        }
    }

    std::string tile_kind_e(int64_t i, const std::string &strip) {
        std::string s = tile_kind_e(i);
        if (s.empty())
            s = "(klt_tile_desc_t::tile_kind_e)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& tile_kind_e() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}

namespace Rose {
    std::string stringify_klt_tile_desc_t_tile_kind_e(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::klt_tile_desc_t::tile_kind_e(i);
        if (retval.empty()) {
            retval = "(klt_tile_desc_t::tile_kind_e)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "klt_tile_desc_t::tile_kind_e::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringify_klt_tile_desc_t_tile_kind_e() {
        return stringify::klt_tile_desc_t::tile_kind_e();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/KLT/include/KLT/Core/looptree.hpp line 30
namespace stringify { namespace KLT { namespace LoopTree {
    const char* kind_e(int64_t i) {
        switch (i) {
            case 0L: return "e_block";
            case 1L: return "e_cond";
            case 2L: return "e_loop";
            case 3L: return "e_tile";
            case 4L: return "e_stmt";
            case 5L: return "e_ignored";
            case 6L: return "e_unknown";
            default: return "";
        }
    }

    std::string kind_e(int64_t i, const std::string &strip) {
        std::string s = kind_e(i);
        if (s.empty())
            s = "(KLT::LoopTree::kind_e)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& kind_e() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L
        };
        static const std::vector<int64_t> retval(values, values + 7);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifyKLT_LoopTree_kind_e(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::KLT::LoopTree::kind_e(i);
        if (retval.empty()) {
            retval = "(KLT::LoopTree::kind_e)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "KLT::LoopTree::kind_e::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyKLT_LoopTree_kind_e() {
        return stringify::KLT::LoopTree::kind_e();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/KLT/include/KLT/Core/descriptor.hpp line 18
namespace stringify { namespace KLT { namespace Descriptor {
    const char* tile_kind_e(int64_t i) {
        switch (i) {
            case -1L: return "e_not_tile";
            case 0L: return "e_static_tile";
            case 1L: return "e_last_klt_tile";
            default: return "";
        }
    }

    std::string tile_kind_e(int64_t i, const std::string &strip) {
        std::string s = tile_kind_e(i);
        if (s.empty())
            s = "(KLT::Descriptor::tile_kind_e)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& tile_kind_e() {
        static const int64_t values[] = {
            -1L,
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifyKLT_Descriptor_tile_kind_e(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::KLT::Descriptor::tile_kind_e(i);
        if (retval.empty()) {
            retval = "(KLT::Descriptor::tile_kind_e)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "KLT::Descriptor::tile_kind_e::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyKLT_Descriptor_tile_kind_e() {
        return stringify::KLT::Descriptor::tile_kind_e();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractMemoryObject/memory_object_impl.h line 84
namespace stringify { namespace AbstractMemoryObject { namespace IndexSet {
    const char* Index_type(int64_t i) {
        switch (i) {
            case 0L: return "Integer_type";
            case 1L: return "Unknown_type";
            default: return "";
        }
    }

    std::string Index_type(int64_t i, const std::string &strip) {
        std::string s = Index_type(i);
        if (s.empty())
            s = "(AbstractMemoryObject::IndexSet::Index_type)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& Index_type() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifyAbstractMemoryObjectIndexSetIndex_type(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::AbstractMemoryObject::IndexSet::Index_type(i);
        if (retval.empty()) {
            retval = "(AbstractMemoryObject::IndexSet::Index_type)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "AbstractMemoryObject::IndexSet::Index_type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyAbstractMemoryObjectIndexSetIndex_type() {
        return stringify::AbstractMemoryObject::IndexSet::Index_type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/MDCG/include/MDCG/Model/base.hpp line 24
namespace stringify { namespace MDCG { namespace Model {
    const char* model_elements_e(int64_t i) {
        switch (i) {
            case 0L: return "e_model_blank";
            case 1L: return "e_model_variable";
            case 2L: return "e_model_function";
            case 3L: return "e_model_field";
            case 4L: return "e_model_method";
            case 5L: return "e_model_type";
            case 6L: return "e_model_class";
            case 7L: return "e_model_namespace";
            default: return "";
        }
    }

    std::string model_elements_e(int64_t i, const std::string &strip) {
        std::string s = model_elements_e(i);
        if (s.empty())
            s = "(MDCG::Model::model_elements_e)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& model_elements_e() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L
        };
        static const std::vector<int64_t> retval(values, values + 8);
        return retval;
    }

}}}

namespace Rose {
    std::string stringifyMDCG_Model_model_elements_e(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::MDCG::Model::model_elements_e(i);
        if (retval.empty()) {
            retval = "(MDCG::Model::model_elements_e)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "MDCG::Model::model_elements_e::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyMDCG_Model_model_elements_e() {
        return stringify::MDCG::Model::model_elements_e();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/MDCG/include/MDCG/Model/base.hpp line 46
namespace stringify { namespace MDCG { namespace Model { namespace element_t {
    const char* kind_e(int64_t i) {
        switch (i) {
            case 0L: return "kind";
            default: return "";
        }
    }

    std::string kind_e(int64_t i, const std::string &strip) {
        std::string s = kind_e(i);
        if (s.empty())
            s = "(MDCG::Model::element_t::kind_e)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& kind_e() {
        static const int64_t values[] = {
            0L
        };
        static const std::vector<int64_t> retval(values, values + 1);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyMDCG_Model_element_t_kind_e(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::MDCG::Model::element_t::kind_e(i);
        if (retval.empty()) {
            retval = "(MDCG::Model::element_t::kind_e)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "MDCG::Model::element_t::kind_e::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyMDCG_Model_element_t_kind_e() {
        return stringify::MDCG::Model::element_t::kind_e();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/numberQuery.h line 10
namespace stringify { namespace NumberQuery {
    const char* TypeOfQueryTypeOneParameter(int64_t i) {
        switch (i) {
            case 0L: return "UnknownListElementType";
            case 1L: return "NumberOfArgsInConstructor";
            case 2L: return "NumberOfOperands";
            case 3L: return "NumberOfArgsInScalarIndexingOperator";
            case 4L: return "END_OF_NODE_TYPE_LIST_ONE_PARAMETER";
            default: return "";
        }
    }

    std::string TypeOfQueryTypeOneParameter(int64_t i, const std::string &strip) {
        std::string s = TypeOfQueryTypeOneParameter(i);
        if (s.empty())
            s = "(NumberQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TypeOfQueryTypeOneParameter() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L
        };
        static const std::vector<int64_t> retval(values, values + 5);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyNumberQueryTypeOfQueryTypeOneParameter(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::NumberQuery::TypeOfQueryTypeOneParameter(i);
        if (retval.empty()) {
            retval = "(NumberQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "NumberQuery::TypeOfQueryTypeOneParameter::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeOneParameter() {
        return stringify::NumberQuery::TypeOfQueryTypeOneParameter();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "UnknownListElementTypeTwoParameters";
            case 1L: return "NumberOfArgsInParanthesisOperator";
            case 2L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
            default: return "";
        }
    }

    std::string TypeOfQueryTypeTwoParameters(int64_t i, const std::string &strip) {
        std::string s = TypeOfQueryTypeTwoParameters(i);
        if (s.empty())
            s = "(NumberQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyNumberQueryTypeOfQueryTypeTwoParameters(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::NumberQuery::TypeOfQueryTypeTwoParameters(i);
        if (retval.empty()) {
            retval = "(NumberQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "NumberQuery::TypeOfQueryTypeTwoParameters::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeTwoParameters() {
        return stringify::NumberQuery::TypeOfQueryTypeTwoParameters();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "UnknownListElementType";
            case 1L: return "VariableDeclaration";
            case 2L: return "Type";
            case 3L: return "FunctionDeclaration";
            case 4L: return "MemberFunctionDeclaration";
            case 5L: return "ClassDeclaration";
            case 6L: return "Argument";
            case 7L: return "Field";
            case 8L: return "UnionedField";
            case 9L: return "Struct";
            case 10L: return "ContainedInSubtreeOfType";
            case 11L: return "END_OF_BOOLEAN_QUERY_TYPE";
            default: return "";
        }
    }

    std::string TypeOfQueryType(int64_t i, const std::string &strip) {
        std::string s = TypeOfQueryType(i);
        if (s.empty())
            s = "(BooleanQuery::TypeOfQueryType)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TypeOfQueryType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L,
            10L,
            11L
        };
        static const std::vector<int64_t> retval(values, values + 12);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyBooleanQueryTypeOfQueryType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::BooleanQuery::TypeOfQueryType(i);
        if (retval.empty()) {
            retval = "(BooleanQuery::TypeOfQueryType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "BooleanQuery::TypeOfQueryType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBooleanQueryTypeOfQueryType() {
        return stringify::BooleanQuery::TypeOfQueryType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/astQuery.h line 96
namespace stringify { namespace AstQueryNamespace {
    const char* QueryDepth(int64_t i) {
        switch (i) {
            case 0L: return "UnknownListElementTypeQueryDepth";
            case 1L: return "ChildrenOnly";
            case 2L: return "AllNodes";
            case 3L: return "ExtractTypes";
            case 4L: return "END_OF_NODE_TYPE_LIST_QUERY_DEPTH";
            default: return "";
        }
    }

    std::string QueryDepth(int64_t i, const std::string &strip) {
        std::string s = QueryDepth(i);
        if (s.empty())
            s = "(AstQueryNamespace::QueryDepth)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& QueryDepth() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L
        };
        static const std::vector<int64_t> retval(values, values + 5);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyAstQueryNamespaceQueryDepth(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::AstQueryNamespace::QueryDepth(i);
        if (retval.empty()) {
            retval = "(AstQueryNamespace::QueryDepth)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "AstQueryNamespace::QueryDepth::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyAstQueryNamespaceQueryDepth() {
        return stringify::AstQueryNamespace::QueryDepth();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "UnknownListElementType";
            case 1L: return "VariableNames";
            case 2L: return "VariableTypeNames";
            case 3L: return "FunctionDeclarationNames";
            case 4L: return "MemberFunctionDeclarationNames";
            case 5L: return "ClassDeclarationNames";
            case 6L: return "ArgumentNames";
            case 7L: return "ClassFieldNames";
            case 8L: return "UnionFieldNames";
            case 9L: return "StructFieldNames";
            case 10L: return "FunctionReferenceNames";
            case 11L: return "StructNames";
            case 12L: return "UnionNames";
            case 13L: return "TypedefDeclarationNames";
            case 14L: return "TypeNames";
            case 15L: return "END_OF_NAME_TYPE_LIST";
            default: return "";
        }
    }

    std::string TypeOfQueryTypeOneParameter(int64_t i, const std::string &strip) {
        std::string s = TypeOfQueryTypeOneParameter(i);
        if (s.empty())
            s = "(NameQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TypeOfQueryTypeOneParameter() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L,
            10L,
            11L,
            12L,
            13L,
            14L,
            15L
        };
        static const std::vector<int64_t> retval(values, values + 16);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeOneParameter(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::NameQuery::TypeOfQueryTypeOneParameter(i);
        if (retval.empty()) {
            retval = "(NameQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "NameQuery::TypeOfQueryTypeOneParameter::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeOneParameter() {
        return stringify::NameQuery::TypeOfQueryTypeOneParameter();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "UnknownListElementTypeTwoParameters";
            case 1L: return "VariableNamesWithTypeName";
            case 2L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
            default: return "";
        }
    }

    std::string TypeOfQueryTypeTwoParameters(int64_t i, const std::string &strip) {
        std::string s = TypeOfQueryTypeTwoParameters(i);
        if (s.empty())
            s = "(NameQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyNameQueryTypeOfQueryTypeTwoParameters(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::NameQuery::TypeOfQueryTypeTwoParameters(i);
        if (retval.empty()) {
            retval = "(NameQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "NameQuery::TypeOfQueryTypeTwoParameters::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeTwoParameters() {
        return stringify::NameQuery::TypeOfQueryTypeTwoParameters();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "UnknownListElementType";
            case 1L: return "VariableDeclarations";
            case 2L: return "VariableTypes";
            case 3L: return "FunctionDeclarations";
            case 4L: return "MemberFunctionDeclarations";
            case 5L: return "ClassDeclarations";
            case 6L: return "StructDeclarations";
            case 7L: return "UnionDeclarations";
            case 8L: return "Arguments";
            case 9L: return "ClassFields";
            case 10L: return "StructFields";
            case 11L: return "UnionFields";
            case 12L: return "StructDefinitions";
            case 13L: return "TypedefDeclarations";
            case 14L: return "AnonymousTypedefs";
            case 15L: return "AnonymousTypedefClassDeclarations";
            case 16L: return "END_OF_NODE_TYPE_LIST_ONE_PARAMETER";
            default: return "";
        }
    }

    std::string TypeOfQueryTypeOneParameter(int64_t i, const std::string &strip) {
        std::string s = TypeOfQueryTypeOneParameter(i);
        if (s.empty())
            s = "(NodeQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TypeOfQueryTypeOneParameter() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L,
            10L,
            11L,
            12L,
            13L,
            14L,
            15L,
            16L
        };
        static const std::vector<int64_t> retval(values, values + 17);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyNodeQueryTypeOfQueryTypeOneParameter(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::NodeQuery::TypeOfQueryTypeOneParameter(i);
        if (retval.empty()) {
            retval = "(NodeQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "NodeQuery::TypeOfQueryTypeOneParameter::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeOneParameter() {
        return stringify::NodeQuery::TypeOfQueryTypeOneParameter();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "UnknownListElementTypeTwoParameters";
            case 1L: return "FunctionDeclarationFromDefinition";
            case 2L: return "ClassDeclarationFromName";
            case 3L: return "ClassDeclarationsFromTypeName";
            case 4L: return "PragmaDeclarationFromName";
            case 5L: return "VariableDeclarationFromName";
            case 6L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
            default: return "";
        }
    }

    std::string TypeOfQueryTypeTwoParameters(int64_t i, const std::string &strip) {
        std::string s = TypeOfQueryTypeTwoParameters(i);
        if (s.empty())
            s = "(NodeQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& TypeOfQueryTypeTwoParameters() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L
        };
        static const std::vector<int64_t> retval(values, values + 7);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyNodeQueryTypeOfQueryTypeTwoParameters(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::NodeQuery::TypeOfQueryTypeTwoParameters(i);
        if (retval.empty()) {
            retval = "(NodeQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "NodeQuery::TypeOfQueryTypeTwoParameters::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeTwoParameters() {
        return stringify::NodeQuery::TypeOfQueryTypeTwoParameters();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "MATCHMODE_SHALLOW";
            case 1L: return "MATCHMODE_DEEP";
            case 2L: return "MATCHMODE_SINGLE";
            default: return "";
        }
    }

    std::string PatternMatchMode(int64_t i, const std::string &strip) {
        std::string s = PatternMatchMode(i);
        if (s.empty())
            s = "(MatchStatus::PatternMatchMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& PatternMatchMode() {
        static const int64_t values[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyMatchStatusPatternMatchMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::MatchStatus::PatternMatchMode(i);
        if (retval.empty()) {
            retval = "(MatchStatus::PatternMatchMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "MatchStatus::PatternMatchMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyMatchStatusPatternMatchMode() {
        return stringify::MatchStatus::PatternMatchMode();
    }
}

// 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 i) {
        switch (i) {
            case 0L: return "NODECHECKMODE_TYPEID";
            case 1L: return "NODECHECKMODE_VARIANT";
            default: return "";
        }
    }

    std::string CheckNodeMode(int64_t i, const std::string &strip) {
        std::string s = CheckNodeMode(i);
        if (s.empty())
            s = "(MatchStatus::CheckNodeMode)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& CheckNodeMode() {
        static const int64_t values[] = {
            0L,
            1L
        };
        static const std::vector<int64_t> retval(values, values + 2);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyMatchStatusCheckNodeMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::MatchStatus::CheckNodeMode(i);
        if (retval.empty()) {
            retval = "(MatchStatus::CheckNodeMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "MatchStatus::CheckNodeMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyMatchStatusCheckNodeMode() {
        return stringify::MatchStatus::CheckNodeMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astMatching/matcherparser.h line 49
namespace stringify {
    const char* yytokentype(int64_t i) {
        switch (i) {
            case 258L: return "ALTERNATION";
            case 259L: return "NOT";
            case 260L: return "AND";
            case 261L: return "XOR";
            case 262L: return "OR";
            case 263L: return "NEQ";
            case 264L: return "EQ";
            case 265L: return "C_NEQ";
            case 266L: return "C_EQ";
            case 267L: return "WHERE";
            case 268L: return "TRUE";
            case 269L: return "FALSE";
            case 270L: return "IDENT";
            case 271L: return "VARIABLE";
            case 272L: return "INTEGER";
            case 273L: return "SQ_STRING";
            case 274L: return "NULL_NODE";
            case 275L: return "DOTDOT";
            default: return "";
        }
    }

    std::string yytokentype(int64_t i, const std::string &strip) {
        std::string s = yytokentype(i);
        if (s.empty())
            s = "(yytokentype)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& yytokentype() {
        static const int64_t values[] = {
            258L,
            259L,
            260L,
            261L,
            262L,
            263L,
            264L,
            265L,
            266L,
            267L,
            268L,
            269L,
            270L,
            271L,
            272L,
            273L,
            274L,
            275L
        };
        static const std::vector<int64_t> retval(values, values + 18);
        return retval;
    }

}

namespace Rose {
    std::string stringify_yytokentype(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::yytokentype(i);
        if (retval.empty()) {
            retval = "(yytokentype)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "yytokentype::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringify_yytokentype() {
        return stringify::yytokentype();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/MFB/include/MFB/Sage/graph.hpp line 35
namespace stringify { namespace MFB { namespace Graph { namespace API {
    const char* link_kind_e(int64_t i) {
        switch (i) {
            case 0L: return "e_link_kind_unknown";
            case 1L: return "e_link_kind_defines";
            case 2L: return "e_link_kind_extends";
            case 3L: return "e_link_kind_specializes";
            case 4L: return "e_link_kind_represents";
            case 5L: return "e_link_kind_param";
            case 6L: return "e_link_kind_arg";
            case 7L: return "e_link_kind_type_base";
            case 8L: return "e_link_kind_last";
            default: return "";
        }
    }

    std::string link_kind_e(int64_t i, const std::string &strip) {
        std::string s = link_kind_e(i);
        if (s.empty())
            s = "(MFB::Graph::API::link_kind_e)" + boost::lexical_cast<std::string>(i);
        if (boost::starts_with(s, strip))
            s = s.substr(strip.size());
        return s;
    }

    const std::vector<int64_t>& link_kind_e() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L
        };
        static const std::vector<int64_t> retval(values, values + 9);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyMFB_GraphAPIlink_kind_e(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::MFB::Graph::API::link_kind_e(i);
        if (retval.empty()) {
            retval = "(MFB::Graph::API::link_kind_e)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "MFB::Graph::API::link_kind_e::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyMFB_GraphAPIlink_kind_e() {
        return stringify::MFB::Graph::API::link_kind_e();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/Labeler.h line 59
namespace stringify { namespace CodeThorn { namespace LabelProperty {
    const char* LabelType(int64_t i) {
        switch (i) {
            case 1L: return "LABEL_UNDEF";
            case 2L: return "LABEL_OTHER";
            case 100L: return "LABEL_FUNCTIONCALL";
            case 101L: return "LABEL_FUNCTIONCALLRETURN";
            case 102L: return "LABEL_FUNCTIONENTRY";
            case 103L: return "LABEL_FUNCTIONEXIT";
            case 104L: return "LABEL_BLOCKBEGIN";
            case 105L: return "LABEL_BLOCKEND";
            case 106L: return "LABEL_EMPTY_STMT";
            case 107L: return "LABEL_FORK";
            case 108L: return "LABEL_JOIN";
            case 109L: return "LABEL_WORKSHARE";
            case 110L: return "LABEL_BARRIER";
            default: return "";
        }
    }

    std::string LabelType(int64_t i, const std::string &strip) {
        std::string s = LabelType(i);
        if (s.empty())
            s =