// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: type_name_from_type
static const char *type_name_from_type(int32_t typ, article_t article)
                {
                    static const char *frees[2] =          {"free-cell",          "a free cell"};
                    static const char *nils[2] =           {"nil",                "nil"};
                    static const char *unuseds[2] =        {"#<unused>",          "the unused object"};
                    static const char *eofs[2] =           {"#<eof>",             "the end-of-file object"};
                    static const char *unspecs[2] =        {"#<unspecified>",     "the unspecified object"};
                    static const char *undefs[2] =         {"undefined",          "an undefined object"};
                    static const char *booleans[2] =       {"boolean",            "boolean"};
                    static const char *strings[2] =        {"string",             "a string"};
                    static const char *byte_vectors[2] =   {"byte-vector",        "a byte-vector"};
                    static const char *symbols[2] =        {"symbol",             "a symbol"};
                    static const char *syntaxes[2] =       {"syntax",             "syntactic"};
                    static const char *pairs[2] =          {"pair",               "a pair"};
                    static const char *gotos[2] =          {"goto",               "a goto (from call-with-exit)"};
                    static const char *continuations[2] =  {"continuation",       "a continuation"};
                    static const char *c_funcs[2] =        {"c-function",         "a c-function"};
                    static const char *c_funcs_star[2] =   {"c-function*",        "a c-function*"};
                    static const char *macros[2] =         {"macro",              "a macro"};
                    static const char *c_macros[2] =       {"c-macro",            "a c-macro"};
                    static const char *bacros[2] =         {"bacro",              "a bacro"};
                    static const char *vectors[2] =        {"vector",             "a vector"};
                    static const char *int_vectors[2] =    {"int-vector",         "an int-vector"};
                    static const char *float_vectors[2] =  {"float-vector",       "a float-vector"};
                    static const char *c_pointers[2] =     {"c-pointer",          "a raw C pointer"};
                    static const char *counters[2] =       {"internal-counter",   "an internal counter"};
                    static const char *baffles[2] =        {"baffle",             "a baffle"};
                    static const char *slots[2] =          {"slot",               "a slot (variable binding)"};
                    static const char *characters[2] =     {"character",          "a character"};
                    static const char *catches[2] =        {"catch",              "a catch"};
                    static const char *dynamic_winds[2] =  {"dynamic-wind",       "a dynamic-wind"};
                    static const char *hash_tables[2] =    {"hash-table",         "a hash-table"};
                    static const char *iterators[2] =      {"iterator",           "an iterator"};
                    static const char *lets[2] =           {"let",                "a let"};
                    static const char *integers[2] =       {"integer",            "an integer"};
                    static const char *big_integers[2] =   {"big-integer",        "a big integer"};
                    static const char *ratios[2] =         {"ratio",              "a ratio"};
                    static const char *big_ratios[2] =     {"big-ratio",          "a big ratio"};
                    static const char *reals[2] =          {"real",               "a real"};
                    static const char *big_reals[2] =      {"big-real",           "a big real"};
                    static const char *complexes[2] =      {"complex-number",     "a complex number"};
                    static const char *big_complexes[2] =  {"big-complex-number", "a big complex number"};
                    static const char *functions[2] =      {"function",           "a function"};
                    static const char *function_stars[2] = {"function*",          "a function*"};
                    static const char *rngs[2] =           {"random-state",       "a random-state"};
                    static const char *inputs[2] =         {"input-port",         "an input port"};
                    static const char *outputs[2] =        {"output-port",        "an output port"};
                    static const char *c_objects[2] =      {"c-object",           "a c_object"};
                    static const char *stacks[2] =         {"stack",              "a stack"};

                    switch (typ)
                    {
                        case T_FREE:            return(frees[article]);
                        case T_NIL:             return(nils[article]);
                        case T_UNUSED:          return(unuseds[article]);
                        case T_EOF_OBJECT:      return(eofs[article]);
                        case T_UNSPECIFIED:     return(unspecs[article]);
                        case T_UNDEFINED:       return(undefs[article]);
                        case T_BOOLEAN:         return(booleans[article]);
                        case T_STRING:          return(strings[article]);
                        case T_BYTE_VECTOR:     return(byte_vectors[article]);
                        case T_SYMBOL:          return(symbols[article]);
                        case T_SYNTAX:          return(syntaxes[article]);
                        case T_PAIR:            return(pairs[article]);
                        case T_GOTO:            return(gotos[article]);
                        case T_CONTINUATION:    return(continuations[article]);
                        case T_C_OPT_ARGS_FUNCTION:
                        case T_C_RST_ARGS_FUNCTION:
                        case T_C_ANY_ARGS_FUNCTION:
                        case T_C_FUNCTION:      return(c_funcs[article]);
                        case T_C_FUNCTION_STAR: return(c_funcs_star[article]);
                        case T_CLOSURE:         return(functions[article]);
                        case T_CLOSURE_STAR:    return(function_stars[article]);
                        case T_C_MACRO:         return(c_macros[article]);
                        case T_C_POINTER:       return(c_pointers[article]);
                        case T_CHARACTER:       return(characters[article]);
                        case T_VECTOR:          return(vectors[article]);
                        case T_INT_VECTOR:      return(int_vectors[article]);
                        case T_FLOAT_VECTOR:    return(float_vectors[article]);
                        case T_MACRO_STAR:
                        case T_MACRO:           return(macros[article]);
                        case T_BACRO_STAR:
                        case T_BACRO:           return(bacros[article]);
                        case T_CATCH:           return(catches[article]);
                        case T_STACK:           return(stacks[article]);
                        case T_DYNAMIC_WIND:    return(dynamic_winds[article]);
                        case T_HASH_TABLE:      return(hash_tables[article]);
                        case T_ITERATOR:        return(iterators[article]);
                        case T_LET:             return(lets[article]);
                        case T_COUNTER:         return(counters[article]);
                        case T_BAFFLE:          return(baffles[article]);
                        case T_RANDOM_STATE:    return(rngs[article]);
                        case T_SLOT:            return(slots[article]);
                        case T_INTEGER:         return(integers[article]);
                        case T_RATIO:           return(ratios[article]);
                        case T_REAL:            return(reals[article]);
                        case T_COMPLEX:         return(complexes[article]);
                        case T_BIG_INTEGER:     return(big_integers[article]);
                        case T_BIG_RATIO:       return(big_ratios[article]);
                        case T_BIG_REAL:        return(big_reals[article]);
                        case T_BIG_COMPLEX:     return(big_complexes[article]);
                        case T_INPUT_PORT:      return(inputs[article]);
                        case T_OUTPUT_PORT:     return(outputs[article]);
                        case T_C_OBJECT:        return(c_objects[article]);
                    }
                    return(NULL);
                }

// Assembly:
cmpl $0x33, %edi
ja 0x5c4d0
movl %edi, %eax
leaq 0xab604(%rip), %rcx     # 0x107874
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, %eax
leaq 0xad7f6(%rip), %rcx     # 0x109a78
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad7f8(%rip), %rcx     # 0x109a88
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad7fa(%rip), %rcx     # 0x109a98
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad7d4(%rip), %rcx     # 0x109a80
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad7b6(%rip), %rcx     # 0x109a70
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad898(%rip), %rcx     # 0x109b60
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad882(%rip), %rcx     # 0x109b58
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad80c(%rip), %rcx     # 0x109af0
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad876(%rip), %rcx     # 0x109b68
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad820(%rip), %rcx     # 0x109b20
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad82a(%rip), %rcx     # 0x109b38
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad79c(%rip), %rcx     # 0x109ab8
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad7de(%rip), %rcx     # 0x109b08
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad700(%rip), %rcx     # 0x109a38
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad802(%rip), %rcx     # 0x109b48
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad7c4(%rip), %rcx     # 0x109b18
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad6f6(%rip), %rcx     # 0x109a58
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad770(%rip), %rcx     # 0x109ae0
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad6ca(%rip), %rcx     # 0x109a48
jmp 0x5c4dc
leaq 0xbd937(%rip), %rax     # 0x119cc1
retq
movl %esi, %eax
leaq 0xad77c(%rip), %rcx     # 0x109b10
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad67e(%rip), %rcx     # 0x109a20
jmp 0x5c4dc
leaq 0xbf5f4(%rip), %rax     # 0x11b9a2
retq
movl %esi, %eax
leaq 0xad660(%rip), %rcx     # 0x109a18
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad69a(%rip), %rcx     # 0x109a60
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad6ec(%rip), %rcx     # 0x109ac0
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad74e(%rip), %rcx     # 0x109b30
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad760(%rip), %rcx     # 0x109b50
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad772(%rip), %rcx     # 0x109b70
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad624(%rip), %rcx     # 0x109a30
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad686(%rip), %rcx     # 0x109aa0
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad700(%rip), %rcx     # 0x109b28
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad5f2(%rip), %rcx     # 0x109a28
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad6fc(%rip), %rcx     # 0x109b40
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad5fe(%rip), %rcx     # 0x109a50
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad678(%rip), %rcx     # 0x109ad8
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad70d(%rip), %rcx     # 0x109b78
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad65a(%rip), %rcx     # 0x109ad0
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad627(%rip), %rcx     # 0x109aa8
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad63c(%rip), %rcx     # 0x109ac8
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad5a9(%rip), %rcx     # 0x109a40
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad60e(%rip), %rcx     # 0x109ab0
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad653(%rip), %rcx     # 0x109b00
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad640(%rip), %rcx     # 0x109af8
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad5a5(%rip), %rcx     # 0x109a68
jmp 0x5c4dc
movl %esi, %eax
leaq 0xad61a(%rip), %rcx     # 0x109ae8
jmp 0x5c4dc
xorl %eax, %eax
retq
movl %esi, %eax
leaq 0xad5b4(%rip), %rcx     # 0x109a90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq