// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: read_sharp
static token_t read_sharp(s7_scheme *sc, s7_pointer pt)
                {
                    int32_t c;
                    /* inchar can return EOF, so it can't be used directly as an index into the digits array */
                    c = inchar(pt);
                    switch (c)
                    {
                        case EOF:
                            s7_error(sc, sc->read_error_symbol, set_elist_1(sc, wrap_string(sc, "unexpected '#' at end of input", 30)));
                            break;

                        case '(':
                            sc->w = small_int(1);
                            return(TOKEN_VECTOR);

                        case 'i':
                            if (read_sharp(sc, pt) == TOKEN_VECTOR)
                                return(TOKEN_INT_VECTOR);
                            backchar('i', pt);
                            break;

                        case 'r':
                            if (read_sharp(sc, pt) == TOKEN_VECTOR)
                                return(TOKEN_FLOAT_VECTOR);
                            backchar('r', pt);
                            break;

                        case 'u':
                            if (s7_peek_char(sc, pt) == chars['8']) /* backwards compatibility: #u8(...) == #u(...) */
                            {
                                int32_t bc;
                                bc = inchar(pt);
                                if (s7_peek_char(sc, pt) == chars['('])
                                {
                                    inchar(pt);
                                    sc->w = small_int(1);
                                    return(TOKEN_BYTE_VECTOR);
                                }
                                backchar(bc, pt);
                            }
                            if (read_sharp(sc, pt) == TOKEN_VECTOR)
                                return(TOKEN_BYTE_VECTOR);
                            backchar('u', pt);
                            break;

                        case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
                            {
                                /* here we can get an overflow: #1231231231231232131D() */
                                s7_int dims;
                                int32_t d, loc = 0;
                                sc->strbuf[loc++] = (unsigned char)c;
                                dims = digits[c];

                                while (true)
                                {
                                    s7_int dig;
                                    d = inchar(pt);
                                    if (d == EOF)
                                        s7_error(sc, sc->read_error_symbol,
                                                set_elist_1(sc, wrap_string(sc, "unexpected end of input while reading #n...", 43)));

                                    dig = digits[d];
                                    if (dig >= 10) break;
                                    dims = dig + (dims * 10);
                                    if ((dims <= 0) ||
                                            (dims > S7_SHORT_MAX))
                                        s7_error(sc, sc->read_error_symbol,
                                                set_elist_2(sc, wrap_string(sc, "overflow while reading #nD: ~A", 30), wrap_integer1(sc, dims)));
                                    sc->strbuf[loc++] = (unsigned char)d;
                                }
                                sc->strbuf[loc++] = d;
                                if ((d == 'd') || (d == 'i') || (d == 'r') || (d == 'u'))
                                {
                                    int32_t e;
                                    e = inchar(pt);
                                    if (e == EOF)
                                        s7_error(sc, sc->read_error_symbol,
                                                set_elist_1(sc, wrap_string(sc, "unexpected end of input while reading #n()", 42)));
                                    sc->strbuf[loc++] = (unsigned char)e;
                                    if (e == '(')
                                    {
                                        sc->w = make_integer(sc, dims);
                                        if (d == 'd') return(TOKEN_VECTOR);
                                        if (d == 'r') return(TOKEN_FLOAT_VECTOR);
                                        if (d == 'u') return(TOKEN_BYTE_VECTOR);
                                        return(TOKEN_INT_VECTOR);
                                    }
                                }
                                /* try to back out */
                                for (d = loc - 1; d > 0; d--)
                                    backchar(sc->strbuf[d], pt);
                            }
                            break;

                        case ':':  /* turn #: into : -- this is for compatibility with Guile, sigh.
                                    *   I just noticed that Rick is using this -- I'll just leave it alone.
                                    *   but that means : readers need to handle this case specially.
                                    * I don't think #! is special anymore -- maybe remove that code?
                                    */
                            sc->strbuf[0] = ':';
                            return(TOKEN_ATOM);

                            /* block comments in #! ... !# */
                            /* this is needed when an input file is treated as a script:
#!/home/bil/cl/snd
!#
(format #t "a test~%")
(exit)
                             * but very often the closing !# is omitted which is too bad
                             */
                        case '!':
                            {
                                char last_char;
                                s7_pointer reader;

                                /* make it possible to override #! handling */
                                for (reader = slot_value(sc->sharp_readers); is_pair(reader); reader = cdr(reader))
                                    if (s7_character(caar(reader)) == '!')
                                    {
                                        sc->strbuf[0] = (unsigned char)c;
                                        return(TOKEN_SHARP_CONST); /* next stage notices any errors */
                                    }

                                /* not #! as block comment (for Guile I guess) */
                                last_char = ' ';
                                while ((c = inchar(pt)) != EOF)
                                {
                                    if ((c == '#') &&
                                            (last_char == '!'))
                                        break;
                                    last_char = c;
                                }
                                if (c == EOF)
                                    s7_error(sc, sc->read_error_symbol,
                                            set_elist_1(sc, wrap_string(sc, "unexpected end of input while reading #!", 40)));
                                return(token(sc));
                            }

                            /* block comments in #| ... |#
                             *   since we ignore everything until the |#, internal semicolon comments are ignored,
                             *   meaning that ;|# is as effective as |#
                             */
                        case '|':
                            {
                                if (is_file_port(pt))
                                {
                                    char last_char;
                                    last_char = ' ';
                                    while (true)
                                    {
                                        c = fgetc(port_file(pt));
                                        if (c == EOF)
                                            s7_error(sc, sc->read_error_symbol,
                                                    set_elist_1(sc, wrap_string(sc, "unexpected end of input while reading #|", 40)));
                                        if ((c == '#') &&
                                                (last_char == '|'))
                                            break;
                                        last_char = c;
                                        if (c == '\n')
                                            port_line_number(pt)++;
                                    }
                                    return(token(sc));
                                }
                                else
                                {
                                    const char *str, *orig_str, *p, *pend;

                                    orig_str = (const char *)(port_data(pt) + port_position(pt));
                                    pend = (const char *)(port_data(pt) + port_data_size(pt));
                                    str = orig_str;

                                    while (true)
                                    {
                                        p = strchr(str, (int)'|');
                                        if ((!p) || (p >= pend))
                                        {
                                            port_position(pt) = port_data_size(pt);
                                            s7_error(sc, sc->read_error_symbol,
                                                    set_elist_1(sc, wrap_string(sc, "unexpected end of input while reading #|", 40)));
                                        }
                                        if (p[1] == '#')
                                            break;
                                        str = (const char *)(p + 1);
                                    }
                                    port_position(pt) += (p - orig_str + 2);

                                    /* now count newline inside the comment */
                                    str = (const char *)orig_str;
                                    pend = p;
                                    while (true)
                                    {
                                        p = strchr(str, (int)'\n');
                                        if ((p) && (p < pend))
                                        {
                                            port_line_number(pt)++;
                                            str = (char *)(p + 1);
                                        }
                                        else break;
                                    }
                                    return(token(sc));
                                }
                            }
                    }
                    sc->strbuf[0] = (unsigned char)c;
                    return(TOKEN_SHARP_CONST); /* next stage notices any errors */
                }

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq 0x140(%rsp), %rdi
callq 0xca3d0
movl %eax, 0x13c(%rsp)
movl 0x13c(%rsp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, 0xb8(%rsp)
subl $0x7d, %eax
ja 0xca39c
movq 0xb8(%rsp), %rax
leaq 0x1159ba(%rip), %rcx    # 0x1df1d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x148(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x148(%rsp), %rax
movq 0x1908(%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x148(%rsp), %rdi
leaq 0x124ac7(%rip), %rsi    # 0x1ee32c
movl $0x1e, %edx
callq 0xb880
movq 0xa0(%rsp), %rdi
movq %rax, %rsi
callq 0xc3820
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
jmp 0xca39c
movq 0x14cbe5(%rip), %rcx    # 0x216488
movq 0x148(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movl $0xb, 0x154(%rsp)
jmp 0xca3c1
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
callq 0xc97c0
cmpl $0xb, %eax
jne 0xc98ec
movl $0xd, 0x154(%rsp)
jmp 0xca3c1
movq 0x140(%rsp), %rsi
movl $0x69, %edi
callq 0x15ec0
jmp 0xca39c
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
callq 0xc97c0
cmpl $0xb, %eax
jne 0xc992d
movl $0xe, 0x154(%rsp)
jmp 0xca3c1
movq 0x140(%rsp), %rsi
movl $0x72, %edi
callq 0x15ec0
jmp 0xca39c
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
callq 0x15de0
movq 0x150c28(%rip), %rcx    # 0x21a588
cmpq 0x1c0(%rcx), %rax
jne 0xc99f0
movq 0x140(%rsp), %rdi
callq 0xca3d0
movl %eax, 0x138(%rsp)
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
callq 0x15de0
movq 0x150beb(%rip), %rcx    # 0x21a588
cmpq 0x140(%rcx), %rax
jne 0xc99d9
movq 0x140(%rsp), %rdi
callq 0xca3d0
movq 0x14cace(%rip), %rcx    # 0x216488
movq 0x148(%rsp), %rax
movq %rcx, 0x4d8(%rax)
movl $0xc, 0x154(%rsp)
jmp 0xca3c1
movl 0x138(%rsp), %eax
movq 0x140(%rsp), %rsi
movsbl %al, %edi
callq 0x15ec0
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
callq 0xc97c0
cmpl $0xb, %eax
jne 0xc9a1a
movl $0xc, 0x154(%rsp)
jmp 0xca3c1
movq 0x140(%rsp), %rsi
movl $0x75, %edi
callq 0x15ec0
jmp 0xca39c
movl $0x0, 0x128(%rsp)
movl 0x13c(%rsp), %eax
movb %al, %dl
movq 0x148(%rsp), %rax
movq 0x4b0(%rax), %rax
movl 0x128(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x128(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq 0x153f24(%rip), %rax    # 0x21d998
movslq 0x13c(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
movq %rax, 0x130(%rsp)
movq 0x140(%rsp), %rdi
callq 0xca3d0
movl %eax, 0x12c(%rsp)
cmpl $-0x1, 0x12c(%rsp)
jne 0xc9b1e
movq 0x148(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x148(%rsp), %rax
movq 0x1908(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x148(%rsp), %rdi
leaq 0x12485f(%rip), %rsi    # 0x1ee34b
movl $0x2b, %edx
callq 0xb880
movq 0x88(%rsp), %rdi
movq %rax, %rsi
callq 0xc3820
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x153e73(%rip), %rax    # 0x21d998
movslq 0x12c(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
movq %rax, 0x120(%rsp)
cmpq $0xa, 0x120(%rsp)
jl 0xc9b49
jmp 0xc9c43
movq 0x120(%rsp), %rax
imulq $0xa, 0x130(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x130(%rsp)
cmpq $0x0, 0x130(%rsp)
jle 0xc9b82
cmpq $0x7fff, 0x130(%rsp) # imm = 0x7FFF
jle 0xc9c0d
movq 0x148(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x148(%rsp), %rax
movq 0x1908(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x148(%rsp), %rdi
leaq 0x1247b5(%rip), %rsi    # 0x1ee377
movl $0x1e, %edx
callq 0xb880
movq %rax, 0x70(%rsp)
movq 0x148(%rsp), %rdi
movq 0x130(%rsp), %rsi
callq 0x12430
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq %rax, %rdx
callq 0xb830
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movl 0x12c(%rsp), %eax
movb %al, %dl
movq 0x148(%rsp), %rax
movq 0x4b0(%rax), %rax
movl 0x128(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x128(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xc9a88
movl 0x12c(%rsp), %eax
movb %al, %dl
movq 0x148(%rsp), %rax
movq 0x4b0(%rax), %rax
movl 0x128(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x128(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
cmpl $0x64, 0x12c(%rsp)
je 0xc9ca0
cmpl $0x69, 0x12c(%rsp)
je 0xc9ca0
cmpl $0x72, 0x12c(%rsp)
je 0xc9ca0
cmpl $0x75, 0x12c(%rsp)
jne 0xc9ec0
movq 0x140(%rsp), %rdi
callq 0xca3d0
movl %eax, 0x11c(%rsp)
cmpl $-0x1, 0x11c(%rsp)
jne 0xc9d24
movq 0x148(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x148(%rsp), %rax
movq 0x1908(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x148(%rsp), %rdi
leaq 0x12469b(%rip), %rsi    # 0x1ee396
movl $0x2a, %edx
callq 0xb880
movq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0xc3820
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movl 0x11c(%rsp), %eax
movb %al, %dl
movq 0x148(%rsp), %rax
movq 0x4b0(%rax), %rax
movl 0x128(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x128(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
cmpl $0x28, 0x11c(%rsp)
jne 0xc9ebe
movq 0x130(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0xc9da4
movq 0x110(%rsp), %rcx
leaq 0x14c6ea(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x48(%rsp)
jmp 0xc9e3c
jmp 0xc9da6
movq 0x148(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x148(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xc9dd3
movq 0x148(%rsp), %rdi
callq 0xc670
movq 0x148(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq $0xb, (%rax)
movq 0x110(%rsp), %rcx
movq 0x100(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x100(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x108(%rsp), %rcx
movq 0x148(%rsp), %rax
movq %rcx, 0x4d8(%rax)
cmpl $0x64, 0x12c(%rsp)
jne 0xc9e7a
movl $0xb, 0x154(%rsp)
jmp 0xca3c1
cmpl $0x72, 0x12c(%rsp)
jne 0xc9e94
movl $0xe, 0x154(%rsp)
jmp 0xca3c1
cmpl $0x75, 0x12c(%rsp)
jne 0xc9eae
movl $0xc, 0x154(%rsp)
jmp 0xca3c1
movl $0xd, 0x154(%rsp)
jmp 0xca3c1
jmp 0xc9ec0
movl 0x128(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x12c(%rsp)
cmpl $0x0, 0x12c(%rsp)
jle 0xc9f18
movq 0x148(%rsp), %rax
movq 0x4b0(%rax), %rax
movslq 0x12c(%rsp), %rcx
movb (%rax,%rcx), %al
movq 0x140(%rsp), %rsi
movsbl %al, %edi
callq 0x15ec0
movl 0x12c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x12c(%rsp)
jmp 0xc9ed1
jmp 0xca39c
movq 0x148(%rsp), %rax
movq 0x4b0(%rax), %rax
movb $0x3a, (%rax)
movl $0x4, 0x154(%rsp)
jmp 0xca3c1
movq 0x148(%rsp), %rax
movq 0x1e0(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0xc9fc9
movq 0xe8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x14450
movzbl %al, %eax
cmpl $0x21, %eax
jne 0xc9fb1
movl 0x13c(%rsp), %eax
movb %al, %cl
movq 0x148(%rsp), %rax
movq 0x4b0(%rax), %rax
movb %cl, (%rax)
movl $0xa, 0x154(%rsp)
jmp 0xca3c1
jmp 0xc9fb3
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xe8(%rsp)
jmp 0xc9f5a
movb $0x20, 0xf7(%rsp)
movq 0x140(%rsp), %rdi
callq 0xca3d0
movl %eax, 0x13c(%rsp)
cmpl $-0x1, %eax
je 0xca013
cmpl $0x23, 0x13c(%rsp)
jne 0xca003
movsbl 0xf7(%rsp), %eax
cmpl $0x21, %eax
jne 0xca003
jmp 0xca013
movl 0x13c(%rsp), %eax
movb %al, 0xf7(%rsp)
jmp 0xc9fd1
cmpl $-0x1, 0x13c(%rsp)
jne 0xca083
movq 0x148(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x148(%rsp), %rax
movq 0x1908(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x148(%rsp), %rdi
leaq 0x124367(%rip), %rsi    # 0x1ee3c1
movl $0x28, %edx
callq 0xb880
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xc3820
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0x148(%rsp), %rdi
callq 0xc9560
movl %eax, 0x154(%rsp)
jmp 0xca3c1
movq 0x140(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0xca1aa
movb $0x20, 0xe7(%rsp)
movq 0x140(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x9290
movl %eax, 0x13c(%rsp)
cmpl $-0x1, 0x13c(%rsp)
jne 0xca146
movq 0x148(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x148(%rsp), %rax
movq 0x1908(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x148(%rsp), %rdi
leaq 0x1242cd(%rip), %rsi    # 0x1ee3ea
movl $0x28, %edx
callq 0xb880
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xc3820
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
cmpl $0x23, 0x13c(%rsp)
jne 0xca15f
movsbl 0xe7(%rsp), %eax
cmpl $0x7c, %eax
jne 0xca15f
jmp 0xca191
movl 0x13c(%rsp), %eax
movb %al, 0xe7(%rsp)
cmpl $0xa, 0x13c(%rsp)
jne 0xca18c
movq 0x140(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0xca0ba
movq 0x148(%rsp), %rdi
callq 0xc9560
movl %eax, 0x154(%rsp)
jmp 0xca3c1
movq 0x140(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x140(%rsp), %rcx
addq 0x20(%rcx), %rax
movq %rax, 0xd0(%rsp)
movq 0x140(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x140(%rsp), %rcx
addq 0x18(%rcx), %rax
movq %rax, 0xc0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x7c, %esi
callq 0x91d0
movq %rax, 0xc8(%rsp)
cmpq $0x0, 0xc8(%rsp)
je 0xca231
movq 0xc8(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jb 0xca2ad
movq 0x140(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x140(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x148(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x148(%rsp), %rax
movq 0x1908(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x148(%rsp), %rax
movq %rax, (%rsp)
movq 0x148(%rsp), %rdi
leaq 0x124165(%rip), %rsi    # 0x1ee3ea
movl $0x28, %edx
callq 0xb880
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc3820
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x2f940
movq 0xc8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x23, %eax
jne 0xca2c0
jmp 0xca2d9
movq 0xc8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd8(%rsp)
jmp 0xca1fa
movq 0xc8(%rsp), %rcx
movq 0xd0(%rsp), %rax
subq %rax, %rcx
addq $0x2, %rcx
movq 0x140(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq 0xd0(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xd8(%rsp), %rdi
movl $0xa, %esi
callq 0x91d0
movq %rax, 0xc8(%rsp)
cmpq $0x0, 0xc8(%rsp)
je 0xca382
movq 0xc8(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jae 0xca382
movq 0x140(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0xc8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd8(%rsp)
jmp 0xca384
jmp 0xca386
jmp 0xca320
movq 0x148(%rsp), %rdi
callq 0xc9560
movl %eax, 0x154(%rsp)
jmp 0xca3c1
movl 0x13c(%rsp), %eax
movb %al, %cl
movq 0x148(%rsp), %rax
movq 0x4b0(%rax), %rax
movb %cl, (%rax)
movl $0xa, 0x154(%rsp)
movl 0x154(%rsp), %eax
addq $0x158, %rsp            # imm = 0x158
retq