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/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qcodeedit.h line 46
namespace stringify { namespace QCodeEdit {
    const char* Position(int64_t i) {
        switch (i) {
            case 0L: return "West";
            case 1L: return "North";
            case 2L: return "South";
            case 3L: return "East";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& Position() {
        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 stringifyQCodeEditPosition(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QCodeEdit::Position(i);
        if (retval.empty()) {
            retval = "(QCodeEdit::Position)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "QCodeEdit::Position::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQCodeEditPosition() {
        return stringify::QCodeEdit::Position();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qlanguagedefinition.h line 44
namespace stringify { namespace QLanguageDefinition {
    const char* CollapseFlag(int64_t i) {
        switch (i) {
            case 0L: return "None";
            case 4095L: return "OpenMask";
            case 16773120L: return "CloseMask";
            case 268435456L: return "Collapsible";
            case 536870912L: return "Collapsed";
            case 1073741824L: return "Closure";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& CollapseFlag() {
        static const int64_t values[] = {
            0L,
            4095L,
            16773120L,
            268435456L,
            536870912L,
            1073741824L
        };
        static const std::vector<int64_t> retval(values, values + 6);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifyQLanguageDefinitionCollapseFlag() {
        return stringify::QLanguageDefinition::CollapseFlag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qreliablefilewatch.h line 52
namespace stringify { namespace QReliableFileWatch {
    const char* State(int64_t i) {
        switch (i) {
            case 0L: return "Clean";
            case 1L: return "Recent";
            case 2L: return "Duplicate";
            default: return "";
        }
    }

    std::string State(int64_t i, const std::string &strip) {
        std::string s = State(i);
        if (s.empty())
            s = "(QReliableFileWatch::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[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyQReliableFileWatchState(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QReliableFileWatch::State(i);
        if (retval.empty()) {
            retval = "(QReliableFileWatch::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 = "QReliableFileWatch::State::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQReliableFileWatchState() {
        return stringify::QReliableFileWatch::State();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qpanellayout.h line 38
namespace stringify { namespace QPanelLayout {
    const char* Position(int64_t i) {
        switch (i) {
            case 0L: return "West";
            case 1L: return "North";
            case 2L: return "South";
            case 3L: return "East";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& Position() {
        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 stringifyQPanelLayoutPosition(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QPanelLayout::Position(i);
        if (retval.empty()) {
            retval = "(QPanelLayout::Position)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "QPanelLayout::Position::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQPanelLayoutPosition() {
        return stringify::QPanelLayout::Position();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qpanellayout.h line 87
namespace stringify { namespace QPanelLayout {
    const char* SizeType(int64_t i) {
        switch (i) {
            case 0L: return "MinimumSize";
            case 1L: return "SizeHint";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyQPanelLayoutSizeType() {
        return stringify::QPanelLayout::SizeType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 64
namespace stringify { namespace QEditor {
    const char* CodecUpdatePolicy(int64_t i) {
        switch (i) {
            case 0L: return "NoUpdate";
            case 1L: return "UpdateOld";
            case 2L: return "UpdateDefault";
            case 4L: return "UpdateCustom";
            case 7L: return "UpdateAll";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyQEditorCodecUpdatePolicy() {
        return stringify::QEditor::CodecUpdatePolicy();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 74
namespace stringify { namespace QEditor {
    const char* EditFlag(int64_t i) {
        switch (i) {
            case 0L: return "None";
            case 1L: return "Overwrite";
            case 2L: return "CursorOn";
            case 4L: return "ReadOnly";
            case 8L: return "MousePressed";
            case 16L: return "MaybeDrag";
            case 32L: return "Selection";
            case 64L: return "Persistent";
            case 128L: return "Multiline";
            case 256L: return "FoldedCursor";
            case 4095L: return "Internal";
            case 4096L: return "LineWrap";
            case 65536L: return "CtrlNavigation";
            case 131072L: return "CursorJumpPastWrap";
            case 1048576L: return "ReplaceTabs";
            case 2097152L: return "RemoveTrailing";
            case 4194304L: return "PreserveTrailingIndent";
            case 16777216L: return "AutoCloseChars";
            case 33554432L: return "AutoIndent";
            case 4294963200L: return "Accessible";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& EditFlag() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            4L,
            8L,
            16L,
            32L,
            64L,
            128L,
            256L,
            4095L,
            4096L,
            65536L,
            131072L,
            1048576L,
            2097152L,
            4194304L,
            16777216L,
            33554432L,
            4294963200L
        };
        static const std::vector<int64_t> retval(values, values + 20);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifyQEditorEditFlag() {
        return stringify::QEditor::EditFlag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 493
namespace stringify { namespace QEditor {
    const char* SaveState(int64_t i) {
        switch (i) {
            case 0L: return "Undefined";
            case 1L: return "Saving";
            case 2L: return "Saved";
            case 3L: return "Conflict";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& SaveState() {
        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 stringifyQEditorSaveState(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QEditor::SaveState(i);
        if (retval.empty()) {
            retval = "(QEditor::SaveState)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "QEditor::SaveState::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQEditorSaveState() {
        return stringify::QEditor::SaveState();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfadefinition.h line 41
namespace stringify { namespace QNFAAction {
    const char* QNFAAction_(int64_t i) {
        switch (i) {
            case 0L: return "NoAction";
            case 4095L: return "FormatMask";
            case 16773120L: return "ParenMask";
            case 16777216L: return "Highlight";
            case 33554432L: return "Indent";
            case 67108864L: return "ParenOpen";
            case 134217728L: return "ParenClose";
            case 268435456L: return "MatchParen";
            case 536870912L: return "Fold";
            case 1073741824L: return "Ambiguous";
            case 2147483648L: return "Content";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& QNFAAction_() {
        static const int64_t values[] = {
            0L,
            4095L,
            16773120L,
            16777216L,
            33554432L,
            67108864L,
            134217728L,
            268435456L,
            536870912L,
            1073741824L,
            2147483648L
        };
        static const std::vector<int64_t> retval(values, values + 11);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifyQNFAActionQNFAAction_() {
        return stringify::QNFAAction::QNFAAction_();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfadefinition.h line 129
namespace stringify { namespace QNFADefinition { namespace PMatch {
    const char* Type(int64_t i) {
        switch (i) {
            case 0L: return "Invalid";
            case 1L: return "Match";
            case 2L: return "Mismatch";
            default: return "";
        }
    }

    std::string Type(int64_t i, const std::string &strip) {
        std::string s = Type(i);
        if (s.empty())
            s = "(QNFADefinition::PMatch::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 stringifyQNFADefinitionPMatchType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QNFADefinition::PMatch::Type(i);
        if (retval.empty()) {
            retval = "(QNFADefinition::PMatch::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 = "QNFADefinition::PMatch::Type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQNFADefinitionPMatchType() {
        return stringify::QNFADefinition::PMatch::Type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfa.h line 42
namespace stringify {
    const char* NFAType(int64_t i) {
        switch (i) {
            case 0L: return "Char";
            case 1L: return "Match";
            case 2L: return "CxtBeg";
            case 3L: return "ContextBegin";
            case 4L: return "CxtEnd";
            case 5L: return "ContextEnd";
            case 8L: return "CxtEsc";
            case 9L: return "EscapeSeq";
            case 16L: return "Escaped";
            case 32L: return "Exclusive";
            case 64L: return "StayOnLine";
            case 128L: return "Reserved";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& NFAType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            8L,
            9L,
            16L,
            32L,
            64L,
            128L
        };
        static const std::vector<int64_t> retval(values, values + 12);
        return retval;
    }

}

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

    const std::vector<int64_t>& stringifyNFAType() {
        return stringify::NFAType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfa.h line 63
namespace stringify {
    const char* NFAAssertion(int64_t i) {
        switch (i) {
            case 0L: return "NoAssertion";
            case 1L: return "ZeroOrOne";
            case 2L: return "ZeroOrMore";
            case 4L: return "OneOrMore";
            case 8L: return "WordStart";
            case 16L: return "WordEnd";
            case 32L: return "Word";
            case 64L: return "NonWord";
            case 128L: return "Digit";
            case 256L: return "NonDigit";
            case 512L: return "Space";
            case 1024L: return "NonSpace";
            case 2048L: return "CaseSensitive";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& NFAAssertion() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            4L,
            8L,
            16L,
            32L,
            64L,
            128L,
            256L,
            512L,
            1024L,
            2048L
        };
        static const std::vector<int64_t> retval(values, values + 13);
        return retval;
    }

}

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

    const std::vector<int64_t>& stringifyNFAAssertion() {
        return stringify::NFAAssertion();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentline.h line 38
namespace stringify { namespace QParenthesis {
    const char* Role(int64_t i) {
        switch (i) {
            case 1L: return "Open";
            case 2L: return "Close";
            case 4L: return "Indent";
            case 8L: return "Fold";
            case 16L: return "Match";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyQParenthesisRole() {
        return stringify::QParenthesis::Role();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentline.h line 69
namespace stringify { namespace QDocumentLine {
    const char* State(int64_t i) {
        switch (i) {
            case 0L: return "None";
            case 1L: return "Hidden";
            case 2L: return "CollapsedBlockStart";
            case 4L: return "CollapsedBlockEnd";
            case 16L: return "LayoutDirty";
            case 32L: return "FormatsApplied";
            default: return "";
        }
    }

    std::string State(int64_t i, const std::string &strip) {
        std::string s = State(i);
        if (s.empty())
            s = "(QDocumentLine::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[] = {
            0L,
            1L,
            2L,
            4L,
            16L,
            32L
        };
        static const std::vector<int64_t> retval(values, values + 6);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyQDocumentLineState(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QDocumentLine::State(i);
        if (retval.empty()) {
            retval = "(QDocumentLine::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 = "QDocumentLine::State::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQDocumentLineState() {
        return stringify::QDocumentLine::State();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcommand.h line 37
namespace stringify { namespace QDocumentCommand {
    const char* Command(int64_t i) {
        switch (i) {
            case 0L: return "None";
            case 1L: return "Insert";
            case 2L: return "Erase";
            case 3L: return "Replace";
            case 4L: return "Custom";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& Command() {
        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 stringifyQDocumentCommandCommand(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QDocumentCommand::Command(i);
        if (retval.empty()) {
            retval = "(QDocumentCommand::Command)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "QDocumentCommand::Command::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQDocumentCommandCommand() {
        return stringify::QDocumentCommand::Command();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 39
namespace stringify { namespace QDocumentCursor {
    const char* MoveFlag(int64_t i) {
        switch (i) {
            case 0L: return "MoveAnchor";
            case 1L: return "KeepAnchor";
            case 2L: return "ThroughWrap";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyQDocumentCursorMoveFlag() {
        return stringify::QDocumentCursor::MoveFlag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 48
namespace stringify { namespace QDocumentCursor {
    const char* MoveOperation(int64_t i) {
        switch (i) {
            case 0L: return "NoMove";
            case 1L: return "Up";
            case 2L: return "Down";
            case 3L: return "Left";
            case 4L: return "Right";
            case 5L: return "Start";
            case 6L: return "StartOfLine";
            case 7L: return "StartOfWord";
            case 8L: return "PreviousBlock";
            case 9L: return "PreviousWord";
            case 10L: return "WordLeft";
            case 11L: return "WordRight";
            case 12L: return "End";
            case 13L: return "EndOfLine";
            case 14L: return "EndOfWord";
            case 15L: return "NextWord";
            case 16L: return "NextBlock";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& MoveOperation() {
        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 stringifyQDocumentCursorMoveOperation(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QDocumentCursor::MoveOperation(i);
        if (retval.empty()) {
            retval = "(QDocumentCursor::MoveOperation)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "QDocumentCursor::MoveOperation::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQDocumentCursorMoveOperation() {
        return stringify::QDocumentCursor::MoveOperation();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 75
namespace stringify { namespace QDocumentCursor {
    const char* SelectionType(int64_t i) {
        switch (i) {
            case 0L: return "WordUnderCursor";
            case 1L: return "LineUnderCursor";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyQDocumentCursorSelectionType() {
        return stringify::QDocumentCursor::SelectionType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 84
namespace stringify { namespace QDocument {
    const char* LineEnding(int64_t i) {
        switch (i) {
            case 0L: return "Conservative";
            case 1L: return "Local";
            case 2L: return "Unix";
            case 3L: return "Windows";
            case 4L: return "Mac";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& LineEnding() {
        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 stringifyQDocumentLineEnding(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QDocument::LineEnding(i);
        if (retval.empty()) {
            retval = "(QDocument::LineEnding)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "QDocument::LineEnding::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQDocumentLineEnding() {
        return stringify::QDocument::LineEnding();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 93
namespace stringify { namespace QDocument {
    const char* TextProcessing(int64_t i) {
        switch (i) {
            case 1L: return "RemoveTrailingWS";
            case 2L: return "PreserveIndent";
            case 4L: return "RestoreTrailingIndent";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyQDocumentTextProcessing() {
        return stringify::QDocument::TextProcessing();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 100
namespace stringify { namespace QDocument {
    const char* WhiteSpaceFlag(int64_t i) {
        switch (i) {
            case 0L: return "ShowNone";
            case 1L: return "ShowTrailing";
            case 2L: return "ShowLeading";
            case 4L: return "ShowTabs";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyQDocumentWhiteSpaceFlag() {
        return stringify::QDocument::WhiteSpaceFlag();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentsearch.h line 40
namespace stringify { namespace QDocumentSearch {
    const char* Option(int64_t i) {
        switch (i) {
            case 1L: return "WholeWords";
            case 2L: return "CaseSensitive";
            case 4L: return "RegExp";
            case 8L: return "Replace";
            case 16L: return "Prompt";
            case 32L: return "Silent";
            case 64L: return "HighlightAll";
            default: return "";
        }
    }

    std::string Option(int64_t i, const std::string &strip) {
        std::string s = Option(i);
        if (s.empty())
            s = "(QDocumentSearch::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>& Option() {
        static const int64_t values[] = {
            1L,
            2L,
            4L,
            8L,
            16L,
            32L,
            64L
        };
        static const std::vector<int64_t> retval(values, values + 7);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyQDocumentSearchOption(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QDocumentSearch::Option(i);
        if (retval.empty()) {
            retval = "(QDocumentSearch::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 = "QDocumentSearch::Option::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQDocumentSearchOption() {
        return stringify::QDocumentSearch::Option();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor_p.h line 52
namespace stringify { namespace QDocumentCursorHandle {
    const char* Flags(int64_t i) {
        switch (i) {
            case 1L: return "Silent";
            case 2L: return "ColumnMemory";
            case 4L: return "MoveWithinWrapped";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyQDocumentCursorHandleFlags() {
        return stringify::QDocumentCursorHandle::Flags();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/AstGraphWidget/DisplayEdge.h line 40
namespace stringify { namespace DisplayEdge {
    const char* PaintMode(int64_t i) {
        switch (i) {
            case 0L: return "STRAIGHT";
            case 1L: return "RECTANGULAR";
            case 2L: return "BEZIER_QUAD";
            case 3L: return "BEZIER_CUBIC";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& PaintMode() {
        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 stringifyDisplayEdgePaintMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::DisplayEdge::PaintMode(i);
        if (retval.empty()) {
            retval = "(DisplayEdge::PaintMode)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "DisplayEdge::PaintMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyDisplayEdgePaintMode() {
        return stringify::DisplayEdge::PaintMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/TaskSystem/CompilerOutputWidget.h line 25
namespace stringify { namespace CompilerOutputWidget {
    const char* PatternType(int64_t i) {
        switch (i) {
            case 0L: return "Unknown";
            case 1L: return "Warning";
            case 2L: return "Error";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyCompilerOutputWidgetPatternType() {
        return stringify::CompilerOutputWidget::PatternType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/TaskSystem/TaskInterface.h line 25
namespace stringify { namespace Task {
    const char* State(int64_t i) {
        switch (i) {
            case 0L: return "BEFORE_START";
            case 1L: return "RUNNING";
            case 2L: return "FINISHED_SUCCESS";
            case 3L: return "FINISHED_ERROR";
            default: return "";
        }
    }

    std::string State(int64_t i, const std::string &strip) {
        std::string s = State(i);
        if (s.empty())
            s = "(Task::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[] = {
            0L,
            1L,
            2L,
            3L
        };
        static const std::vector<int64_t> retval(values, values + 4);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyTaskState(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Task::State(i);
        if (retval.empty()) {
            retval = "(Task::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 = "Task::State::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyTaskState() {
        return stringify::Task::State();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/ProjectManager/DependencyInfo.h line 20
namespace stringify { namespace DependencyInfo {
    const char* State(int64_t i) {
        switch (i) {
            case 0L: return "VALID";
            case 1L: return "INVALID";
            case 2L: return "ERROR";
            default: return "";
        }
    }

    std::string State(int64_t i, const std::string &strip) {
        std::string s = State(i);
        if (s.empty())
            s = "(DependencyInfo::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[] = {
            0L,
            1L,
            2L
        };
        static const std::vector<int64_t> retval(values, values + 3);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyDependencyInfoState(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::DependencyInfo::State(i);
        if (retval.empty()) {
            retval = "(DependencyInfo::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 = "DependencyInfo::State::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyDependencyInfoState() {
        return stringify::DependencyInfo::State();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/util/AstDisplayInfo.h line 14
namespace stringify { namespace AstDisplayInfo {
    const char* NodeType(int64_t i) {
        switch (i) {
            case 0L: return "ROOT";
            case 1L: return "INCLUDE_ROOT";
            case 2L: return "SRC_FILE";
            case 3L: return "INCLUDE_FILE";
            case 4L: return "NAMESPACE";
            case 5L: return "CLASS";
            case 6L: return "FUNCTION";
            case 7L: return "LOOP";
            case 8L: return "UNKNOWN";
            default: return "";
        }
    }

    std::string NodeType(int64_t i, const std::string &strip) {
        std::string s = NodeType(i);
        if (s.empty())
            s = "(AstDisplayInfo::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,
            7L,
            8L
        };
        static const std::vector<int64_t> retval(values, values + 9);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyAstDisplayInfoNodeType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::AstDisplayInfo::NodeType(i);
        if (retval.empty()) {
            retval = "(AstDisplayInfo::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 = "AstDisplayInfo::NodeType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyAstDisplayInfoNodeType() {
        return stringify::AstDisplayInfo::NodeType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QtGradientEditor/qtgradientwidget.cpp line 91
namespace stringify { namespace QtGradientWidgetPrivate {
    const char* Handle(int64_t i) {
        switch (i) {
            case 0L: return "NoHandle";
            case 1L: return "StartLinearHandle";
            case 2L: return "EndLinearHandle";
            case 3L: return "CentralRadialHandle";
            case 4L: return "FocalRadialHandle";
            case 5L: return "RadiusRadialHandle";
            case 6L: return "CentralConicalHandle";
            case 7L: return "AngleConicalHandle";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& Handle() {
        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 stringifyQtGradientWidgetPrivateHandle(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QtGradientWidgetPrivate::Handle(i);
        if (retval.empty()) {
            retval = "(QtGradientWidgetPrivate::Handle)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "QtGradientWidgetPrivate::Handle::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQtGradientWidgetPrivateHandle() {
        return stringify::QtGradientWidgetPrivate::Handle();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/qtWidgets/QtGradientEditor/qtcolorline.h line 62
namespace stringify { namespace QtColorLine {
    const char* ColorComponent(int64_t i) {
        switch (i) {
            case 0L: return "Red";
            case 1L: return "Green";
            case 2L: return "Blue";
            case 3L: return "Hue";
            case 4L: return "Saturation";
            case 5L: return "Value";
            case 6L: return "Alpha";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& ColorComponent() {
        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 stringifyQtColorLineColorComponent(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::QtColorLine::ColorComponent(i);
        if (retval.empty()) {
            retval = "(QtColorLine::ColorComponent)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "QtColorLine::ColorComponent::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyQtColorLineColorComponent() {
        return stringify::QtColorLine::ColorComponent();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/failSafe/failSafePragma.h line 31
namespace stringify { namespace FailSafe {
    const char* fail_safe_enum(int64_t i) {
        switch (i) {
            case 0L: return "e_unknown";
            case 1L: return "e_region";
            case 2L: return "e_status_predicate";
            case 3L: return "e_data_predicate";
            case 4L: return "e_tolerance";
            case 5L: return "e_double_redundancy";
            case 6L: return "e_triple_redundancy";
            case 7L: return "e_save";
            case 8L: return "e_assert";
            case 9L: return "e_specifier";
            case 10L: return "e_region_reference";
            case 11L: return "e_error";
            case 12L: return "e_violation";
            case 13L: return "e_recover";
            case 14L: return "e_pre";
            case 15L: return "e_post";
            case 16L: return "e_type_ET1";
            case 17L: return "e_type_ET2";
            case 18L: return "e_violation_NaN";
            case 19L: return "e_violation_SECDED";
            case 20L: return "e_violation_SEGFAULT";
            case 21L: return "e_violation_ANY";
            case 22L: return "e_not_failsafe";
            default: return "";
        }
    }

    std::string fail_safe_enum(int64_t i, const std::string &strip) {
        std::string s = fail_safe_enum(i);
        if (s.empty())
            s = "(FailSafe::fail_safe_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>& fail_safe_enum() {
        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
        };
        static const std::vector<int64_t> retval(values, values + 23);
        return retval;
    }

}}

namespace Rose {
    std::string stringifyFailSafe_fail_safe_enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::FailSafe::fail_safe_enum(i);
        if (retval.empty()) {
            retval = "(FailSafe::fail_safe_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 = "FailSafe::fail_safe_enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyFailSafe_fail_safe_enum() {
        return stringify::FailSafe::fail_safe_enum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/dataStructureTraversal/exampleTest.C line 3
namespace stringify {
    const char* controlEnum(int64_t i) {
        switch (i) {
            case 0L: return "BEGGINING_OF_ENUM";
            case 1L: return "typeInt";
            case 2L: return "typeChar";
            case 3L: return "typeTestStruct";
            case 4L: return "END_OF_ENUM";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& controlEnum() {
        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 stringify_controlEnum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::controlEnum(i);
        if (retval.empty()) {
            retval = "(controlEnum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "controlEnum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringify_controlEnum() {
        return stringify::controlEnum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/roseExtensions/dataStructureTraversal/GenRepresentation.h line 23
namespace stringify { namespace GenRepresentation {
    const char* TypeOfPrint(int64_t i) {
        switch (i) {
            case 0L: return "UnknownListElement";
            case 1L: return "Container";
            case 2L: return "Contained";
            case 3L: return "END_OF_LIST";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& TypeOfPrint() {
        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 stringifyGenRepresentationTypeOfPrint(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::GenRepresentation::TypeOfPrint(i);
        if (retval.empty()) {
            retval = "(GenRepresentation::TypeOfPrint)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "GenRepresentation::TypeOfPrint::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyGenRepresentationTypeOfPrint() {
        return stringify::GenRepresentation::TypeOfPrint();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 88
namespace stringify {
    const char* ConstructParamEnum(int64_t i) {
        switch (i) {
            case 0L: return "NO_CONSTRUCTOR_PARAMETER";
            case 1L: return "CONSTRUCTOR_PARAMETER";
            default: return "";
        }
    }

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

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

}

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

    const std::vector<int64_t>& stringifyConstructParamEnum() {
        return stringify::ConstructParamEnum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 93
namespace stringify {
    const char* BuildAccessEnum(int64_t i) {
        switch (i) {
            case 0L: return "NO_ACCESS_FUNCTIONS";
            case 1L: return "BUILD_ACCESS_FUNCTIONS";
            case 2L: return "BUILD_FLAG_ACCESS_FUNCTIONS";
            case 3L: return "BUILD_LIST_ACCESS_FUNCTIONS";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& BuildAccessEnum() {
        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 stringifyBuildAccessEnum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::BuildAccessEnum(i);
        if (retval.empty()) {
            retval = "(BuildAccessEnum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "BuildAccessEnum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBuildAccessEnum() {
        return stringify::BuildAccessEnum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 101
namespace stringify {
    const char* CopyConfigEnum(int64_t i) {
        switch (i) {
            case 0L: return "NO_COPY_DATA";
            case 1L: return "COPY_DATA";
            case 2L: return "CLONE_PTR";
            case 3L: return "CLONE_TREE";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& CopyConfigEnum() {
        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 stringifyCopyConfigEnum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::CopyConfigEnum(i);
        if (retval.empty()) {
            retval = "(CopyConfigEnum)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "CopyConfigEnum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyCopyConfigEnum() {
        return stringify::CopyConfigEnum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 122
namespace stringify {
    const char* TraversalEnum(int64_t i) {
        switch (i) {
            case 0L: return "DEF_TRAVERSAL";
            case 1L: return "NO_TRAVERSAL";
            default: return "";
        }
    }

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

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

}

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

    const std::vector<int64_t>& stringifyTraversalEnum() {
        return stringify::TraversalEnum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/grammar.h line 127
namespace stringify {
    const char* DeleteEnum(int64_t i) {
        switch (i) {
            case 0L: return "DEF_DELETE";
            case 1L: return "NO_DELETE";
            default: return "";
        }
    }

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

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

}

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

    const std::vector<int64_t>& stringifyDeleteEnum() {
        return stringify::DeleteEnum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 100
namespace stringify { namespace AstNodeClass {
    const char* locationInTree(int64_t i) {
        switch (i) {
            case 0L: return "LOCAL_LIST";
            case 1L: return "SUBTREE_LIST";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyAstNodeClass_locationInTree() {
        return stringify::AstNodeClass::locationInTree();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 106
namespace stringify { namespace AstNodeClass {
    const char* includeExcludeMechanism(int64_t i) {
        switch (i) {
            case 0L: return "INCLUDE_LIST";
            case 1L: return "EXCLUDE_LIST";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyAstNodeClass_includeExcludeMechanism() {
        return stringify::AstNodeClass::includeExcludeMechanism();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/AstNodeClass.h line 309
namespace stringify { namespace AstNodeClass {
    const char* TypeEvaluation(int64_t i) {
        switch (i) {
            case 0L: return "CHAR_POINTER";
            case 1L: return "CONST_CHAR_POINTER";
            case 2L: return "ATTACHEDPREPROCESSINGINFOTYPE";
            case 3L: return "ROSE_HASH_MULTIMAP";
            case 4L: return "ROSE_GRAPH_HASH_MULTIMAP";
            case 5L: return "ROSE_GRAPH_DIRECTED_EDGE_HASH_MULTIMAP";
            case 6L: return "ROSE_GRAPH_UNDIRECTED_EDGE_HASH_MULTIMAP";
            case 7L: return "ROSE_GRAPH_NODE_EDGE_HASH_MULTIMAP";
            case 8L: return "ROSE_GRAPH_INTEGER_NODE_HASH_MAP";
            case 9L: return "ROSE_GRAPH_INTEGER_EDGE_HASH_MAP";
            case 10L: return "ROSE_GRAPH_STRING_INTEGER_HASH_MULTIMAP";
            case 11L: return "ROSE_GRAPH_INTEGER_PAIR_EDGE_HASH_MULTIMAP";
            case 12L: return "ROSE_GRAPH_INTEGER_EDGE_HASH_MULTIMAP";
            case 13L: return "SGCLASS_POINTER";
            case 14L: return "ROSEATTRUBUTESLISTCONTAINER";
            case 15L: return "SGCLASS_POINTER_LIST";
            case 16L: return "SGCLASS_POINTER_VECTOR";
            case 17L: return "SGCLASS_POINTER_VECTOR_NAMED_LIST";
            case 18L: return "STL_CONTAINER";
            case 19L: return "STL_SET";
            case 20L: return "STL_MULTIMAP";
            case 21L: return "STL_MAP";
            case 22L: return "STRING";
            case 23L: return "SGNAME";
            case 24L: return "BIT_VECTOR";
            case 25L: return "MODIFIERCLASS";
            case 26L: return "MODIFIERCLASS_WITHOUTEASYSTORAGE";
            case 27L: return "ASTATTRIBUTEMECHANISM";
            case 28L: return "TO_HANDLE";
            case 29L: return "OSTREAM";
            case 30L: return "ENUM_TYPE";
            case 31L: return "BASIC_DATA_TYPE";
            case 32L: return "SKIP_TYPE";
            case 33L: return "SGCLASS_POINTER_LIST_POINTER";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& TypeEvaluation() {
        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
        };
        static const std::vector<int64_t> retval(values, values + 34);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifyAstNodeClassTypeEvaluation() {
        return stringify::AstNodeClass::TypeEvaluation();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 2643
namespace stringify { namespace SgAsmRiscOperation {
    const char* RiscOperator(int64_t i) {
        switch (i) {
            case 0L: return "OP_NONE";
            case 1L: return "OP_bottom";
            case 2L: return "OP_undefined";
            case 3L: return "OP_unspecified";
            case 4L: return "OP_filterCallTarget";
            case 5L: return "OP_filterReturnTarget";
            case 6L: return "OP_filterIndirectJumpTarget";
            case 7L: return "OP_hlt";
            case 8L: return "OP_cpuid";
            case 9L: return "OP_rdtsc";
            case 10L: return "OP_and_";
            case 11L: return "OP_or_";
            case 12L: return "OP_xor_";
            case 13L: return "OP_invert";
            case 14L: return "OP_extract";
            case 15L: return "OP_concat";
            case 16L: return "OP_leastSignificantSetBit";
            case 17L: return "OP_mostSignificantSetBit";
            case 18L: return "OP_rotateLeft";
            case 19L: return "OP_rotateRight";
            case 20L: return "OP_shiftLeft";
            case 21L: return "OP_shiftRight";
            case 22L: return "OP_shiftRightArithmetic";
            case 23L: return "OP_equalToZero";
            case 24L: return "OP_ite";
            case 25L: return "OP_isEqual";
            case 26L: return "OP_isNotEqual";
            case 27L: return "OP_isUnsignedLessThan";
            case 28L: return "OP_isUnsignedLessThanOrEqual";
            case 29L: return "OP_isUnsignedGreaterThan";
            case 30L: return "OP_isUnsignedGreaterThanOrEqual";
            case 31L: return "OP_isSignedLessThan";
            case 32L: return "OP_isSignedLessThanOrEqual";
            case 33L: return "OP_isSignedGreaterThan";
            case 34L: return "OP_isSignedGreaterThanOrEqual";
            case 35L: return "OP_unsignedExtend";
            case 36L: return "OP_signExtend";
            case 37L: return "OP_add";
            case 38L: return "OP_addCarries";
            case 39L: return "OP_subtract";
            case 40L: return "OP_negate";
            case 41L: return "OP_signedDivide";
            case 42L: return "OP_signedModulo";
            case 43L: return "OP_signedMultiply";
            case 44L: return "OP_unsignedDivide";
            case 45L: return "OP_unsignedModulo";
            case 46L: return "OP_unsignedMultiply";
            case 47L: return "OP_interrupt";
            case 48L: return "OP_readRegister";
            case 49L: return "OP_peekRegister";
            case 50L: return "OP_writeRegister";
            case 51L: return "OP_readMemory";
            case 52L: return "OP_peekMemory";
            case 53L: return "OP_writeMemory";
            case 54L: return "OP_N_OPERATORS";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& RiscOperator() {
        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
        };
        static const std::vector<int64_t> retval(values, values + 55);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmRiscOperationRiscOperator() {
        return stringify::SgAsmRiscOperation::RiscOperator();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 3459
namespace stringify { namespace SgAsmFunction {
    const char* MayReturn(int64_t i) {
        switch (i) {
            case 0L: return "RET_UNKNOWN";
            case 1L: return "RET_NEVER";
            case 2L: return "RET_SOMETIMES";
            case 3L: return "RET_ALWAYS";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& MayReturn() {
        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 stringifySgAsmFunctionMayReturn(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmFunction::MayReturn(i);
        if (retval.empty()) {
            retval = "(SgAsmFunction::MayReturn)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SgAsmFunction::MayReturn::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmFunctionMayReturn() {
        return stringify::SgAsmFunction::MayReturn();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 3469
namespace stringify { namespace SgAsmFunction {
    const char* FunctionReason(int64_t i) {
        switch (i) {
            case 0L: return "FUNC_NONE";
            case 1L: return "FUNC_INTERPADFUNC";
            case 2L: return "FUNC_PESCRAMBLER_DISPATCH";
            case 3L: return "FUNC_CONFIGURED";
            case 4L: return "FUNC_CMDLINE";
            case 5L: return "FUNC_SCAN_RO_DATA";
            case 6L: return "FUNC_INSN_RO_DATA";
            case 255L: return "FUNC_MISCMASK";
            case 16384L: return "FUNC_THUNK_TARGET";
            case 32768L: return "FUNC_EXCEPTION_HANDLER";
            case 65536L: return "FUNC_ENTRY_POINT";
            case 131072L: return "FUNC_CALL_TARGET";
            case 262144L: return "FUNC_CALL_INSN";
            case 524288L: return "FUNC_EH_FRAME";
            case 1048576L: return "FUNC_SYMBOL";
            case 2097152L: return "FUNC_PATTERN";
            case 4194304L: return "FUNC_GRAPH";
            case 8388608L: return "FUNC_USERDEF";
            case 16777216L: return "FUNC_PADDING";
            case 33554432L: return "FUNC_DISCONT";
            case 67108864L: return "FUNC_INSNHEAD";
            case 134217728L: return "FUNC_IMPORT";
            case 268435456L: return "FUNC_LEFTOVERS";
            case 536870912L: return "FUNC_INTRABLOCK";
            case 1073741824L: return "FUNC_THUNK";
            case 2147483648L: return "FUNC_EXPORT";
            case 4026499327L: return "FUNC_DEFAULT";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& FunctionReason() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            255L,
            16384L,
            32768L,
            65536L,
            131072L,
            262144L,
            524288L,
            1048576L,
            2097152L,
            4194304L,
            8388608L,
            16777216L,
            33554432L,
            67108864L,
            134217728L,
            268435456L,
            536870912L,
            1073741824L,
            2147483648L,
            4026499327L
        };
        static const std::vector<int64_t> retval(values, values + 27);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmFunctionFunctionReason() {
        return stringify::SgAsmFunction::FunctionReason();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 3625
namespace stringify { namespace SgAsmFunction {
    const char* function_kind_enum(int64_t i) {
        switch (i) {
            case 0L: return "e_unknown";
            case 1L: return "e_standard";
            case 2L: return "e_library";
            case 3L: return "e_imported";
            case 4L: return "e_thunk";
            case 5L: return "e_last";
            default: return "";
        }
    }

    std::string function_kind_enum(int64_t i, const std::string &strip) {
        std::string s = function_kind_enum(i);
        if (s.empty())
            s = "(SgAsmFunction::function_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>& function_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 stringifySgAsmFunction_function_kind_enum(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmFunction::function_kind_enum(i);
        if (retval.empty()) {
            retval = "(SgAsmFunction::function_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 = "SgAsmFunction::function_kind_enum::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmFunction_function_kind_enum() {
        return stringify::SgAsmFunction::function_kind_enum();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 3857
namespace stringify { namespace SgAsmBlock {
    const char* Reason(int64_t i) {
        switch (i) {
            case 0L: return "BLK_NONE";
            case 1L: return "BLK_FINDDATA";
            case 2L: return "BLK_POSTFUNC";
            case 255L: return "BLK_MISCMASK";
            case 65536L: return "BLK_ENTRY_POINT";
            case 131072L: return "BLK_PADDING";
            case 524288L: return "BLK_FRAGMENT";
            case 1048576L: return "BLK_CFGHEAD";
            case 2097152L: return "BLK_USERDEF";
            case 4194304L: return "BLK_LEFTOVERS";
            case 8388608L: return "BLK_JUMPTABLE";
            case 16777216L: return "BLK_GRAPH1";
            case 33554432L: return "BLK_GRAPH2";
            case 67108864L: return "BLK_GRAPH3";
            default: return "";
        }
    }

    std::string Reason(int64_t i, const std::string &strip) {
        std::string s = Reason(i);
        if (s.empty())
            s = "(SgAsmBlock::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,
            255L,
            65536L,
            131072L,
            524288L,
            1048576L,
            2097152L,
            4194304L,
            8388608L,
            16777216L,
            33554432L,
            67108864L
        };
        static const std::vector<int64_t> retval(values, values + 14);
        return retval;
    }

}}

namespace Rose {
    std::string stringifySgAsmBlockReason(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmBlock::Reason(i);
        if (retval.empty()) {
            retval = "(SgAsmBlock::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 = "SgAsmBlock::Reason::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmBlockReason() {
        return stringify::SgAsmBlock::Reason();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 4708
namespace stringify { namespace SgAsmElfFileHeader {
    const char* ObjectType(int64_t i) {
        switch (i) {
            case 0L: return "ET_NONE";
            case 1L: return "ET_REL";
            case 2L: return "ET_EXEC";
            case 3L: return "ET_DYN";
            case 4L: return "ET_CORE";
            case 65024L: return "ET_LOOS";
            case 65279L: return "ET_HIOS";
            case 65280L: return "ET_LOPROC";
            case 65535L: return "ET_HIPROC";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifySgAsmElfFileHeaderObjectType() {
        return stringify::SgAsmElfFileHeader::ObjectType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5128
namespace stringify { namespace SgAsmElfSectionTableEntry {
    const char* SectionType(int64_t i) {
        switch (i) {
            case 0L: return "SHT_NULL";
            case 1L: return "SHT_PROGBITS";
            case 2L: return "SHT_SYMTAB";
            case 3L: return "SHT_STRTAB";
            case 4L: return "SHT_RELA";
            case 5L: return "SHT_HASH";
            case 6L: return "SHT_DYNAMIC";
            case 7L: return "SHT_NOTE";
            case 8L: return "SHT_NOBITS";
            case 9L: return "SHT_REL";
            case 10L: return "SHT_SHLIB";
            case 11L: return "SHT_DYNSYM";
            case 1610612736L: return "SHT_LOOS";
            case 1879048189L: return "SHT_GNU_verdef";
            case 1879048190L: return "SHT_GNU_verneed";
            case 1879048191L: return "SHT_GNU_versym";
            case 1879048192L: return "SHT_LOPROC";
            case 2147483647L: return "SHT_HIPROC";
            case 2147483648L: return "SHT_LOUSER";
            case 4294967295L: return "SHT_HIUSER";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& SectionType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            8L,
            9L,
            10L,
            11L,
            1610612736L,
            1879048189L,
            1879048190L,
            1879048191L,
            1879048192L,
            2147483647L,
            2147483648L,
            4294967295L
        };
        static const std::vector<int64_t> retval(values, values + 20);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionType() {
        return stringify::SgAsmElfSectionTableEntry::SectionType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5155
namespace stringify { namespace SgAsmElfSectionTableEntry {
    const char* SectionFlags(int64_t i) {
        switch (i) {
            case 0L: return "SHF_NULL";
            case 1L: return "SHF_WRITE";
            case 2L: return "SHF_ALLOC";
            case 4L: return "SHF_EXECINSTR";
            case 16L: return "SHF_MERGE";
            case 32L: return "SHF_STRINGS";
            case 64L: return "SHF_INFO_LINK";
            case 128L: return "SHF_LINK_ORDER";
            case 256L: return "SHF_OS_NONCONFORMING";
            case 512L: return "SHF_GROUP";
            case 1024L: return "SHF_TLS";
            case 267386880L: return "SHF_MASKOS";
            case 4026531840L: return "SHF_MASKPROC";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& SectionFlags() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            4L,
            16L,
            32L,
            64L,
            128L,
            256L,
            512L,
            1024L,
            267386880L,
            4026531840L
        };
        static const std::vector<int64_t> retval(values, values + 13);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionFlags() {
        return stringify::SgAsmElfSectionTableEntry::SectionFlags();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5557
namespace stringify { namespace SgAsmElfSegmentTableEntry {
    const char* SegmentType(int64_t i) {
        switch (i) {
            case 0L: return "PT_NULL";
            case 1L: return "PT_LOAD";
            case 2L: return "PT_DYNAMIC";
            case 3L: return "PT_INTERP";
            case 4L: return "PT_NOTE";
            case 5L: return "PT_SHLIB";
            case 6L: return "PT_PHDR";
            case 7L: return "PT_TLS";
            case 1610612736L: return "PT_LOOS";
            case 1685382480L: return "PT_GNU_EH_FRAME";
            case 1685382481L: return "PT_GNU_STACK";
            case 1685382482L: return "PT_GNU_RELRO";
            case 1694766464L: return "PT_PAX_FLAGS";
            case 1879048186L: return "PT_SUNWBSS";
            case 1879048187L: return "PT_SUNWSTACK";
            case 1879048191L: return "PT_HIOS";
            case 1879048192L: return "PT_LOPROC";
            case 2147483647L: return "PT_HIPROC";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& SegmentType() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            3L,
            4L,
            5L,
            6L,
            7L,
            1610612736L,
            1685382480L,
            1685382481L,
            1685382482L,
            1694766464L,
            1879048186L,
            1879048187L,
            1879048191L,
            1879048192L,
            2147483647L
        };
        static const std::vector<int64_t> retval(values, values + 18);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentType() {
        return stringify::SgAsmElfSegmentTableEntry::SegmentType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5585
namespace stringify { namespace SgAsmElfSegmentTableEntry {
    const char* SegmentFlags(int64_t i) {
        switch (i) {
            case 0L: return "PF_NONE";
            case 1L: return "PF_XPERM";
            case 2L: return "PF_WPERM";
            case 4L: return "PF_RPERM";
            case 1048568L: return "PF_RESERVED";
            case 267386880L: return "PF_OS_MASK";
            case 4026531840L: return "PF_PROC_MASK";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& SegmentFlags() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            4L,
            1048568L,
            267386880L,
            4026531840L
        };
        static const std::vector<int64_t> retval(values, values + 7);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentFlags() {
        return stringify::SgAsmElfSegmentTableEntry::SegmentFlags();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5931
namespace stringify { namespace SgAsmElfSymbol {
    const char* ElfSymBinding(int64_t i) {
        switch (i) {
            case 0L: return "STB_LOCAL";
            case 1L: return "STB_GLOBAL";
            case 2L: return "STB_WEAK";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymBinding() {
        return stringify::SgAsmElfSymbol::ElfSymBinding();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 5937
namespace stringify { namespace SgAsmElfSymbol {
    const char* ElfSymType(int64_t i) {
        switch (i) {
            case 0L: return "STT_NOTYPE";
            case 1L: return "STT_OBJECT";
            case 2L: return "STT_FUNC";
            case 3L: return "STT_SECTION";
            case 4L: return "STT_FILE";
            case 5L: return "STT_COMMON";
            case 6L: return "STT_TLS";
            case 10L: return "STT_IFUNC";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymType() {
        return stringify::SgAsmElfSymbol::ElfSymType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 7339
namespace stringify { namespace SgAsmElfRelocEntry {
    const char* RelocType(int64_t i) {
        switch (i) {
            case 0L: return "R_386_NONE";
            case 1L: return "R_386_32";
            case 2L: return "R_386_PC32";
            case 3L: return "R_386_GOT32";
            case 4L: return "R_386_PLT32";
            case 5L: return "R_386_COPY";
            case 6L: return "R_386_GLOB_DAT";
            case 7L: return "R_386_JMP_SLOT";
            case 8L: return "R_386_RELATIVE";
            case 9L: return "R_386_GOTOFF";
            case 10L: return "R_386_GOTPC";
            case 11L: return "R_386_32PLT";
            case 14L: return "R_386_TLS_TPOFF";
            case 15L: return "R_386_TLS_IE";
            case 16L: return "R_386_TLS_GOTIE";
            case 17L: return "R_386_TLS_LE";
            case 18L: return "R_386_TLS_GD";
            case 19L: return "R_386_TLS_LDM";
            case 20L: return "R_386_16";
            case 21L: return "R_386_PC16";
            case 22L: return "R_386_8";
            case 23L: return "R_386_PC8";
            case 24L: return "R_386_TLS_GD_32";
            case 25L: return "R_386_TLS_GD_PUSH";
            case 26L: return "R_386_TLS_GD_CALL";
            case 27L: return "R_386_TLS_GD_POP";
            case 28L: return "R_386_TLS_LDM_32";
            case 29L: return "R_386_TLS_LDM_PUSH";
            case 30L: return "R_386_TLS_LDM_CALL";
            case 31L: return "R_386_TLS_LDM_POP";
            case 32L: return "R_386_TLS_LDO_32";
            case 33L: return "R_386_TLS_IE_32";
            case 34L: return "R_386_TLS_LE_32";
            case 35L: return "R_386_TLS_DTPMOD32";
            case 36L: return "R_386_TLS_DTPOFF32";
            case 37L: return "R_386_TLS_TPOFF32";
            case 100L: return "R_X86_64_NONE";
            case 101L: return "R_X86_64_64";
            case 102L: return "R_X86_64_PC32";
            case 103L: return "R_X86_64_GOT32";
            case 104L: return "R_X86_64_PLT32";
            case 105L: return "R_X86_64_COPY";
            case 106L: return "R_X86_64_GLOB_DAT";
            case 107L: return "R_X86_64_JUMP_SLOT";
            case 108L: return "R_X86_64_RELATIVE";
            case 109L: return "R_X86_64_GOTPCREL";
            case 110L: return "R_X86_64_32";
            case 111L: return "R_X86_64_32S";
            case 112L: return "R_X86_64_16";
            case 113L: return "R_X86_64_PC16";
            case 114L: return "R_X86_64_8";
            case 115L: return "R_X86_64_PC8";
            case 116L: return "R_X86_64_DTPMOD64";
            case 117L: return "R_X86_64_DTPOFF64";
            case 118L: return "R_X86_64_TPOFF64";
            case 119L: return "R_X86_64_TLSGD";
            case 120L: return "R_X86_64_TLSLD";
            case 121L: return "R_X86_64_DTPOFF32";
            case 122L: return "R_X86_64_GOTTPOFF";
            case 123L: return "R_X86_64_TPOFF32";
            default: return "";
        }
    }

    std::string RelocType(int64_t i, const std::string &strip) {
        std::string s = RelocType(i);
        if (s.empty())
            s = "(SgAsmElfRelocEntry::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,
            8L,
            9L,
            10L,
            11L,
            14L,
            15L,
            16L,
            17L,
            18L,
            19L,
            20L,
            21L,
            22L,
            23L,
            24L,
            25L,
            26L,
            27L,
            28L,
            29L,
            30L,
            31L,
            32L,
            33L,
            34L,
            35L,
            36L,
            37L,
            100L,
            101L,
            102L,
            103L,
            104L,
            105L,
            106L,
            107L,
            108L,
            109L,
            110L,
            111L,
            112L,
            113L,
            114L,
            115L,
            116L,
            117L,
            118L,
            119L,
            120L,
            121L,
            122L,
            123L
        };
        static const std::vector<int64_t> retval(values, values + 60);
        return retval;
    }

}}

namespace Rose {
    std::string stringifySgAsmElfRelocEntryRelocType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmElfRelocEntry::RelocType(i);
        if (retval.empty()) {
            retval = "(SgAsmElfRelocEntry::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 = "SgAsmElfRelocEntry::RelocType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmElfRelocEntryRelocType() {
        return stringify::SgAsmElfRelocEntry::RelocType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 7696
namespace stringify { namespace SgAsmElfDynamicEntry {
    const char* EntryType(int64_t i) {
        switch (i) {
            case 0L: return "DT_NULL";
            case 1L: return "DT_NEEDED";
            case 2L: return "DT_PLTRELSZ";
            case 3L: return "DT_PLTGOT";
            case 4L: return "DT_HASH";
            case 5L: return "DT_STRTAB";
            case 6L: return "DT_SYMTAB";
            case 7L: return "DT_RELA";
            case 8L: return "DT_RELASZ";
            case 9L: return "DT_RELAENT";
            case 10L: return "DT_STRSZ";
            case 11L: return "DT_SYMENT";
            case 12L: return "DT_INIT";
            case 13L: return "DT_FINI";
            case 14L: return "DT_SONAME";
            case 15L: return "DT_RPATH";
            case 16L: return "DT_SYMBOLIC";
            case 17L: return "DT_REL";
            case 18L: return "DT_RELSZ";
            case 19L: return "DT_RELENT";
            case 20L: return "DT_PLTREL";
            case 21L: return "DT_DEBUG";
            case 22L: return "DT_TEXTREL";
            case 23L: return "DT_JMPREL";
            case 24L: return "DT_BIND_NOW";
            case 25L: return "DT_INIT_ARRAY";
            case 26L: return "DT_FINI_ARRAY";
            case 27L: return "DT_INIT_ARRAYSZ";
            case 28L: return "DT_FINI_ARRAYSZ";
            case 29L: return "DT_RUNPATH";
            case 30L: return "DT_FLAGS";
            case 32L: return "DT_PREINIT_ARRAY";
            case 33L: return "DT_PREINIT_ARRAYSZ";
            case 34L: return "DT_NUM";
            case 1879047669L: return "DT_GNU_PRELINKED";
            case 1879047670L: return "DT_GNU_CONFLICTSZ";
            case 1879047671L: return "DT_GNU_LIBLISTSZ";
            case 1879047672L: return "DT_CHECKSUM";
            case 1879047673L: return "DT_PLTPADSZ";
            case 1879047674L: return "DT_MOVEENT";
            case 1879047675L: return "DT_MOVESZ";
            case 1879047676L: return "DT_FEATURE_1";
            case 1879047677L: return "DT_POSFLAG_1";
            case 1879047678L: return "DT_SYMINSZ";
            case 1879047679L: return "DT_SYMINENT";
            case 1879047925L: return "DT_GNU_HASH";
            case 1879047926L: return "DT_TLSDESC_PLT";
            case 1879047927L: return "DT_TLSDESC_GOT";
            case 1879047928L: return "DT_GNU_CONFLICT";
            case 1879047929L: return "DT_GNU_LIBLIST";
            case 1879047930L: return "DT_CONFIG";
            case 1879047931L: return "DT_DEPAUDIT";
            case 1879047932L: return "DT_AUDIT";
            case 1879047933L: return "DT_PLTPAD";
            case 1879047934L: return "DT_MOVETAB";
            case 1879047935L: return "DT_SYMINFO";
            case 1879048176L: return "DT_VERSYM";
            case 1879048185L: return "DT_RELACOUNT";
            case 1879048186L: return "DT_RELCOUNT";
            case 1879048187L: return "DT_FLAGS_1";
            case 1879048188L: return "DT_VERDEF";
            case 1879048189L: return "DT_VERDEFNUM";
            case 1879048190L: return "DT_VERNEED";
            case 1879048191L: return "DT_VERNEEDNUM";
            case 2147483645L: return "DT_AUXILIARY";
            case 2147483647L: return "DT_FILTER";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& EntryType() {
        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,
            32L,
            33L,
            34L,
            1879047669L,
            1879047670L,
            1879047671L,
            1879047672L,
            1879047673L,
            1879047674L,
            1879047675L,
            1879047676L,
            1879047677L,
            1879047678L,
            1879047679L,
            1879047925L,
            1879047926L,
            1879047927L,
            1879047928L,
            1879047929L,
            1879047930L,
            1879047931L,
            1879047932L,
            1879047933L,
            1879047934L,
            1879047935L,
            1879048176L,
            1879048185L,
            1879048186L,
            1879048187L,
            1879048188L,
            1879048189L,
            1879048190L,
            1879048191L,
            2147483645L,
            2147483647L
        };
        static const std::vector<int64_t> retval(values, values + 66);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmElfDynamicEntryEntryType() {
        return stringify::SgAsmElfDynamicEntry::EntryType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 10195
namespace stringify { namespace SgAsmPEFileHeader {
    const char* HeaderFlags(int64_t i) {
        switch (i) {
            case 0L: return "HF_PROGRAM";
            case 2L: return "HF_EXECUTABLE";
            case 512L: return "HF_FIXED";
            case 8192L: return "HF_LIBRARY";
            case 56829L: return "HF_RESERVED_MASK";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& HeaderFlags() {
        static const int64_t values[] = {
            0L,
            2L,
            512L,
            8192L,
            56829L
        };
        static const std::vector<int64_t> retval(values, values + 5);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmPEFileHeaderHeaderFlags() {
        return stringify::SgAsmPEFileHeader::HeaderFlags();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 10204
namespace stringify { namespace SgAsmPEFileHeader {
    const char* Subsystem(int64_t i) {
        switch (i) {
            case 0L: return "HF_SPEC_UNKNOWN";
            case 1L: return "HF_NATIVE";
            case 2L: return "HF_WINGUI";
            case 3L: return "HF_WINCHAR";
            case 5L: return "HF_OS2CHAR";
            case 7L: return "HF_POSIX";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifySgAsmPEFileHeaderSubsystem() {
        return stringify::SgAsmPEFileHeader::Subsystem();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 10214
namespace stringify { namespace SgAsmPEFileHeader {
    const char* DLLFlags(int64_t i) {
        switch (i) {
            case 1L: return "DLL_PROC_INIT";
            case 2L: return "DLL_PROC_TERM";
            case 4L: return "DLL_THRD_INIT";
            case 8L: return "DLL_THRD_TERM";
            case 65520L: return "DLL_RESERVED_MASK";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifySgAsmPEFileHeaderDLLFlags() {
        return stringify::SgAsmPEFileHeader::DLLFlags();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 10223
namespace stringify { namespace SgAsmPEFileHeader {
    const char* PairPurpose(int64_t i) {
        switch (i) {
            case 0L: return "PAIR_EXPORTS";
            case 1L: return "PAIR_IMPORTS";
            case 2L: return "PAIR_RESOURCES";
            case 3L: return "PAIR_EXCEPTIONS";
            case 4L: return "PAIR_CERTIFICATES";
            case 5L: return "PAIR_BASERELOCS";
            case 6L: return "PAIR_DEBUG";
            case 7L: return "PAIR_ARCHITECTURE";
            case 8L: return "PAIR_GLOBALPTR";
            case 9L: return "PAIR_TLS";
            case 10L: return "PAIR_LOADCONFIG";
            case 11L: return "PAIR_BOUNDIMPORT";
            case 12L: return "PAIR_IAT";
            case 13L: return "PAIR_DELAYIMPORT";
            case 14L: return "PAIR_CLRRUNTIME";
            case 15L: return "PAIR_RESERVED15";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& PairPurpose() {
        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 stringifySgAsmPEFileHeaderPairPurpose(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmPEFileHeader::PairPurpose(i);
        if (retval.empty()) {
            retval = "(SgAsmPEFileHeader::PairPurpose)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SgAsmPEFileHeader::PairPurpose::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmPEFileHeaderPairPurpose() {
        return stringify::SgAsmPEFileHeader::PairPurpose();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 12004
namespace stringify { namespace SgAsmPESectionTableEntry {
    const char* PESectionFlags(int64_t i) {
        switch (i) {
            case 32L: return "OF_CODE";
            case 64L: return "OF_IDATA";
            case 128L: return "OF_UDATA";
            case 512L: return "OF_INFO";
            case 2048L: return "OF_REMOVE";
            case 4096L: return "OF_COMDAT";
            case 16384L: return "OF_NO_DEFER_SPEC_EXC";
            case 32768L: return "OF_GPREL";
            case 1048576L: return "OF_ALIGN_1";
            case 2097152L: return "OF_ALIGN_2";
            case 3145728L: return "OF_ALIGN_4";
            case 4194304L: return "OF_ALIGN_8";
            case 5242880L: return "OF_ALIGN_16";
            case 6291456L: return "OF_ALIGN_32";
            case 7340032L: return "OF_ALIGN_64";
            case 8388608L: return "OF_ALIGN_128";
            case 9437184L: return "OF_ALIGN_256";
            case 10485760L: return "OF_ALIGN_512";
            case 11534336L: return "OF_ALIGN_1k";
            case 12582912L: return "OF_ALIGN_2k";
            case 13631488L: return "OF_ALIGN_4k";
            case 14680064L: return "OF_ALIGN_8k";
            case 15728640L: return "OF_ALIGN_MASK";
            case 16777216L: return "OF_NRELOC_OVFL";
            case 33554432L: return "OF_DISCARDABLE";
            case 67108864L: return "OF_NO_CACHE";
            case 134217728L: return "OF_NO_PAGING";
            case 268435456L: return "OF_SHARED";
            case 536870912L: return "OF_EXECUTABLE";
            case 1073741824L: return "OF_READABLE";
            case 2147483648L: return "OF_WRITABLE";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& PESectionFlags() {
        static const int64_t values[] = {
            32L,
            64L,
            128L,
            512L,
            2048L,
            4096L,
            16384L,
            32768L,
            1048576L,
            2097152L,
            3145728L,
            4194304L,
            5242880L,
            6291456L,
            7340032L,
            8388608L,
            9437184L,
            10485760L,
            11534336L,
            12582912L,
            13631488L,
            14680064L,
            15728640L,
            16777216L,
            33554432L,
            67108864L,
            134217728L,
            268435456L,
            536870912L,
            1073741824L,
            2147483648L
        };
        static const std::vector<int64_t> retval(values, values + 31);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmPESectionTableEntryPESectionFlags() {
        return stringify::SgAsmPESectionTableEntry::PESectionFlags();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 14032
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolDefState(int64_t i) {
        switch (i) {
            case 0L: return "SYM_UNDEFINED";
            case 1L: return "SYM_TENTATIVE";
            case 2L: return "SYM_DEFINED";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolDefState() {
        return stringify::SgAsmGenericSymbol::SymbolDefState();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 14039
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolType(int64_t i) {
        switch (i) {
            case 0L: return "SYM_NO_TYPE";
            case 1L: return "SYM_DATA";
            case 2L: return "SYM_FUNC";
            case 3L: return "SYM_SECTION";
            case 4L: return "SYM_FILE";
            case 5L: return "SYM_ARRAY";
            case 6L: return "SYM_TLS";
            case 7L: return "SYM_REGISTER";
            case 8L: return "SYM_COMMON";
            case 9L: return "SYM_IFUNC";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& SymbolType() {
        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 stringifySgAsmGenericSymbolSymbolType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmGenericSymbol::SymbolType(i);
        if (retval.empty()) {
            retval = "(SgAsmGenericSymbol::SymbolType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SgAsmGenericSymbol::SymbolType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolType() {
        return stringify::SgAsmGenericSymbol::SymbolType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 14053
namespace stringify { namespace SgAsmGenericSymbol {
    const char* SymbolBinding(int64_t i) {
        switch (i) {
            case 0L: return "SYM_NO_BINDING";
            case 1L: return "SYM_LOCAL";
            case 2L: return "SYM_GLOBAL";
            case 3L: return "SYM_WEAK";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& SymbolBinding() {
        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 stringifySgAsmGenericSymbolSymbolBinding(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmGenericSymbol::SymbolBinding(i);
        if (retval.empty()) {
            retval = "(SgAsmGenericSymbol::SymbolBinding)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SgAsmGenericSymbol::SymbolBinding::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolBinding() {
        return stringify::SgAsmGenericSymbol::SymbolBinding();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 14586
namespace stringify { namespace SgAsmGenericSection {
    const char* SectionPurpose(int64_t i) {
        switch (i) {
            case 0L: return "SP_UNSPECIFIED";
            case 1L: return "SP_PROGRAM";
            case 2L: return "SP_HEADER";
            case 3L: return "SP_SYMTAB";
            case 4L: return "SP_OTHER";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& SectionPurpose() {
        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 stringifySgAsmGenericSectionSectionPurpose(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmGenericSection::SectionPurpose(i);
        if (retval.empty()) {
            retval = "(SgAsmGenericSection::SectionPurpose)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SgAsmGenericSection::SectionPurpose::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmGenericSectionSectionPurpose() {
        return stringify::SgAsmGenericSection::SectionPurpose();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15423
namespace stringify { namespace SgAsmGenericFile {
    const char* AddressSpace(int64_t i) {
        switch (i) {
            case 1L: return "ADDRSP_MEMORY";
            case 2L: return "ADDRSP_FILE";
            case 3L: return "ADDRSP_ALL";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifySgAsmGenericFileAddressSpace() {
        return stringify::SgAsmGenericFile::AddressSpace();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15430
namespace stringify { namespace SgAsmGenericFile {
    const char* Elasticity(int64_t i) {
        switch (i) {
            case 0L: return "ELASTIC_NONE";
            case 1L: return "ELASTIC_UNREF";
            case 2L: return "ELASTIC_HOLE";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifySgAsmGenericFileElasticity() {
        return stringify::SgAsmGenericFile::Elasticity();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15830
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecFamily(int64_t i) {
        switch (i) {
            case 0L: return "FAMILY_UNSPECIFIED";
            case 1L: return "FAMILY_DOS";
            case 2L: return "FAMILY_ELF";
            case 3L: return "FAMILY_LE";
            case 4L: return "FAMILY_LX";
            case 5L: return "FAMILY_NE";
            case 6L: return "FAMILY_PE";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& ExecFamily() {
        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 stringifySgAsmExecutableFileFormatExecFamily(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmExecutableFileFormat::ExecFamily(i);
        if (retval.empty()) {
            retval = "(SgAsmExecutableFileFormat::ExecFamily)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SgAsmExecutableFileFormat::ExecFamily::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecFamily() {
        return stringify::SgAsmExecutableFileFormat::ExecFamily();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15841
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecABI(int64_t i) {
        switch (i) {
            case 0L: return "ABI_UNSPECIFIED";
            case 1L: return "ABI_OTHER";
            case 2L: return "ABI_86OPEN";
            case 3L: return "ABI_AIX";
            case 4L: return "ABI_ARM";
            case 5L: return "ABI_FREEBSD";
            case 6L: return "ABI_HPUX";
            case 7L: return "ABI_IRIX";
            case 8L: return "ABI_HURD";
            case 9L: return "ABI_LINUX";
            case 10L: return "ABI_MODESTO";
            case 11L: return "ABI_MONTEREY";
            case 12L: return "ABI_MSDOS";
            case 13L: return "ABI_NT";
            case 14L: return "ABI_NETBSD";
            case 15L: return "ABI_OS2";
            case 16L: return "ABI_SOLARIS";
            case 17L: return "ABI_SYSV";
            case 18L: return "ABI_TRU64";
            case 19L: return "ABI_WIN386";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& ExecABI() {
        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
        };
        static const std::vector<int64_t> retval(values, values + 20);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecABI() {
        return stringify::SgAsmExecutableFileFormat::ExecABI();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 15865
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* InsSetArchitecture(int64_t i) {
        switch (i) {
            case 0L: return "ISA_UNSPECIFIED";
            case 256L: return "ISA_IA32_Family";
            case 257L: return "ISA_IA32_286";
            case 258L: return "ISA_IA32_386";
            case 259L: return "ISA_IA32_486";
            case 260L: return "ISA_IA32_Pentium";
            case 261L: return "ISA_IA32_Cyrix6x86";
            case 262L: return "ISA_IA32_AMDK5";
            case 263L: return "ISA_IA32_PentiumPro";
            case 264L: return "ISA_IA32_PentiumII";
            case 265L: return "ISA_IA32_Athlon";
            case 266L: return "ISA_IA32_Pentium4";
            case 267L: return "ISA_IA32_PentiumM";
            case 512L: return "ISA_X8664_Family";
            case 513L: return "ISA_X8664_Athlon64";
            case 514L: return "ISA_X8664_Prescott";
            case 515L: return "ISA_X8664_IntelCore";
            case 516L: return "ISA_X8664_AMDPhenom";
            case 768L: return "ISA_SPARC_Family";
            case 769L: return "ISA_SPARC_V7";
            case 770L: return "ISA_SPARC_V8";
            case 771L: return "ISA_SPARC_V8E";
            case 772L: return "ISA_SPARC_V9";
            case 773L: return "ISA_SPARC_V9JPS1";
            case 774L: return "ISA_SPARC_V9UA";
            case 775L: return "ISA_SPARC_V9JPS2";
            case 1024L: return "ISA_M68K_Family";
            case 1025L: return "ISA_M68K_68000";
            case 1026L: return "ISA_M68K_68EC000";
            case 1027L: return "ISA_M68K_68HC000";
            case 1028L: return "ISA_M68K_68008";
            case 1029L: return "ISA_M68K_68010";
            case 1030L: return "ISA_M68K_68012";
            case 1031L: return "ISA_M68K_68020";
            case 1032L: return "ISA_M68K_68EC020";
            case 1033L: return "ISA_M68K_68030";
            case 1034L: return "ISA_M68K_68EC030";
            case 1035L: return "ISA_M68K_68040";
            case 1036L: return "ISA_M68K_68EC040";
            case 1037L: return "ISA_M68K_68LC040";
            case 1038L: return "ISA_M68K_68060";
            case 1039L: return "ISA_M68K_ColdFire";
            case 1040L: return "ISA_M68K_DragonBall";
            case 1280L: return "ISA_M88K_Family";
            case 1281L: return "ISA_M88K_88100";
            case 1282L: return "ISA_M88K_88110";
            case 1283L: return "ISA_M88K_88110MP";
            case 1284L: return "ISA_M88K_88120";
            case 1536L: return "ISA_MIPS_Family";
            case 1537L: return "ISA_MIPS_MarkI";
            case 1538L: return "ISA_MIPS_MarkII";
            case 1539L: return "ISA_MIPS_MarkIII";
            case 1540L: return "ISA_MIPS_R2000";
            case 1541L: return "ISA_MIPS_R3000";
            case 1542L: return "ISA_MIPS_R4000";
            case 1543L: return "ISA_MIPS_R4200";
            case 1544L: return "ISA_MIPS_R4300";
            case 1545L: return "ISA_MIPS_R4600";
            case 1546L: return "ISA_MIPS_R4650";
            case 1547L: return "ISA_MIPS_R4700";
            case 1548L: return "ISA_MIPS_R5000";
            case 1549L: return "ISA_MIPS_RM7000";
            case 1550L: return "ISA_MIPS_R8000";
            case 1551L: return "ISA_MIPS_R10000";
            case 1552L: return "ISA_MIPS_R12000";
            case 1553L: return "ISA_MIPS_R14000";
            case 1554L: return "ISA_MIPS_R16000";
            case 1555L: return "ISA_MIPS_R16000A";
            case 1556L: return "ISA_MIPS_16";
            case 1557L: return "ISA_MIPS_FPU";
            case 1558L: return "ISA_MIPS_16FPU";
            case 1792L: return "ISA_I860_Family";
            case 1793L: return "ISA_I860_860XR";
            case 1794L: return "ISA_I860_860XP";
            case 2048L: return "ISA_IA64_Family";
            case 2049L: return "ISA_IA64_Itanium";
            case 2050L: return "ISA_IA64_Itanium2";
            case 2304L: return "ISA_ARM_Family";
            case 2305L: return "ISA_ARM_ARM1";
            case 2306L: return "ISA_ARM_ARM2";
            case 2307L: return "ISA_ARM_ARM3";
            case 2308L: return "ISA_ARM_ARM6";
            case 2309L: return "ISA_ARM_ARM7";
            case 2310L: return "ISA_ARM_ARM7TDMI";
            case 2311L: return "ISA_ARM_StrongARM";
            case 2312L: return "ISA_ARM_ARM8";
            case 2313L: return "ISA_ARM_ARM9TDMI";
            case 2314L: return "ISA_ARM_ARM9E";
            case 2315L: return "ISA_ARM_ARM10E";
            case 2316L: return "ISA_ARM_XScale";
            case 2317L: return "ISA_ARM_ARM11";
            case 2318L: return "ISA_ARM_Cortex";
            case 61440L: return "ISA_OTHER_Family";
            case 61441L: return "ISA_ATT_WE_32100";
            case 61442L: return "ISA_IBM_System_370";
            case 61443L: return "ISA_HPPA";
            case 61444L: return "ISA_Fujitsu_VPP500";
            case 61445L: return "ISA_Sun_v8plus";
            case 61446L: return "ISA_PowerPC";
            case 61447L: return "ISA_PowerPC_64bit";
            case 61448L: return "ISA_IBM_S390";
            case 61449L: return "ISA_NEC_V800_series";
            case 61450L: return "ISA_Fujitsu_FR20";
            case 61451L: return "ISA_TRW_RH_32";
            case 61452L: return "ISA_Motorola_RCE";
            case 61454L: return "ISA_Digital_Alpha_fake";
            case 61455L: return "ISA_Hitachi_SH";
            case 61456L: return "ISA_Siemens_Tricore";
            case 61457L: return "ISA_Argonaut_RISC_Core";
            case 61458L: return "ISA_Hitachi_H8_300";
            case 61459L: return "ISA_Hitachi_H8_300H";
            case 61460L: return "ISA_Hitachi_H8S";
            case 61461L: return "ISA_Hitachi_H8_500";
            case 61462L: return "ISA_Stanford_MIPS_X";
            case 61463L: return "ISA_Motorola_M68HC12";
            case 61464L: return "ISA_Fujitsu_MMA_Multimedia_Accelerator";
            case 61465L: return "ISA_Siemens_PCP";
            case 61466L: return "ISA_Sony_nCPU_embeeded_RISC";
            case 61467L: return "ISA_Denso_NDR1_microprocessor";
            case 61468L: return "ISA_Motorola_Start_Core_processor";
            case 61469L: return "ISA_Toyota_ME16_processor";
            case 61470L: return "ISA_STMicroelectronic_ST100_processor";
            case 61471L: return "ISA_Advanced_Logic_Corp_Tinyj_emb_family";
            case 61472L: return "ISA_AMD_x86_64_architecture";
            case 61473L: return "ISA_Sony_DSP_Processor";
            case 61474L: return "ISA_Siemens_FX66_microcontroller";
            case 61475L: return "ISA_STMicroelectronics_ST9_plus_8_16_microcontroller";
            case 61476L: return "ISA_STMicroelectronics_ST7_8bit_microcontroller";
            case 61477L: return "ISA_Motorola_MC68HC16_microcontroller";
            case 61478L: return "ISA_Motorola_MC68HC11_microcontroller";
            case 61479L: return "ISA_Motorola_MC68HC08_microcontroller";
            case 61480L: return "ISA_Motorola_MC68HC05_microcontroller";
            case 61481L: return "ISA_Silicon_Graphics_SVx";
            case 61482L: return "ISA_STMicroelectronics_ST19_8bit_microcontroller";
            case 61483L: return "ISA_Digital_VAX";
            case 61484L: return "ISA_Axis_Communications_32bit_embedded_processor";
            case 61485L: return "ISA_Infineon_Technologies_32bit_embedded_processor";
            case 61486L: return "ISA_Element_14_64bit_DSP_Processor";
            case 61487L: return "ISA_LSI_Logic_16bit_DSP_Processor";
            case 61488L: return "ISA_Donald_Knuths_educational_64bit_processor";
            case 61489L: return "ISA_Harvard_University_machine_independent_object_files";
            case 61490L: return "ISA_SiTera_Prism";
            case 61491L: return "ISA_Atmel_AVR_8bit_microcontroller";
            case 61492L: return "ISA_Fujitsu_FR30";
            case 61493L: return "ISA_Mitsubishi_D10V";
            case 61494L: return "ISA_Mitsubishi_D30V";
            case 61495L: return "ISA_NEC_v850";
            case 61496L: return "ISA_Mitsubishi_M32R";
            case 61497L: return "ISA_Matsushita_MN10300";
            case 61498L: return "ISA_Matsushita_MN10200";
            case 61499L: return "ISA_picoJava";
            case 61500L: return "ISA_OpenRISC_32bit_embedded_processor";
            case 61501L: return "ISA_ARC_Cores_Tangent_A5";
            case 61502L: return "ISA_Tensilica_Xtensa_Architecture";
            case 61503L: return "ISA_Digital_Alpha";
            case 61504L: return "ISA_Matsushita_AM33";
            case 61505L: return "ISA_EFI_ByteCode";
            case 65280L: return "ISA_FAMILY_MASK";
            case 65535L: return "ISA_OTHER";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& InsSetArchitecture() {
        static const int64_t values[] = {
            0L,
            256L,
            257L,
            258L,
            259L,
            260L,
            261L,
            262L,
            263L,
            264L,
            265L,
            266L,
            267L,
            512L,
            513L,
            514L,
            515L,
            516L,
            768L,
            769L,
            770L,
            771L,
            772L,
            773L,
            774L,
            775L,
            1024L,
            1025L,
            1026L,
            1027L,
            1028L,
            1029L,
            1030L,
            1031L,
            1032L,
            1033L,
            1034L,
            1035L,
            1036L,
            1037L,
            1038L,
            1039L,
            1040L,
            1280L,
            1281L,
            1282L,
            1283L,
            1284L,
            1536L,
            1537L,
            1538L,
            1539L,
            1540L,
            1541L,
            1542L,
            1543L,
            1544L,
            1545L,
            1546L,
            1547L,
            1548L,
            1549L,
            1550L,
            1551L,
            1552L,
            1553L,
            1554L,
            1555L,
            1556L,
            1557L,
            1558L,
            1792L,
            1793L,
            1794L,
            2048L,
            2049L,
            2050L,
            2304L,
            2305L,
            2306L,
            2307L,
            2308L,
            2309L,
            2310L,
            2311L,
            2312L,
            2313L,
            2314L,
            2315L,
            2316L,
            2317L,
            2318L,
            61440L,
            61441L,
            61442L,
            61443L,
            61444L,
            61445L,
            61446L,
            61447L,
            61448L,
            61449L,
            61450L,
            61451L,
            61452L,
            61454L,
            61455L,
            61456L,
            61457L,
            61458L,
            61459L,
            61460L,
            61461L,
            61462L,
            61463L,
            61464L,
            61465L,
            61466L,
            61467L,
            61468L,
            61469L,
            61470L,
            61471L,
            61472L,
            61473L,
            61474L,
            61475L,
            61476L,
            61477L,
            61478L,
            61479L,
            61480L,
            61481L,
            61482L,
            61483L,
            61484L,
            61485L,
            61486L,
            61487L,
            61488L,
            61489L,
            61490L,
            61491L,
            61492L,
            61493L,
            61494L,
            61495L,
            61496L,
            61497L,
            61498L,
            61499L,
            61500L,
            61501L,
            61502L,
            61503L,
            61504L,
            61505L,
            65280L,
            65535L
        };
        static const std::vector<int64_t> retval(values, values + 159);
        return retval;
    }

}}

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

    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatInsSetArchitecture() {
        return stringify::SgAsmExecutableFileFormat::InsSetArchitecture();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/ROSETTA/src/binaryInstruction.C line 16044
namespace stringify { namespace SgAsmExecutableFileFormat {
    const char* ExecPurpose(int64_t i) {
        switch (i) {
            case 0L: return "PURPOSE_UNSPECIFIED";
            case 1L: return "PURPOSE_OTHER";
            case 2L: return "PURPOSE_EXECUTABLE";
            case 3L: return "PURPOSE_LIBRARY";
            case 4L: return "PURPOSE_CORE_DUMP";
            case 5L: return "PURPOSE_OS_SPECIFIC";
            case 6L: return "PURPOSE_PROC_SPECIFIC";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& ExecPurpose() {
        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 stringifySgAsmExecutableFileFormatExecPurpose(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::SgAsmExecutableFileFormat::ExecPurpose(i);
        if (retval.empty()) {
            retval = "(SgAsmExecutableFileFormat::ExecPurpose)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SgAsmExecutableFileFormat::ExecPurpose::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecPurpose() {
        return stringify::SgAsmExecutableFileFormat::ExecPurpose();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryUnparserBase.h line 37
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace ArrowMargin {
    const char* Flags(int64_t i) {
        switch (i) {
            case 1L: return "POINTABLE_ENTITY_START";
            case 2L: return "POINTABLE_ENTITY_END";
            case 4L: return "POINTABLE_ENTITY_INSIDE";
            case 8L: return "ALWAYS_RENDER";
            default: return "";
        }
    }

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

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

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisUnparserArrowMarginFlags(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags)" + 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::Unparser::ArrowMargin::Flags::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisUnparserArrowMarginFlags() {
        return stringify::Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/AsmUnparser.h line 251
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace AsmUnparser {
    const char* Organization(int64_t i) {
        switch (i) {
            case 0L: return "ORGANIZED_BY_AST";
            case 1L: return "ORGANIZED_BY_ADDRESS";
            default: return "";
        }
    }

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

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

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisAsmUnparserOrganization(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::AsmUnparser::Organization(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::AsmUnparser::Organization)" + 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::AsmUnparser::Organization::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisAsmUnparserOrganization() {
        return stringify::Rose::BinaryAnalysis::AsmUnparser::Organization();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/AsmUnparser_compat.h line 46
namespace stringify {
    const char* ArmSignForExpressionUnparsing(int64_t i) {
        switch (i) {
            case 0L: return "arm_sign_none";
            case 1L: return "arm_sign_plus";
            case 2L: return "arm_sign_minus";
            default: return "";
        }
    }

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

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

}

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

    const std::vector<int64_t>& stringifyArmSignForExpressionUnparsing() {
        return stringify::ArmSignForExpressionUnparsing();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryEdgeArrows.h line 31
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
    const char* OutputPart(int64_t i) {
        switch (i) {
            case 0L: return "FIRST_LINE";
            case 1L: return "LAST_LINE";
            case 2L: return "MIDDLE_LINE";
            case 3L: return "INTER_LINE";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& OutputPart() {
        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 stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart)" + 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::Unparser::EdgeArrows::OutputPart::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart() {
        return stringify::Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryEdgeArrows.h line 59
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
    const char* ArrowStylePreset(int64_t i) {
        switch (i) {
            case 0L: return "UNICODE_1";
            case 1L: return "UNICODE_2";
            case 2L: return "ASCII_1";
            case 3L: return "ASCII_2";
            case 4L: return "ASCII_3";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& ArrowStylePreset() {
        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 stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset)" + 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::Unparser::EdgeArrows::ArrowStylePreset::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset() {
        return stringify::Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinaryEdgeArrows.h line 68
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
    const char* ArrowSide(int64_t i) {
        switch (i) {
            case 0L: return "LEFT";
            case 1L: return "RIGHT";
            default: return "";
        }
    }

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

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

}}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide)" + 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::Unparser::EdgeArrows::ArrowSide::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide() {
        return stringify::Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinarySerialIo.h line 119
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
    const char* Format(int64_t i) {
        switch (i) {
            case 0L: return "BINARY";
            case 1L: return "TEXT";
            case 2L: return "XML";
            default: return "";
        }
    }

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

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

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSerialIoFormat(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SerialIo::Format(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SerialIo::Format)" + 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::SerialIo::Format::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoFormat() {
        return stringify::Rose::BinaryAnalysis::SerialIo::Format();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinarySerialIo.h line 130
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
    const char* Savable(int64_t i) {
        switch (i) {
            case 0L: return "NO_OBJECT";
            case 1L: return "PARTITIONER";
            case 2L: return "AST";
            case 65534L: return "END_OF_DATA";
            case 65535L: return "ERROR";
            case 65536L: return "USER_DEFINED";
            case 4294967295L: return "USER_DEFINED_LAST";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& Savable() {
        static const int64_t values[] = {
            0L,
            1L,
            2L,
            65534L,
            65535L,
            65536L,
            4294967295L
        };
        static const std::vector<int64_t> retval(values, values + 7);
        return retval;
    }

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSerialIoSavable(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SerialIo::Savable(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SerialIo::Savable)" + 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::SerialIo::Savable::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoSavable() {
        return stringify::Rose::BinaryAnalysis::SerialIo::Savable();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 19
namespace stringify {
    const char* AssociativitySpecifier(int64_t i) {
        switch (i) {
            case 0L: return "e_assoc_none";
            case 1L: return "e_assoc_right";
            case 2L: return "e_assoc_left";
            case 3L: return "e_assoc_last";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& AssociativitySpecifier() {
        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 stringifyAssociativitySpecifier(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::AssociativitySpecifier(i);
        if (retval.empty()) {
            retval = "(AssociativitySpecifier)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "AssociativitySpecifier::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyAssociativitySpecifier() {
        return stringify::AssociativitySpecifier();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 46
namespace stringify { namespace UnparseLanguageIndependentConstructs {
    const char* token_sequence_position_enum_type(int64_t i) {
        switch (i) {
            case 0L: return "e_leading_whitespace_start";
            case 1L: return "e_leading_whitespace_end";
            case 2L: return "e_token_subsequence_start";
            case 3L: return "e_token_subsequence_end";
            case 4L: return "e_trailing_whitespace_start";
            case 5L: return "e_trailing_whitespace_end";
            case 6L: return "e_else_whitespace_start";
            case 7L: return "e_else_whitespace_end";
            default: return "";
        }
    }

    std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
        std::string s = token_sequence_position_enum_type(i);
        if (s.empty())
            s = "(UnparseLanguageIndependentConstructs::token_sequence_position_enum_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>& token_sequence_position_enum_type() {
        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 stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::UnparseLanguageIndependentConstructs::token_sequence_position_enum_type(i);
        if (retval.empty()) {
            retval = "(UnparseLanguageIndependentConstructs::token_sequence_position_enum_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 = "UnparseLanguageIndependentConstructs::token_sequence_position_enum_type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type() {
        return stringify::UnparseLanguageIndependentConstructs::token_sequence_position_enum_type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 74
namespace stringify { namespace UnparseLanguageIndependentConstructs {
    const char* unparsed_as_enum_type(int64_t i) {
        switch (i) {
            case 0L: return "e_unparsed_as_error";
            case 1L: return "e_unparsed_as_AST";
            case 2L: return "e_unparsed_as_partial_token_sequence";
            case 3L: return "e_unparsed_as_token_stream";
            case 4L: return "e_unparsed_as_last";
            default: return "";
        }
    }

    std::string unparsed_as_enum_type(int64_t i, const std::string &strip) {
        std::string s = unparsed_as_enum_type(i);
        if (s.empty())
            s = "(UnparseLanguageIndependentConstructs::unparsed_as_enum_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>& unparsed_as_enum_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 stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::UnparseLanguageIndependentConstructs::unparsed_as_enum_type(i);
        if (retval.empty()) {
            retval = "(UnparseLanguageIndependentConstructs::unparsed_as_enum_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 = "UnparseLanguageIndependentConstructs::unparsed_as_enum_type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type() {
        return stringify::UnparseLanguageIndependentConstructs::unparsed_as_enum_type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/formatSupport/unparse_format.h line 51
namespace stringify {
    const char* Format_Opt(int64_t i) {
        switch (i) {
            case 0L: return "FORMAT_BEFORE_DIRECTIVE";
            case 1L: return "FORMAT_AFTER_DIRECTIVE";
            case 2L: return "FORMAT_BEFORE_STMT";
            case 3L: return "FORMAT_AFTER_STMT";
            case 4L: return "FORMAT_BEFORE_BASIC_BLOCK1";
            case 5L: return "FORMAT_AFTER_BASIC_BLOCK1";
            case 6L: return "FORMAT_BEFORE_BASIC_BLOCK2";
            case 7L: return "FORMAT_AFTER_BASIC_BLOCK2";
            case 8L: return "FORMAT_BEFORE_NESTED_STATEMENT";
            case 9L: return "FORMAT_AFTER_NESTED_STATEMENT";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& Format_Opt() {
        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 stringifyFormat_Opt(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Format_Opt(i);
        if (retval.empty()) {
            retval = "(Format_Opt)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "Format_Opt::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyFormat_Opt() {
        return stringify::Format_Opt();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/astUnparseAttribute.h line 33
namespace stringify { namespace AstUnparseAttribute {
    const char* RelativePositionType(int64_t i) {
        switch (i) {
            case 0L: return "e_defaultValue";
            case 1L: return "e_undef";
            case 2L: return "e_before";
            case 3L: return "e_after";
            case 4L: return "e_inside";
            case 5L: return "e_replace";
            case 6L: return "e_before_syntax";
            case 7L: return "e_after_syntax";
            default: return "";
        }
    }

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

    const std::vector<int64_t>& RelativePositionType() {
        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 stringifyAstUnparseAttributeRelativePositionType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::AstUnparseAttribute::RelativePositionType(i);
        if (retval.empty()) {
            retval = "(AstUnparseAttribute::RelativePositionType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "AstUnparseAttribute::RelativePositionType::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyAstUnparseAttributeRelativePositionType() {
        return stringify::AstUnparseAttribute::RelativePositionType();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/CxxCodeGeneration/unparseCxx.h line 531
namespace stringify { namespace Unparse_ExprStmt {
    const char* token_sequence_position_enum_type(int64_t i) {
        switch (i) {
            case 0L: return "e_leading_whitespace_start";
            case 1L: return "e_leading_whitespace_end";
            case 2L: return "e_token_subsequence_start";
            case 3L: return "e_token_subsequence_end";
            case 4L: return "e_trailing_whitespace_start";
            case 5L: return "e_trailing_whitespace_end";
            default: return "";
        }
    }

    std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
        std::string s = token_sequence_position_enum_type(i);
        if (s.empty())
            s = "(Unparse_ExprStmt::token_sequence_position_enum_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>& token_sequence_position_enum_type() {
        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 stringifyUnparse_ExprStmt_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Unparse_ExprStmt::token_sequence_position_enum_type(i);
        if (retval.empty()) {
            retval = "(Unparse_ExprStmt::token_sequence_position_enum_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 = "Unparse_ExprStmt::token_sequence_position_enum_type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyUnparse_ExprStmt_token_sequence_position_enum_type() {
        return stringify::Unparse_ExprStmt::token_sequence_position_enum_type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/unparser.h line 205
namespace stringify { namespace Unparser {
    const char* token_sequence_position_enum_type(int64_t i) {
        switch (i) {
            case 0L: return "e_leading_whitespace_start";
            case 1L: return "e_leading_whitespace_end";
            case 2L: return "e_token_subsequence_start";
            case 3L: return "e_token_subsequence_end";
            case 4L: return "e_trailing_whitespace_start";
            case 5L: return "e_trailing_whitespace_end";
            default: return "";
        }
    }

    std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
        std::string s = token_sequence_position_enum_type(i);
        if (s.empty())
            s = "(Unparser::token_sequence_position_enum_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>& token_sequence_position_enum_type() {
        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 stringifyUnparser_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Unparser::token_sequence_position_enum_type(i);
        if (retval.empty()) {
            retval = "(Unparser::token_sequence_position_enum_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 = "Unparser::token_sequence_position_enum_type::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyUnparser_token_sequence_position_enum_type() {
        return stringify::Unparser::token_sequence_position_enum_type();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/MemoryMap.h line 126
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap { namespace Attach {
    const char* Boolean(int64_t 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::MemoryMap::Attach::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 stringifyBinaryAnalysisMemoryMapAttachBoolean(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::MemoryMap::Attach::Boolean(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::MemoryMap::Attach::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::MemoryMap::Attach::Boolean::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapAttachBoolean() {
        return stringify::Rose::BinaryAnalysis::MemoryMap::Attach::Boolean();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/MemoryMap.h line 282
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap {
    const char* InsertFileMapMode(int64_t i) {
        switch (i) {
            case 0L: return "MAP_PRIVATE";
            case 1L: return "MAP_READWRITE";
            case 2L: return "MAP_RDONLY";
            default: return "";
        }
    }

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

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

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisMemoryMapInsertFileMapMode(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::MemoryMap::InsertFileMapMode(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::MemoryMap::InsertFileMapMode)" + 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::MemoryMap::InsertFileMapMode::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapInsertFileMapMode() {
        return stringify::Rose::BinaryAnalysis::MemoryMap::InsertFileMapMode();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/SRecord.h line 28
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
    const char* Syntax(int64_t i) {
        switch (i) {
            case 0L: return "SREC_MOTOROLA";
            case 1L: return "SREC_INTEL";
            case 2L: return "SREC_UNKNOWN_SYNTAX";
            default: return "";
        }
    }

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

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

}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSRecordSyntax(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SRecord::Syntax(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SRecord::Syntax)" + 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::SRecord::Syntax::" + retval;
        }
        return retval;
    }

    const std::vector<int64_t>& stringifyBinaryAnalysisSRecordSyntax() {
        return stringify::Rose::BinaryAnalysis::SRecord::Syntax();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/SRecord.h line 35
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
    const char* Type(int64_t i) {
        switch (i) {
            case 0L: return "SREC_M_HEADER";
            case 1L: return "SREC_M_DATA16";
            case 2L: return "SREC_M_DATA24";
            case 3L: return "SREC_M_DATA32";
            case 4L: return "SREC_M_RESERVED";
            case 5L: return "SREC_M_COUNT16";
            case 6L: return "SREC_M_COUNT24";
            case 7L: return "SREC_M_START32";
            case 8L: return "SREC_M_START24";
            case 9L: return "SREC_M_START16";
            case 10L: return "SREC_I_DATA";
            case 11L: return "SREC_I_END";
            case 12L: return "SREC_I_EXTENDED_SA";
            case 13L: return "SREC_I_START_SA";
            case 14L: return "SREC_I_EXTENDED_LA";
            case 15L: return "SREC_I_START_LA";
            case 16L: return "SREC_UNKNOWN_TYPE";
            default: return "";
        }
    }

    std::string Type(int64_t i, const std::string &strip) {
        std::string s = Type(i);
        if (s.empty())
            s = "(Rose::BinaryAnalysis::SRecord::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,
            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 stringifyBinaryAnalysisSRecordType(int64_t i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::SRecord::Type(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::SRecord::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::SRecord::Type::" + retval;
        }
        return retval;
    }

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/BinaryFormats/ByteOrder.h line 7
namespace stringify { namespace ByteOrder {
    const char* Endianness(int64_t i) {
        switch (i) {
            case 0L: return "ORDER_UNSPECIFIED";
            case 1L: return "ORDER_LSB";
            case 2L: return "ORDER_MSB";
            default: return "";
        }
    }

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

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

}}

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

    const std::vector<int64_t>& stringifyByteOrderEndianness() {
        return stringify::ByteOrder::Endianness();
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 11
namespace stringify { namespace General_Language_Translation {
    const char* ExpressionKind(int64_t i) {
        switch (i) {
            case 0L: return "e_unknown";
            case 1L: return "e_access_modifier_public";
            case 2L: return "e_access_modifier_private";
            case 3L: return "e_storage_modifier_contiguous";
            case 4L: return "e_storage_modifier_external";
            case 5L: return "e_storage_modifier_static";
            case 6L: return "e_storage_modifier_location";
            case 7L: return "e_storage_modifier_jovial_def";
            case 8L: return "e_storage_modifier_jovial_ref";
            case 9L: return "e_type_modifier_list";
            case 10L: return "e_type_modifier_allocatable";
            case 11L: return "e_type_modifier_asynchronous";
            case 12L: return "e_type_modifier_const";
            case 13L: return "e_type_modifier_intent_in";
            case 14L: return "e_type_modifier_intent_out";
            case 15L: return "e_type_modifier_intent_inout";
            case 16L: return "e_type_modifier_intrinsic";
            case 17L: return "e_type_modifier_optional";
            case 18L: return "e_type_modifier_pointer";
            case 19L: return "e_type_modifier_protected";
            case 20L: return "e_type_modifier_round";
            case 21L: return "e_type_modifier_save";
            case 22L: return "e_type_modifier_target";
            case 23L: return "e_type_modifier_truncate";
            case 24L: return "e_type_modifier_value";
            case 25L: return "e_type_modifier_reference";
            case 26L: return "e_type_modifier_result";
            case 27L: return "e_type_modifier_volatile";
            case 28L: return "e_type_modifier_z";
            case 29L: return "e_function_modifier_list";
            case 30L: return "e_function_modifier_none";
            case 31L: return "e_function_modifier_elemental";
            case 32L: return "e_function_modifier_impure";
            case 33L: return "e_function_modifier_module";
            case 34L: return "e_function_modifier_pure";
            case 35L: return "e_function_modifier_recursive";
            case 36L: return "e_function_modifier_reentrant";
            case 37L: return "e_struct_modifier_list";
            case 38L: return "e_struct_item_modifier_list";
            case 39L: return "e_operator_assign";
            case 40L: return "e_operator_exponentiate";
            case 41L: return "e_operator_concatenate";
            case 42L: return "e_operator_add";
            case 43L: return "e_operator_subtract";
            case 44L: return "e_operator_mod";
            case 45L: return "e_operator_multiply";
            case 46L: return "e_operator_divide";
            case 47L: return "e_operator_and";
            case 48L: return "e_operator_or";
            case 49L: return "e_operator_xor";
            case 50L: return "e_operator_equiv";
            case 51L: return "e_operator_less_than";
            case 52L: return "e_operator_greater_than";
            case 53L: return "e_operator_less_than_or_equal";
            case 54L: return "e_operator_greater_than_or_equal";
            case 55L: return "e_operator_equality";
            case 56L: return "e_operator_not_equal";
            case 57L: return "e_operator_unary_plus";
            case 58L: return "e_operator_unary_minus";
            case 59L: return "e_operator_unary_not";
            case 60L: return "e_operator_unity";
            case 61L: return "e_literalExpression";
            case 62L: return "e_function_reference";
            case 63L: return "e_procedure_call";
            case 64L: return "e_argument_list";
            case 65L: return "e_argument_keyword";
            case 66L: return "e_variable_reference";