// File: /workspace/github_c_makefile_star2_O2/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 0x49bcb
movl %edi, %eax
leaq 0x89f29(%rip), %rcx     # 0xd3894
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, %eax
leaq 0x8c0fb(%rip), %rcx     # 0xd5a78
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c0fd(%rip), %rcx     # 0xd5a88
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c0ff(%rip), %rcx     # 0xd5a98
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c0d9(%rip), %rcx     # 0xd5a80
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c0bb(%rip), %rcx     # 0xd5a70
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c19d(%rip), %rcx     # 0xd5b60
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c187(%rip), %rcx     # 0xd5b58
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c111(%rip), %rcx     # 0xd5af0
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c17b(%rip), %rcx     # 0xd5b68
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c125(%rip), %rcx     # 0xd5b20
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c12f(%rip), %rcx     # 0xd5b38
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c0a1(%rip), %rcx     # 0xd5ab8
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c0e3(%rip), %rcx     # 0xd5b08
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c005(%rip), %rcx     # 0xd5a38
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c107(%rip), %rcx     # 0xd5b48
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c0c9(%rip), %rcx     # 0xd5b18
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bffb(%rip), %rcx     # 0xd5a58
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c075(%rip), %rcx     # 0xd5ae0
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bfcf(%rip), %rcx     # 0xd5a48
jmp 0x49bd7
leaq 0x9c1dc(%rip), %rax     # 0xe5c61
retq
movl %esi, %eax
leaq 0x8c081(%rip), %rcx     # 0xd5b10
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf83(%rip), %rcx     # 0xd5a20
jmp 0x49bd7
leaq 0x9de99(%rip), %rax     # 0xe7942
retq
movl %esi, %eax
leaq 0x8bf65(%rip), %rcx     # 0xd5a18
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf9f(%rip), %rcx     # 0xd5a60
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bff1(%rip), %rcx     # 0xd5ac0
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c053(%rip), %rcx     # 0xd5b30
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c065(%rip), %rcx     # 0xd5b50
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c077(%rip), %rcx     # 0xd5b70
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf29(%rip), %rcx     # 0xd5a30
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf8b(%rip), %rcx     # 0xd5aa0
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c005(%rip), %rcx     # 0xd5b28
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bef7(%rip), %rcx     # 0xd5a28
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c001(%rip), %rcx     # 0xd5b40
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf03(%rip), %rcx     # 0xd5a50
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf7d(%rip), %rcx     # 0xd5ad8
jmp 0x49bd7
movl %esi, %eax
leaq 0x8c012(%rip), %rcx     # 0xd5b78
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf5f(%rip), %rcx     # 0xd5ad0
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf2c(%rip), %rcx     # 0xd5aa8
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf41(%rip), %rcx     # 0xd5ac8
jmp 0x49bd7
movl %esi, %eax
leaq 0x8beae(%rip), %rcx     # 0xd5a40
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf13(%rip), %rcx     # 0xd5ab0
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf58(%rip), %rcx     # 0xd5b00
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf45(%rip), %rcx     # 0xd5af8
jmp 0x49bd7
movl %esi, %eax
leaq 0x8beaa(%rip), %rcx     # 0xd5a68
jmp 0x49bd7
movl %esi, %eax
leaq 0x8bf1f(%rip), %rcx     # 0xd5ae8
jmp 0x49bd7
xorl %eax, %eax
retq
movl %esi, %eax
leaq 0x8beb9(%rip), %rcx     # 0xd5a90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq