stringify.C

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

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

    std::string Organization(long 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;
    }
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisAsmUnparserOrganization(long int 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;
    }
}

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

    std::string Format(long 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;
    }
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSerialIoFormat(long int 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;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/BinarySerialIo.h line 127
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
    const char* Savable(long 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(long 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;
    }
}}}}

namespace Rose {
    std::string stringifyBinaryAnalysisSerialIoSavable(long int 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;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/asmUnparser/AsmUnparser_compat.h line 44
namespace stringify {
    const char* ArmSignForExpressionUnparsing(long 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(long 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;
    }
}

namespace Rose {
    std::string stringifyArmSignForExpressionUnparsing(long int 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;
    }
}

// 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(long 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(long 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;
    }
}

namespace Rose {
    std::string stringifyAssociativitySpecifier(long int 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;
    }
}

// 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(long 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(long 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;
    }
}}

namespace Rose {
    std::string stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type(long int 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;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 71
namespace stringify { namespace UnparseLanguageIndependentConstructs {
    const char* unparsed_as_enum_type(long 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(long 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;
    }
}}

namespace Rose {
    std::string stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type(long int 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;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/unparser.h line 201
namespace stringify { namespace Unparser {
    const char* token_sequence_position_enum_type(long 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(long 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;
    }
}}

namespace Rose {
    std::string stringifyUnparser_token_sequence_position_enum_type(long int 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;
    }
}

// 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(long 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(long 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;
    }
}

namespace Rose {
    std::string stringifyFormat_Opt(long int 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;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/backend/unparser/CxxCodeGeneration/unparseCxx.h line 522
namespace stringify { namespace Unparse_ExprStmt {
    const char* token_sequence_position_enum_type(long 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(long 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;
    }
}}

namespace Rose {
    std::string stringifyUnparse_ExprStmt_token_sequence_position_enum_type(long int 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;
    }
}

// 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(long 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(long 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;
    }
}}

namespace Rose {
    std::string stringifyAstUnparseAttributeRelativePositionType(long int 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;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/POET/poet_yacc.h line 46
namespace stringify {
    const char* yytokentype(long i) {
        switch (i) {
            case 258L: return "ENDLIST";
            case 259L: return "ERROR";
            case 260L: return "SYNERROR";
            case 261L: return "PARAMETER";
            case 262L: return "DEFINE";
            case 263L: return "EVAL";
            case 264L: return "LBEGIN";
            case 265L: return "RBEGIN";
            case 266L: return "PRINT";
            case 267L: return "INPUT_ENDFILE";
            case 268L: return "INPUT_ENDL";
            case 269L: return "INPUT_CONT";
            case 270L: return "COND";
            case 271L: return "ANNOT";
            case 272L: return "TO";
            case 273L: return "FROM";
            case 274L: return "TYPE";
            case 275L: return "POETTYPE";
            case 276L: return "SYNTAX";
            case 277L: return "MESSAGE";
            case 278L: return "LTAG";
            case 279L: return "RTAG";
            case 280L: return "ENDTAG";
            case 281L: return "PARS";
            case 282L: return "XFORM";
            case 283L: return "OUTPUT";
            case 284L: return "PARSE";
            case 285L: return "LOOKAHEAD";
            case 286L: return "MATCH";
            case 287L: return "CODE";
            case 288L: return "GLOBAL";
            case 289L: return "SOURCE";
            case 290L: return "ENDCODE";
            case 291L: return "ENDXFORM";
            case 292L: return "INPUT";
            case 293L: return "ENDINPUT";
            case 294L: return "SEMICOLON";
            case 295L: return "IN";
            case 296L: return "SUCH_THAT";
            case 297L: return "FOR";
            case 298L: return "FOREACH";
            case 299L: return "FOREACH_R";
            case 300L: return "DO";
            case 301L: return "ENDDO";
            case 302L: return "BREAK";
            case 303L: return "CONTINUE";
            case 304L: return "RETURN";
            case 305L: return "DEBUG";
            case 306L: return "IF";
            case 307L: return "ELSE";
            case 308L: return "CASE";
            case 309L: return "SWITCH";
            case 310L: return "DEFAULT";
            case 311L: return "DOT3";
            case 312L: return "DOT4";
            case 313L: return "ASSIGN";
            case 314L: return "PLUS_ASSIGN";
            case 315L: return "MINUS_ASSIGN";
            case 316L: return "MULT_ASSIGN";
            case 317L: return "DIVIDE_ASSIGN";
            case 318L: return "MOD_ASSIGN";
            case 319L: return "COMMA";
            case 320L: return "QUESTION";
            case 321L: return "OR";
            case 322L: return "TOR";
            case 323L: return "AND";
            case 324L: return "NOT";
            case 325L: return "LT";
            case 326L: return "LE";
            case 327L: return "EQ";
            case 328L: return "GT";
            case 329L: return "GE";
            case 330L: return "NE";
            case 331L: return "ARROW";
            case 332L: return "DARROW";
            case 333L: return "PLUS";
            case 334L: return "MINUS";
            case 335L: return "MULTIPLY";
            case 336L: return "DIVIDE";
            case 337L: return "MOD";
            case 338L: return "STR_CONCAT";
            case 339L: return "DCOLON";
            case 340L: return "UMINUS";
            case 341L: return "TILT";
            case 342L: return "DELAY";
            case 343L: return "APPLY";
            case 344L: return "CLEAR";
            case 345L: return "SAVE";
            case 346L: return "RESTORE";
            case 347L: return "REVERSE";
            case 348L: return "PERMUTE";
            case 349L: return "REPLACE";
            case 350L: return "ASSERT";
            case 351L: return "RANGE";
            case 352L: return "DUPLICATE";
            case 353L: return "REBUILD";
            case 354L: return "VAR";
            case 355L: return "MAP";
            case 356L: return "TUPLE";
            case 357L: return "LIST";
            case 358L: return "LIST1";
            case 359L: return "INT";
            case 360L: return "STRING";
            case 361L: return "FLOAT";
            case 362L: return "NAME";
            case 363L: return "EXP";
            case 364L: return "TRACE";
            case 365L: return "ERASE";
            case 366L: return "COPY";
            case 367L: return "SPLIT";
            case 368L: return "LEN";
            case 369L: return "INSERT";
            case 370L: return "CAR";
            case 371L: return "CDR";
            case 372L: return "COLON";
            case 373L: return "ID";
            case 374L: return "ICONST";
            case 375L: return "FCONST";
            case 376L: return "ANY";
            case 377L: return "DOT";
            case 378L: return "DOT2";
            case 379L: return "POND";
            case 380L: return "LB";
            case 381L: return "RB";
            case 382L: return "LBR";
            case 383L: return "RBR";
            case 384L: return "LP";
            case 385L: return "RP";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/MSTL/DOTGeneration.h line 45
namespace stringify { namespace DOTGeneration {
    const char* traversalType(long i) {
        switch (i) {
            case 0L: return "PREORDER";
            case 1L: return "POSTORDER";
            case 2L: return "TOPDOWN";
            case 3L: return "BOTTOMUP";
            case 4L: return "TOPDOWNBOTTOMUP";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QRButtons.h line 29
namespace stringify { namespace qrs { namespace QRButtons {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "Normal";
            case 1L: return "Toggle";
            case 2L: return "Check";
            case 3L: return "Radio";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringify_qrsQRButtonsType(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::qrs::QRButtons::Type(i);
        if (retval.empty()) {
            retval = "(qrs::QRButtons::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 = "qrs::QRButtons::Type::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QRSelect.h line 26
namespace stringify { namespace qrs { namespace QRSelect {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "Combo";
            case 1L: return "Box";
            case 2L: return "Check";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringify_qrsQRSelectType(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::qrs::QRSelect::Type(i);
        if (retval.empty()) {
            retval = "(qrs::QRSelect::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 = "qrs::QRSelect::Type::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Widgets/QREdit.h line 28
namespace stringify { namespace qrs { namespace QREdit {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "Line";
            case 1L: return "Box";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringify_qrsQREditType(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::qrs::QREdit::Type(i);
        if (retval.empty()) {
            retval = "(qrs::QREdit::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 = "qrs::QREdit::Type::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/qeditor.h line 65
namespace stringify { namespace qrs { namespace QEditor {
    const char* TypeSel(long i) {
        switch (i) {
            case 1000L: return "sel0";
            case 2000L: return "sel1";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/qsourcecolorizer.h line 257
namespace stringify { namespace qrs { namespace QSourceColorizer {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "Normal";
            case 1L: return "PreProcessor";
            case 2L: return "Keyword";
            case 3L: return "BuiltInClass";
            case 4L: return "Operator";
            case 5L: return "Comment";
            case 6L: return "Constant";
            case 7L: return "String";
            case 1000L: return "Custom";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringify_qrsQSourceColorizerType(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::qrs::QSourceColorizer::Type(i);
        if (retval.empty()) {
            retval = "(qrs::QSourceColorizer::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 = "qrs::QSourceColorizer::Type::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/parenmatcher.h line 37
namespace stringify { namespace qrs { namespace Paren {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "Open";
            case 1L: return "Closed";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringify_qrsParenType(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::qrs::Paren::Type(i);
        if (retval.empty()) {
            retval = "(qrs::Paren::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 = "qrs::Paren::Type::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/parenmatcher.h line 48
namespace stringify { namespace qrs { namespace ParenMatcher {
    const char* Selection(long i) {
        switch (i) {
            case 1L: return "Match";
            case 2L: return "Mismatch";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/paragdata.h line 36
namespace stringify { namespace qrs { namespace Symbol {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "Left";
            case 1L: return "Right";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringify_qrsSymbolType(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::qrs::Symbol::Type(i);
        if (retval.empty()) {
            retval = "(qrs::Symbol::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 = "qrs::Symbol::Type::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/QRSourceBox.h line 39
namespace stringify { namespace qrs { namespace QRSourceBox {
    const char* ToolbarIdx(long i) {
        switch (i) {
            case 0L: return "tbTargetMode";
            case 1L: return "tbCacheView";
            case 2L: return "tbCollectMode";
            case 3L: return "tbClearCache";
            case 4L: return "tbBroadcastCache";
            case 5L: return "tbGoto";
            case 6L: return "tbLookup";
            case 7L: return "tbZoomIn";
            case 8L: return "tbZoomOut";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 122
namespace stringify { namespace qrs { namespace Q3TextStringChar {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "Regular";
            case 1L: return "Custom";
            case 2L: return "Anchor";
            case 3L: return "CustomAnchor";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringify_qrsQ3TextStringCharType(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::qrs::Q3TextStringChar::Type(i);
        if (retval.empty()) {
            retval = "(qrs::Q3TextStringChar::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 = "qrs::Q3TextStringChar::Type::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 366
namespace stringify { namespace qrs { namespace Q3TextCursor {
    const char* Operation(long i) {
        switch (i) {
            case 0L: return "EnterBegin";
            case 1L: return "EnterEnd";
            case 2L: return "Next";
            case 3L: return "Prev";
            case 4L: return "Up";
            case 5L: return "Down";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 390
namespace stringify { namespace qrs { namespace Q3TextCommand {
    const char* Commands(long i) {
        switch (i) {
            case 0L: return "Invalid";
            case 1L: return "Insert";
            case 2L: return "Delete";
            case 3L: return "Format";
            case 4L: return "Style";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 451
namespace stringify { namespace qrs { namespace Q3TextCustomItem {
    const char* Placement(long i) {
        switch (i) {
            case 0L: return "PlaceInline";
            case 1L: return "PlaceLeft";
            case 2L: return "PlaceRight";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 724
namespace stringify { namespace qrs { namespace Q3TextDocument {
    const char* SelectionIds(long i) {
        switch (i) {
            case 0L: return "Standard";
            case 32000L: return "Temp";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1380
namespace stringify { namespace qrs { namespace Q3TextPreProcessor {
    const char* Ids(long i) {
        switch (i) {
            case 0L: return "Standard";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1400
namespace stringify { namespace qrs { namespace Q3TextFormat {
    const char* Flags(long i) {
        switch (i) {
            case 0L: return "NoFlags";
            case 1L: return "Bold";
            case 2L: return "Italic";
            case 4L: return "Underline";
            case 8L: return "Family";
            case 16L: return "Size";
            case 32L: return "Color";
            case 64L: return "Misspelled";
            case 128L: return "VAlign";
            case 256L: return "StrikeOut";
            case 287L: return "Font";
            case 511L: return "Format";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringify_qrsQ3TextFormatFlags(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::qrs::Q3TextFormat::Flags(i);
        if (retval.empty()) {
            retval = "(qrs::Q3TextFormat::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 = "qrs::Q3TextFormat::Flags::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/SourceBox/q3richtext_px.h line 1415
namespace stringify { namespace qrs { namespace Q3TextFormat {
    const char* VerticalAlignment(long i) {
        switch (i) {
            case 0L: return "AlignNormal";
            case 1L: return "AlignSuperScript";
            case 2L: return "AlignSubScript";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/TreeBox/QRTreeBox.h line 40
namespace stringify { namespace qrs { namespace QRTreeBox {
    const char* ToolbarIdx(long i) {
        switch (i) {
            case 0L: return "tbTargetMode";
            case 1L: return "tbCacheView";
            case 2L: return "tbCollectMode";
            case 3L: return "tbClearCache";
            case 4L: return "tbBroadcastCache";
            case 5L: return "tbHighlight";
            case 6L: return "tbLookup";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/qrose/Components/TreeBox/QRTreeBox.h line 107
namespace stringify { namespace qrs { namespace QRTreeBox {
    const char* popmenu_nodes_id(long i) {
        switch (i) {
            case 0L: return "pm_set_root";
            case 1L: return "pm_set_default_root";
            case 2L: return "pm_remove";
            case 3L: return "pm_expand";
            case 4L: return "pm_collapse";
            case 5L: return "pm_expand_code";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_encoder.h line 69
namespace stringify {
    const char* _HPDF_EncodingType(long i) {
        switch (i) {
            case 0L: return "HPDF_STANDARD_ENCODING";
            case 1L: return "HPDF_MAC_ROMAN_ENCODING";
            case 2L: return "HPDF_WIN_ANSI_ENCODING";
            case 3L: return "HPDF_FONT_SPECIFIC";
            case 4L: return "HPDF_ENCODING_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_encoder.h line 130
namespace stringify {
    const char* _HPDF_BaseEncodings(long i) {
        switch (i) {
            case 0L: return "HPDF_BASE_ENCODING_STANDARD";
            case 1L: return "HPDF_BASE_ENCODING_WIN_ANSI";
            case 2L: return "HPDF_BASE_ENCODING_MAC_ROMAN";
            case 3L: return "HPDF_BASE_ENCODING_FONT_SPECIFIC";
            case 4L: return "HPDF_BASE_ENCODING_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_fontdef.h line 63
namespace stringify {
    const char* _HPDF_FontDefType(long i) {
        switch (i) {
            case 0L: return "HPDF_FONTDEF_TYPE_TYPE1";
            case 1L: return "HPDF_FONTDEF_TYPE_TRUETYPE";
            case 2L: return "HPDF_FONTDEF_TYPE_CID";
            case 3L: return "HPDF_FONTDEF_TYPE_UNINITIALIZED";
            case 4L: return "HPDF_FONTDEF_TYPE_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_streams.h line 33
namespace stringify {
    const char* _HPDF_StreamType(long i) {
        switch (i) {
            case 0L: return "HPDF_STREAM_UNKNOWN";
            case 1L: return "HPDF_STREAM_CALLBACK";
            case 2L: return "HPDF_STREAM_FILE";
            case 3L: return "HPDF_STREAM_MEMORY";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_streams.h line 46
namespace stringify {
    const char* _HPDF_WhenceMode(long i) {
        switch (i) {
            case 0L: return "HPDF_SEEK_SET";
            case 1L: return "HPDF_SEEK_CUR";
            case 2L: return "HPDF_SEEK_END";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_font.h line 31
namespace stringify {
    const char* _HPDF_FontType(long i) {
        switch (i) {
            case 0L: return "HPDF_FONT_TYPE1";
            case 1L: return "HPDF_FONT_TRUETYPE";
            case 2L: return "HPDF_FONT_TYPE3";
            case 3L: return "HPDF_FONT_TYPE0_CID";
            case 4L: return "HPDF_FONT_TYPE0_TT";
            case 5L: return "HPDF_FONT_CID_TYPE0";
            case 6L: return "HPDF_FONT_CID_TYPE2";
            case 7L: return "HPDF_FONT_MMTYPE1";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 128
namespace stringify {
    const char* _HPDF_InfoType(long i) {
        switch (i) {
            case 0L: return "HPDF_INFO_CREATION_DATE";
            case 1L: return "HPDF_INFO_MOD_DATE";
            case 2L: return "HPDF_INFO_AUTHOR";
            case 3L: return "HPDF_INFO_CREATOR";
            case 4L: return "HPDF_INFO_PRODUCER";
            case 5L: return "HPDF_INFO_TITLE";
            case 6L: return "HPDF_INFO_SUBJECT";
            case 7L: return "HPDF_INFO_KEYWORDS";
            case 8L: return "HPDF_INFO_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 144
namespace stringify {
    const char* _HPDF_PdfVer(long i) {
        switch (i) {
            case 0L: return "HPDF_VER_12";
            case 1L: return "HPDF_VER_13";
            case 2L: return "HPDF_VER_14";
            case 3L: return "HPDF_VER_15";
            case 4L: return "HPDF_VER_16";
            case 5L: return "HPDF_VER_17";
            case 6L: return "HPDF_VER_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 154
namespace stringify {
    const char* _HPDF_EncryptMode(long i) {
        switch (i) {
            case 2L: return "HPDF_ENCRYPT_R2";
            case 3L: return "HPDF_ENCRYPT_R3";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 213
namespace stringify {
    const char* _HPDF_ColorSpace(long i) {
        switch (i) {
            case 0L: return "HPDF_CS_DEVICE_GRAY";
            case 1L: return "HPDF_CS_DEVICE_RGB";
            case 2L: return "HPDF_CS_DEVICE_CMYK";
            case 3L: return "HPDF_CS_CAL_GRAY";
            case 4L: return "HPDF_CS_CAL_RGB";
            case 5L: return "HPDF_CS_LAB";
            case 6L: return "HPDF_CS_ICC_BASED";
            case 7L: return "HPDF_CS_SEPARATION";
            case 8L: return "HPDF_CS_DEVICE_N";
            case 9L: return "HPDF_CS_INDEXED";
            case 10L: return "HPDF_CS_PATTERN";
            case 11L: return "HPDF_CS_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 250
namespace stringify {
    const char* _HPDF_LineCap(long i) {
        switch (i) {
            case 0L: return "HPDF_BUTT_END";
            case 1L: return "HPDF_ROUND_END";
            case 2L: return "HPDF_PROJECTING_SCUARE_END";
            case 3L: return "HPDF_LINECAP_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 260
namespace stringify {
    const char* _HPDF_LineJoin(long i) {
        switch (i) {
            case 0L: return "HPDF_MITER_JOIN";
            case 1L: return "HPDF_ROUND_JOIN";
            case 2L: return "HPDF_BEVEL_JOIN";
            case 3L: return "HPDF_LINEJOIN_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 270
namespace stringify {
    const char* _HPDF_TextRenderingMode(long i) {
        switch (i) {
            case 0L: return "HPDF_FILL";
            case 1L: return "HPDF_STROKE";
            case 2L: return "HPDF_FILL_THEN_STROKE";
            case 3L: return "HPDF_INVISIBLE";
            case 4L: return "HPDF_FILL_CLIPPING";
            case 5L: return "HPDF_STROKE_CLIPPING";
            case 6L: return "HPDF_FILL_STROKE_CLIPPING";
            case 7L: return "HPDF_CLIPPING";
            case 8L: return "HPDF_RENDERING_MODE_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 283
namespace stringify {
    const char* _HPDF_WritingMode(long i) {
        switch (i) {
            case 0L: return "HPDF_WMODE_HORIZONTAL";
            case 1L: return "HPDF_WMODE_VERTICAL";
            case 2L: return "HPDF_WMODE_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 290
namespace stringify {
    const char* _HPDF_PageLayout(long i) {
        switch (i) {
            case 0L: return "HPDF_PAGE_LAYOUT_SINGLE";
            case 1L: return "HPDF_PAGE_LAYOUT_ONE_COLUMN";
            case 2L: return "HPDF_PAGE_LAYOUT_TWO_COLUMN_LEFT";
            case 3L: return "HPDF_PAGE_LAYOUT_TWO_COLUMN_RIGHT";
            case 4L: return "HPDF_PAGE_LAYOUT_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 299
namespace stringify {
    const char* _HPDF_PageMode(long i) {
        switch (i) {
            case 0L: return "HPDF_PAGE_MODE_USE_NONE";
            case 1L: return "HPDF_PAGE_MODE_USE_OUTLINE";
            case 2L: return "HPDF_PAGE_MODE_USE_THUMBS";
            case 3L: return "HPDF_PAGE_MODE_FULL_SCREEN";
            case 4L: return "HPDF_PAGE_MODE_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 311
namespace stringify {
    const char* _HPDF_PageNumStyle(long i) {
        switch (i) {
            case 0L: return "HPDF_PAGE_NUM_STYLE_DECIMAL";
            case 1L: return "HPDF_PAGE_NUM_STYLE_UPPER_ROMAN";
            case 2L: return "HPDF_PAGE_NUM_STYLE_LOWER_ROMAN";
            case 3L: return "HPDF_PAGE_NUM_STYLE_UPPER_LETTERS";
            case 4L: return "HPDF_PAGE_NUM_STYLE_LOWER_LETTERS";
            case 5L: return "HPDF_PAGE_NUM_STYLE_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 321
namespace stringify {
    const char* _HPDF_DestinationType(long i) {
        switch (i) {
            case 0L: return "HPDF_XYZ";
            case 1L: return "HPDF_FIT";
            case 2L: return "HPDF_FIT_H";
            case 3L: return "HPDF_FIT_V";
            case 4L: return "HPDF_FIT_R";
            case 5L: return "HPDF_FIT_B";
            case 6L: return "HPDF_FIT_BH";
            case 7L: return "HPDF_FIT_BV";
            case 8L: return "HPDF_DST_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 334
namespace stringify {
    const char* _HPDF_AnnotType(long i) {
        switch (i) {
            case 0L: return "HPDF_ANNOT_TEXT_NOTES";
            case 1L: return "HPDF_ANNOT_LINK";
            case 2L: return "HPDF_ANNOT_SOUND";
            case 3L: return "HPDF_ANNOT_FREE_TEXT";
            case 4L: return "HPDF_ANNOT_STAMP";
            case 5L: return "HPDF_ANNOT_SQUARE";
            case 6L: return "HPDF_ANNOT_CIRCLE";
            case 7L: return "HPDF_ANNOT_STRIKE_OUT";
            case 8L: return "HPDF_ANNOT_HIGHTLIGHT";
            case 9L: return "HPDF_ANNOT_UNDERLINE";
            case 10L: return "HPDF_ANNOT_INK";
            case 11L: return "HPDF_ANNOT_FILE_ATTACHMENT";
            case 12L: return "HPDF_ANNOT_POPUP";
            case 13L: return "HPDF_ANNOT_3D";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 352
namespace stringify {
    const char* _HPDF_AnnotFlgs(long i) {
        switch (i) {
            case 0L: return "HPDF_ANNOT_INVISIBLE";
            case 1L: return "HPDF_ANNOT_HIDDEN";
            case 2L: return "HPDF_ANNOT_PRINT";
            case 3L: return "HPDF_ANNOT_NOZOOM";
            case 4L: return "HPDF_ANNOT_NOROTATE";
            case 5L: return "HPDF_ANNOT_NOVIEW";
            case 6L: return "HPDF_ANNOT_READONLY";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 363
namespace stringify {
    const char* _HPDF_AnnotHighlightMode(long i) {
        switch (i) {
            case 0L: return "HPDF_ANNOT_NO_HIGHTLIGHT";
            case 1L: return "HPDF_ANNOT_INVERT_BOX";
            case 2L: return "HPDF_ANNOT_INVERT_BORDER";
            case 3L: return "HPDF_ANNOT_DOWN_APPEARANCE";
            case 4L: return "HPDF_ANNOT_HIGHTLIGHT_MODE_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 372
namespace stringify {
    const char* _HPDF_AnnotIcon(long i) {
        switch (i) {
            case 0L: return "HPDF_ANNOT_ICON_COMMENT";
            case 1L: return "HPDF_ANNOT_ICON_KEY";
            case 2L: return "HPDF_ANNOT_ICON_NOTE";
            case 3L: return "HPDF_ANNOT_ICON_HELP";
            case 4L: return "HPDF_ANNOT_ICON_NEW_PARAGRAPH";
            case 5L: return "HPDF_ANNOT_ICON_PARAGRAPH";
            case 6L: return "HPDF_ANNOT_ICON_INSERT";
            case 7L: return "HPDF_ANNOT_ICON_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 388
namespace stringify {
    const char* _HPDF_BSSubtype(long i) {
        switch (i) {
            case 0L: return "HPDF_BS_SOLID";
            case 1L: return "HPDF_BS_DASHED";
            case 2L: return "HPDF_BS_BEVELED";
            case 3L: return "HPDF_BS_INSET";
            case 4L: return "HPDF_BS_UNDERLINED";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 399
namespace stringify {
    const char* _HPDF_BlendMode(long i) {
        switch (i) {
            case 0L: return "HPDF_BM_NORMAL";
            case 1L: return "HPDF_BM_MULTIPLY";
            case 2L: return "HPDF_BM_SCREEN";
            case 3L: return "HPDF_BM_OVERLAY";
            case 4L: return "HPDF_BM_DARKEN";
            case 5L: return "HPDF_BM_LIGHTEN";
            case 6L: return "HPDF_BM_COLOR_DODGE";
            case 7L: return "HPDF_BM_COLOR_BUM";
            case 8L: return "HPDF_BM_HARD_LIGHT";
            case 9L: return "HPDF_BM_SOFT_LIGHT";
            case 10L: return "HPDF_BM_DIFFERENCE";
            case 11L: return "HPDF_BM_EXCLUSHON";
            case 12L: return "HPDF_BM_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 417
namespace stringify {
    const char* _HPDF_TransitionStyle(long i) {
        switch (i) {
            case 0L: return "HPDF_TS_WIPE_RIGHT";
            case 1L: return "HPDF_TS_WIPE_UP";
            case 2L: return "HPDF_TS_WIPE_LEFT";
            case 3L: return "HPDF_TS_WIPE_DOWN";
            case 4L: return "HPDF_TS_BARN_DOORS_HORIZONTAL_OUT";
            case 5L: return "HPDF_TS_BARN_DOORS_HORIZONTAL_IN";
            case 6L: return "HPDF_TS_BARN_DOORS_VERTICAL_OUT";
            case 7L: return "HPDF_TS_BARN_DOORS_VERTICAL_IN";
            case 8L: return "HPDF_TS_BOX_OUT";
            case 9L: return "HPDF_TS_BOX_IN";
            case 10L: return "HPDF_TS_BLINDS_HORIZONTAL";
            case 11L: return "HPDF_TS_BLINDS_VERTICAL";
            case 12L: return "HPDF_TS_DISSOLVE";
            case 13L: return "HPDF_TS_GLITTER_RIGHT";
            case 14L: return "HPDF_TS_GLITTER_DOWN";
            case 15L: return "HPDF_TS_GLITTER_TOP_LEFT_TO_BOTTOM_RIGHT";
            case 16L: return "HPDF_TS_REPLACE";
            case 17L: return "HPDF_TS_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 440
namespace stringify {
    const char* _HPDF_PageSizes(long i) {
        switch (i) {
            case 0L: return "HPDF_PAGE_SIZE_LETTER";
            case 1L: return "HPDF_PAGE_SIZE_LEGAL";
            case 2L: return "HPDF_PAGE_SIZE_A3";
            case 3L: return "HPDF_PAGE_SIZE_A4";
            case 4L: return "HPDF_PAGE_SIZE_A5";
            case 5L: return "HPDF_PAGE_SIZE_B4";
            case 6L: return "HPDF_PAGE_SIZE_B5";
            case 7L: return "HPDF_PAGE_SIZE_EXECUTIVE";
            case 8L: return "HPDF_PAGE_SIZE_US4x6";
            case 9L: return "HPDF_PAGE_SIZE_US4x8";
            case 10L: return "HPDF_PAGE_SIZE_US5x7";
            case 11L: return "HPDF_PAGE_SIZE_COMM10";
            case 12L: return "HPDF_PAGE_SIZE_EOF";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 457
namespace stringify {
    const char* _HPDF_PageDirection(long i) {
        switch (i) {
            case 0L: return "HPDF_PAGE_PORTRAIT";
            case 1L: return "HPDF_PAGE_LANDSCAPE";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 463
namespace stringify {
    const char* _HPDF_EncoderType(long i) {
        switch (i) {
            case 0L: return "HPDF_ENCODER_TYPE_SINGLE_BYTE";
            case 1L: return "HPDF_ENCODER_TYPE_DOUBLE_BYTE";
            case 2L: return "HPDF_ENCODER_TYPE_UNINITIALIZED";
            case 3L: return "HPDF_ENCODER_UNKNOWN";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 471
namespace stringify {
    const char* _HPDF_ByteType(long i) {
        switch (i) {
            case 0L: return "HPDF_BYTE_TYPE_SINGLE";
            case 1L: return "HPDF_BYTE_TYPE_LEAD";
            case 2L: return "HPDF_BYTE_TYPE_TRIAL";
            case 3L: return "HPDF_BYTE_TYPE_UNKNOWN";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/3rdPartyLibraries/libharu-2.1.0/include/hpdf_types.h line 479
namespace stringify {
    const char* _HPDF_TextAlignment(long i) {
        switch (i) {
            case 0L: return "HPDF_TALIGN_LEFT";
            case 1L: return "HPDF_TALIGN_RIGHT";
            case 2L: return "HPDF_TALIGN_CENTER";
            case 3L: return "HPDF_TALIGN_JUSTIFY";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/SgNodeHelper.h line 426
namespace stringify { namespace SgNodeHelper { namespace Pattern { namespace OutputTarget {
    const char* OType(long i) {
        switch (i) {
            case 0L: return "VAR";
            case 1L: return "INT";
            case 2L: return "UNKNOWNPRINTF";
            case 3L: return "UNKNOWNOPERATION";
            default: return "";
        }
    }

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

namespace Rose {
    std::string stringifySgNodeHelperPatternOutputTargetOType(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::SgNodeHelper::Pattern::OutputTarget::OType(i);
        if (retval.empty()) {
            retval = "(SgNodeHelper::Pattern::OutputTarget::OType)" + boost::lexical_cast<std::string>(i);
        } else {
            if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
                retval = retval.substr(strlen(strip));
            if (canonic)
                retval = "SgNodeHelper::Pattern::OutputTarget::OType::" + retval;
        }
        return retval;
    }
}

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/abstractLayer/Labeler.h line 86
namespace stringify { namespace SPRAY { namespace LabelProperty {
    const char* IOType(long i) {
        switch (i) {
            case 0L: return "LABELIO_NONE";
            case 1L: return "LABELIO_STDIN";
            case 2L: return "LABELIO_STDOUTVAR";
            case 3L: return "LABELIO_STDOUTCONST";
            case 4L: return "LABELIO_STDERR";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nameQuery.h line 74
namespace stringify { namespace NameQuery {
    const char* TypeOfQueryTypeOneParameter(long i) {
        switch (i) {
            case 0L: return "UnknownListElementType";
            case 1L: return "VariableNames";
            case 2L: return "VariableTypeNames";
            case 3L: return "FunctionDeclarationNames";
            case 4L: return "MemberFunctionDeclarationNames";
            case 5L: return "ClassDeclarationNames";
            case 6L: return "ArgumentNames";
            case 7L: return "ClassFieldNames";
            case 8L: return "UnionFieldNames";
            case 9L: return "StructFieldNames";
            case 10L: return "FunctionReferenceNames";
            case 11L: return "StructNames";
            case 12L: return "UnionNames";
            case 13L: return "TypedefDeclarationNames";
            case 14L: return "TypeNames";
            case 15L: return "END_OF_NAME_TYPE_LIST";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nameQuery.h line 94
namespace stringify { namespace NameQuery {
    const char* TypeOfQueryTypeTwoParameters(long i) {
        switch (i) {
            case 0L: return "UnknownListElementTypeTwoParameters";
            case 1L: return "VariableNamesWithTypeName";
            case 2L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/booleanQuery.h line 43
namespace stringify { namespace BooleanQuery {
    const char* TypeOfQueryType(long i) {
        switch (i) {
            case 0L: return "UnknownListElementType";
            case 1L: return "VariableDeclaration";
            case 2L: return "Type";
            case 3L: return "FunctionDeclaration";
            case 4L: return "MemberFunctionDeclaration";
            case 5L: return "ClassDeclaration";
            case 6L: return "Argument";
            case 7L: return "Field";
            case 8L: return "UnionedField";
            case 9L: return "Struct";
            case 10L: return "ContainedInSubtreeOfType";
            case 11L: return "END_OF_BOOLEAN_QUERY_TYPE";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/numberQuery.h line 19
namespace stringify { namespace NumberQuery {
    const char* TypeOfQueryTypeTwoParameters(long i) {
        switch (i) {
            case 0L: return "UnknownListElementTypeTwoParameters";
            case 1L: return "NumberOfArgsInParanthesisOperator";
            case 2L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nodeQuery.h line 133
namespace stringify { namespace NodeQuery {
    const char* TypeOfQueryTypeOneParameter(long i) {
        switch (i) {
            case 0L: return "UnknownListElementType";
            case 1L: return "VariableDeclarations";
            case 2L: return "VariableTypes";
            case 3L: return "FunctionDeclarations";
            case 4L: return "MemberFunctionDeclarations";
            case 5L: return "ClassDeclarations";
            case 6L: return "StructDeclarations";
            case 7L: return "UnionDeclarations";
            case 8L: return "Arguments";
            case 9L: return "ClassFields";
            case 10L: return "StructFields";
            case 11L: return "UnionFields";
            case 12L: return "StructDefinitions";
            case 13L: return "TypedefDeclarations";
            case 14L: return "AnonymousTypedefs";
            case 15L: return "AnonymousTypedefClassDeclarations";
            case 16L: return "END_OF_NODE_TYPE_LIST_ONE_PARAMETER";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astQuery/nodeQuery.h line 154
namespace stringify { namespace NodeQuery {
    const char* TypeOfQueryTypeTwoParameters(long i) {
        switch (i) {
            case 0L: return "UnknownListElementTypeTwoParameters";
            case 1L: return "FunctionDeclarationFromDefinition";
            case 2L: return "ClassDeclarationFromName";
            case 3L: return "ClassDeclarationsFromTypeName";
            case 4L: return "PragmaDeclarationFromName";
            case 5L: return "VariableDeclarationFromName";
            case 6L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/implicitCodeGeneration/defaultFunctionGenerator.C line 17
namespace stringify {
    const char* defaultEnumFunctionType(long i) {
        switch (i) {
            case 0L: return "e_unknown";
            case 1L: return "e_constructor";
            case 2L: return "e_destructor";
            case 3L: return "e_copy_constructor";
            case 4L: return "e_assignment_operator";
            case 5L: return "e_last_type";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programTransformation/extractFunctionArgumentsNormalization/functionEvaluationOrderTraversal.h line 40
namespace stringify { namespace FunctionCallInfo {
    const char* InsertionMode(long i) {
        switch (i) {
            case 0L: return "INSERT_BEFORE";
            case 1L: return "APPEND_SCOPE";
            case 2L: return "INVALID";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 21
namespace stringify { namespace SDG { namespace SDGNode {
    const char* NodeType(long i) {
        switch (i) {
            case 0L: return "Entry";
            case 1L: return "ASTNode";
            case 2L: return "FunctionCall";
            case 3L: return "ActualIn";
            case 4L: return "ActualOut";
            case 5L: return "FormalIn";
            case 6L: return "FormalOut";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 48
namespace stringify { namespace SDG { namespace SDGEdge {
    const char* EdgeType(long i) {
        switch (i) {
            case 0L: return "ControlDependence";
            case 1L: return "DataDependence";
            case 2L: return "ParameterIn";
            case 3L: return "ParameterOut";
            case 4L: return "Call";
            case 5L: return "Summary";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 58
namespace stringify { namespace SDG { namespace SDGEdge {
    const char* ControlDependenceType(long i) {
        switch (i) {
            case 0L: return "cdTrue";
            case 1L: return "cdFalse";
            case 2L: return "cdCase";
            case 3L: return "cdDefault";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/dominanceAnalysis/DominatorTree.h line 13
namespace stringify { namespace DominatorTreesAndDominanceFrontiers {
    const char* Dir_ection(long i) {
        switch (i) {
            case 0L: return "PRE_DOMINATOR";
            case 1L: return "POST_DOMINATOR";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/arithmeticIntensity/ai_measurement.h line 25
namespace stringify { namespace ArithmeticIntensityMeasurement {
    const char* running_mode_enum(long i) {
        switch (i) {
            case 0L: return "e_analysis_and_instrument";
            case 1L: return "e_static_counting";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/arithmeticIntensity/ai_measurement.h line 30
namespace stringify { namespace ArithmeticIntensityMeasurement {
    const char* fp_operation_kind_enum(long i) {
        switch (i) {
            case 0L: return "e_unknown";
            case 1L: return "e_total";
            case 2L: return "e_plus";
            case 3L: return "e_minus";
            case 4L: return "e_multiply";
            case 5L: return "e_divide";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/ssaUnfilteredCfg/reachingDefUnfilteredCfg.h line 19
namespace stringify { namespace ssa_unfiltered_cfg { namespace ReachingDef {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "PHI_FUNCTION";
            case 1L: return "ORIGINAL_DEF";
            case 2L: return "EXPANDED_DEF";
            case 3L: return "EXTERNAL_DEF";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Utils/BaseGraph.h line 261
namespace stringify { namespace BaseGraph { namespace BiDirNodesIterator {
    const char* dirType(long i) {
        switch (i) {
            case 0L: return "Forward";
            case 1L: return "Reverse";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/RIFG.h line 63
namespace stringify { namespace RIFG {
    const char* EdgeDirection(long i) {
        switch (i) {
            case 0L: return "ED_INCOMING";
            case 1L: return "ED_OUTGOING";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/RIFG.h line 64
namespace stringify { namespace RIFG {
    const char* ForwardBackward(long i) {
        switch (i) {
            case 0L: return "FORWARD";
            case 1L: return "BACKWARD";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/CFG.h line 83
namespace stringify { namespace CFG {
    const char* EdgeType(long i) {
        switch (i) {
            case 0L: return "TRUE_EDGE";
            case 1L: return "FALLTHROUGH_EDGE";
            case 2L: return "FALSE_EDGE";
            case 3L: return "BACK_EDGE";
            case 4L: return "MULTIWAY_EDGE";
            case 5L: return "BREAK_EDGE";
            case 6L: return "CONTINUE_EDGE";
            case 7L: return "RETURN_EDGE";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/TarjanIntervals.h line 65
namespace stringify {
    const char* RITarjType(long i) {
        switch (i) {
            case 0L: return "RI_TARJ_NOTHING";
            case 1L: return "RI_TARJ_ACYCLIC";
            case 2L: return "RI_TARJ_INTERVAL";
            case 3L: return "RI_TARJ_IRREDUCIBLE";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CFG/TarjanIntervals.h line 67
namespace stringify {
    const char* RITarjEdgeType(long i) {
        switch (i) {
            case 0L: return "RI_TARJ_NORMAL";
            case 1L: return "RI_TARJ_LOOP_ENTRY";
            case 2L: return "RI_TARJ_IRRED_ENTRY";
            case 3L: return "RI_TARJ_ITERATE";
            default: return "";
        }
    }

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 173
namespace stringify {
    const char* IRStmtType(long i) {
        switch (i) {
            case 0L: return "SIMPLE";
            case 1L: return "COMPOUND";
            case 2L: return "LOOP";
            case 3L: return "END_TESTED_LOOP";
            case 4L: return "STRUCT_TWOWAY_CONDITIONAL";
            case 5L: return "STRUCT_MULTIWAY_CONDITIONAL";
            case 6L: return "USTRUCT_TWOWAY_CONDITIONAL_T";
            case 7L: return "USTRUCT_TWOWAY_CONDITIONAL_F";
            case 8L: return "USTRUCT_MULTIWAY_CONDITIONAL";
            case 9L: return "RETURN";
            case 10L: return "BREAK";
            case 11L: return "LOOP_CONTINUE";
            case 12L: return "ALTERNATE_PROC_ENTRY";
            case 13L: return "UNCONDITIONAL_JUMP";
            case 14L: return "UNCONDITIONAL_JUMP_I";
            case 15L: return "NONE";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/OpenAnalysis/CallGraph/CallGraph.h line 73
namespace stringify { namespace CallGraph {
    const char* EdgeType(long i) {
        switch (i) {
            case 0L: return "NORMAL_EDGE";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/EditDistance/TreeEditDistance.h line 60
namespace stringify { namespace Rose { namespace EditDistance { namespace TreeEditDistance {
    const char* EditType(long i) {
        switch (i) {
            case 0L: return "INSERT";
            case 1L: return "DELETE";
            case 2L: return "SUBSTITUTE";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/programAnalysis/staticSingleAssignment/reachingDef.h line 18
namespace stringify { namespace ReachingDef {
    const char* Type(long i) {
        switch (i) {
            case 0L: return "PHI_FUNCTION";
            case 1L: return "ORIGINAL_DEF";
            case 2L: return "EXPANDED_DEF";
            default: return "";
        }
    }

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 66
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* PlacementPosition_Enum(long i) {
        switch (i) {
            case 0L: return "unknownPositionInScope";
            case 1L: return "PreamblePositionInScope";
            case 2L: return "TopOfCurrentScope";
            case 3L: return "BeforeCurrentPosition";
            case 4L: return "ReplaceCurrentPosition";
            case 5L: return "AfterCurrentPosition";
            case 6L: return "BottomOfCurrentScope";
            case 7L: return "LAST_PLACEMENT_TAG";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 79
namespace stringify { namespace MidLevelCollectionTypedefs {
    const char* IntermediateFileStringPosition_Enum(long i) {
        switch (i) {
            case 0L: return "unknownIntermediatePositionInScope";
            case 1L: return "GlobalScopePreamble";
            case 2L: return "CurrentLocationTopOfScope";
            case 3L: return "CurrentLocationAfter";
            case 4L: return "LAST_INTERMEDIATE_SOURCE_CODE_PLACEMENT_TAG";
            case 6L: return "CurrentLocationBottomOfScope";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 141
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* ScopeIdentifier_Enum(long i) {
        switch (i) {
            case 0L: return "unknownScope";
            case 1L: return "SurroundingScope";
            case 2L: return "ParentScope";
            case 3L: return "NestedLoopScope";
            case 4L: return "NestedConditionalScope";
            case 5L: return "FunctionScope";
            case 6L: return "FileScope";
            case 7L: return "GlobalScope";
            case 8L: return "Preamble";
            case 9L: return "LAST_SCOPE_TAG";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 162
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* PlacementPosition_Enum(long i) {
        switch (i) {
            case 0L: return "unknownPositionInScope";
            case 1L: return "PreamblePositionInScope";
            case 2L: return "TopOfScope";
            case 3L: return "TopOfIncludeRegion";
            case 4L: return "BottomOfIncludeRegion";
            case 5L: return "BeforeCurrentPosition";
            case 6L: return "ReplaceCurrentPosition";
            case 7L: return "AfterCurrentPosition";
            case 8L: return "BottomOfScope";
            case 9L: return "LAST_PLACEMENT_TAG";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astRewriteMechanism/rewrite.h line 176
namespace stringify { namespace HighLevelCollectionTypedefs {
    const char* IntermediateFileStringPosition_Enum(long i) {
        switch (i) {
            case 0L: return "unknownIntermediatePositionInScope";
            case 1L: return "GlobalScopePreamble";
            case 2L: return "GlobalScopeTopOfScope";
            case 3L: return "GlobalScopeTopOfIncludeRegion";
            case 4L: return "GlobalScopeBottomOfIncludeRegion";
            case 5L: return "GlobalScopeBeforeCurrentPosition";
            case 6L: return "GlobalScopeReplaceCurrentPosition";
            case 7L: return "FunctionScopePreamble";
            case 8L: return "FunctionScopeTopOfScope";
            case 9L: return "FunctionScopeBeforeCurrentPosition";
            case 10L: return "FunctionScopeReplaceCurrentPosition";
            case 11L: return "FunctionScopeAfterCurrentPosition";
            case 12L: return "FunctionScopeBottomOfScope";
            case 13L: return "GlobalScopeAfterCurrentPosition";
            case 14L: return "GlobalScopeBottomOfScope";
            case 15L: return "LAST_INTERMEDIATE_SOURCE_CODE_PLACEMENT_TAG";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astProcessing/AstAttributeMechanism.C line 21
namespace stringify {
    const char* WarningType(long i) {
        switch (i) {
            case 0L: return "HAS_MEMORY_LEAK";
            case 1L: return "HAS_UNKNOWN_OWNERSHIP";
            case 2L: return "HAS_NULL_COPY";
            case 3L: return "HAS_SELF_COPY";
            case 4L: return "HAS_NO_CLASS_NAME";
            default: return "";
        }
    }

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/astProcessing/AstAttributeMechanism.h line 42
namespace stringify { namespace AstAttribute {
    const char* OwnershipPolicy(long i) {
        switch (i) {
            case 0L: return "CONTAINER_OWNERSHIP";
            case 1L: return "NO_OWNERSHIP";
            case 2L: return "CUSTOM_OWNERSHIP";
            case 3L: return "UNKNOWN_OWNERSHIP";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinaryReachability.h line 19
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Reachability {
    const char* Reason(long i) {
        switch (i) {
            case 0L: return "NOT_REACHABLE";
            case 1L: return "ENTRY_POINT";
            case 2L: return "EXPORTED_FUNCTION";
            case 4L: return "SIGNAL_HANDLER";
            case 128L: return "ASSUMED";
            case 255L: return "PREDEFINED";
            case 256L: return "USER_DEFINED_0";
            case 4294967040L: return "USER_DEFINED";
            case 4294967295L: return "ALL_REASONS";
            default: return "";
        }
    }

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

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

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

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

namespace Rose {
    std::string stringifyBinaryAnalysisReachabilityPropagateBoolean(long int i, const char *strip, bool canonic) {
        std::string retval = stringify::Rose::BinaryAnalysis::Reachability::Propagate::Boolean(i);
        if (retval.empty()) {
            retval = "(Rose::BinaryAnalysis::Reachability::Propagate::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::Reachability::Propagate::Boolean::" + retval;
        }
        return retval;
    }
}

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySymbolicExpr.h line 56
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr {
    const char* Operator(long i) {
        switch (i) {
            case 0L: return "OP_ADD";
            case 1L: return "OP_AND";
            case 2L: return "OP_ASR";
            case 3L: return "OP_CONCAT";
            case 4L: return "OP_EQ";
            case 5L: return "OP_EXTRACT";
            case 6L: return "OP_INVERT";
            case 7L: return "OP_ITE";
            case 8L: return "OP_LET";
            case 9L: return "OP_LSSB";
            case 10L: return "OP_MSSB";
            case 11L: return "OP_NE";
            case 12L: return "OP_NEGATE";
            case 13L: return "OP_NOOP";
            case 14L: return "OP_OR";
            case 15L: return "OP_READ";
            case 16L: return "OP_ROL";
            case 17L: return "OP_ROR";
            case 18L: return "OP_SDIV";
            case 19L: return "OP_SET";
            case 20L: return "OP_SEXTEND";
            case 21L: return "OP_SGE";
            case 22L: return "OP_SGT";
            case 23L: return "OP_SHL0";
            case 24L: return "OP_SHL1";
            case 25L: return "OP_SHR0";
            case 26L: return "OP_SHR1";
            case 27L: return "OP_SLE";
            case 28L: return "OP_SLT";
            case 29L: return "OP_SMOD";
            case 30L: return "OP_SMUL";
            case 31L: return "OP_UDIV";
            case 32L: return "OP_UEXTEND";
            case 33L: return "OP_UGE";
            case 34L: return "OP_UGT";
            case 35L: return "OP_ULE";
            case 36L: return "OP_ULT";
            case 37L: return "OP_UMOD";
            case 38L: return "OP_UMUL";
            case 39L: return "OP_WRITE";
            case 40L: return "OP_XOR";
            case 41L: return "OP_ZEROP";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

// DO NOT EDIT -- This implementation was automatically generated for the enum defined at
// /src/midend/binaryAnalyses/BinarySymbolicExpr.h line 944
namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace Leaf {
    const char* LeafType(long i) {
        switch (i) {
            case 0L: return "CONSTANT";
            case 1L: return "BITVECTOR";
            case 2L: return "MEMORY";
            default: return "";
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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