// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: number_to_string_with_radix
static block_t *number_to_string_with_radix(s7_scheme *sc, s7_pointer obj, int32_t radix, s7_int width, s7_int precision, char float_choice, s7_int *nlen)
    {
        /* called by s7_number_to_string (char*), g_number_to_string (strp), number_to_string_p_pp (strp), format_number (strp basically) */
        /* the rest of s7 assumes nlen is set to the correct length */
        block_t *b;
        char *p;
        s7_int len, str_len;

#if WITH_GMP
        if (s7_is_bignum(obj))
        {
            p = big_number_to_string_with_radix(obj, radix, width, nlen, P_WRITE);
            b = string_to_block(sc, p, *nlen);
            free(p);
            return(b);
        }
        /* this ignores precision because it's way too hard to get the mpfr string to look like
         *   C's output -- we either have to call mpfr_get_str twice (the first time just to
         *   find out what the exponent is and how long the string actually is), or we have
         *   to do messy string manipulations.  So (format #f "",3F" pi) ignores the "3" and
         *   prints the full string.
         */
#endif

        if (radix == 10)
        {
            p = number_to_string_base_10(sc, obj, width, precision, float_choice, nlen, P_WRITE);
            return(string_to_block(sc, p, *nlen));
        }

        switch (type(obj))
        {
            case T_INTEGER:
                {
                    size_t len1;
                    b = mallocate(sc, (128 + width));
                    p = (char *)block_data(b);
                    len1 = integer_to_string_any_base(p, integer(obj), radix);
                    if ((size_t)width > len1)
                    {
                        size_t start;
                        start = width - len1;
                        memmove((void *)(p + start), (void *)p, len1);
                        memset((void *)p, (int)' ', start);
                        p[width] = '\0';
                        *nlen = width;
                    }
                    else *nlen = len1;
                    return(b);
                }

            case T_RATIO:
                {
                    size_t len1, len2;
                    str_len = 256 + width;
                    b = mallocate(sc, str_len);
                    p = (char *)block_data(b);
                    len1 = integer_to_string_any_base(p, numerator(obj), radix);
                    p[len1] = '/';
                    len2 = integer_to_string_any_base((char *)(p + len1 + 1), denominator(obj), radix);
                    len = len1 + 1 + len2;
                    p[len] = '\0';
                }
                break;

            case T_REAL:
                {
                    int32_t i;
                    s7_int int_part;
                    s7_double x, frac_part, min_frac, base;
                    bool sign = false;
                    char n[128], d[256];

                    x = real(obj);

                    if (is_NaN(x))
                        return(string_to_block(sc, "+nan.0", *nlen = 6));
                    if (is_inf(x))
                    {
                        if (x < 0.0)
                            return(string_to_block(sc, "-inf.0", *nlen = 6));
                        return(string_to_block(sc, "+inf.0", *nlen = 6));
                    }

                    if (x < 0.0)
                    {
                        sign = true;
                        x = -x;
                    }

                    if (x > 1.0e18) /* i.e. close to or greater than most-positive-fixnum (9.22e18), so the code below is unlikely to work, (format #f "~X" 1e19) */
                    {
                        int32_t ep;
                        block_t *b1;
                        len = 0;
                        ep = (int32_t)floor(log(x) / log((double)radix));
                        real(sc->real_wrapper3) = x / pow((double)radix, (double)ep); /* divide it down to one digit, then the fractional part */
                        b = number_to_string_with_radix(sc, sc->real_wrapper3, radix, width, precision, float_choice, &len);
                        b1 = mallocate(sc, len + 8);
                        p = (char *)block_data(b1);
                        p[0] = '\0';
                        (*nlen) = catstrs(p, len + 8, (sign) ? "-" : "", (char *)block_data(b), "e", integer_to_string_no_length(sc, ep), NULL);
                        liberate(sc, b);
                        return(b1);
                    }

                    int_part = (s7_int)floor(x);
                    frac_part = x - int_part;
                    integer_to_string_any_base(n, int_part, radix);
                    min_frac = dpow(radix, -precision);

                    /* doesn't this assume precision < 128/256 and that we can fit in 256 digits (1e308)? */
                    for (i = 0, base = radix; (i < precision) && (frac_part > min_frac); i++, base *= radix)
                    {
                        s7_int ipart;
                        ipart = (s7_int)(frac_part * base);
                        if (ipart >= radix)         /* rounding confusion */
                            ipart = radix - 1;
                        frac_part -= (ipart / base);
                        if (ipart < 10)
                            d[i] = (char)('0' + ipart);
                        else d[i] = (char)('a' + ipart -  10);
                    }
                    if (i == 0)
                        d[i++] = '0';
                    d[i] = '\0';
                    b = mallocate(sc, 256);
                    p = (char *)block_data(b);
                    p[0] = '\0';
                    len = catstrs(p, 256, (sign) ? "-" : "", n, ".", d, NULL);
                    str_len = 256;
                }
                break;

            default:
                {
                    block_t *n, *d;
                    char *dp;
                    real(sc->real_wrapper3) = real_part(obj);
                    n = number_to_string_with_radix(sc, sc->real_wrapper3, radix, 0, precision, float_choice, &len); /* include floatify */
                    real(sc->real_wrapper4) = imag_part(obj);
                    d = number_to_string_with_radix(sc, sc->real_wrapper4, radix, 0, precision, float_choice, &len);
                    dp = (char *)block_data(d);
                    b = mallocate(sc, 512);
                    p = (char *)block_data(b);
                    p[0] = '\0';
                    len = catstrs(p, 512, (char *)block_data(n), ((dp[0] == '+') || (dp[0] == '-')) ? "" : "+", dp, "i", NULL);
                    str_len = 512;
                    liberate(sc, n);
                    liberate(sc, d);
                }
                break;
        }

        if (width > len)
        {
            s7_int spaces;
            if (width >= str_len)
            {
                str_len = width + 1;
                b = reallocate(sc, b, str_len);
                p = (char *)block_data(b);
            }
            spaces = width - len;
            p[width] = '\0';
            memmove((void *)(p + spaces), (void *)p, len);
            memset((void *)p, (int)' ', spaces);
            (*nlen) = width;
        }
        else (*nlen) = len;
        return(b);
    }

// Assembly:
subq $0x2c8, %rsp            # imm = 0x2C8
movb %r9b, %al
movq 0x2d0(%rsp), %r9
movq %rdi, 0x2b8(%rsp)
movq %rsi, 0x2b0(%rsp)
movl %edx, 0x2ac(%rsp)
movq %rcx, 0x2a0(%rsp)
movq %r8, 0x298(%rsp)
movb %al, 0x297(%rsp)
cmpl $0xa, 0x2ac(%rsp)
jne 0x12a6e
movq 0x2b8(%rsp), %rdi
movq 0x2b0(%rsp), %rsi
movq 0x2a0(%rsp), %rdx
movq 0x298(%rsp), %rcx
movb 0x297(%rsp), %al
movq 0x2d0(%rsp), %r9
movsbl %al, %r8d
movl $0x1, (%rsp)
callq 0xc66e0
movq %rax, 0x280(%rsp)
movq 0x2b8(%rsp), %rdi
movq 0x280(%rsp), %rsi
movq 0x2d0(%rsp), %rax
movq (%rax), %rdx
callq 0xc6e90
movq %rax, 0x2c0(%rsp)
jmp 0x1358a
movq 0x2b0(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x54(%rsp)
subl $0xb, %eax
je 0x12aa5
jmp 0x12a84
movl 0x54(%rsp), %eax
subl $0xc, %eax
je 0x12bc2
jmp 0x12a93
movl 0x54(%rsp), %eax
subl $0xd, %eax
je 0x12cad
jmp 0x132a5
movq 0x2b8(%rsp), %rdi
movq 0x2a0(%rsp), %rsi
addq $0x80, %rsi
callq 0xaa80
movq %rax, 0x288(%rsp)
movq 0x288(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x280(%rsp)
movq 0x280(%rsp), %rdi
movq 0x2b0(%rsp), %rax
movq 0x8(%rax), %rsi
movl 0x2ac(%rsp), %edx
callq 0xc6f00
movq %rax, 0x268(%rsp)
movq 0x2a0(%rsp), %rax
cmpq 0x268(%rsp), %rax
jbe 0x12b9a
movq 0x2a0(%rsp), %rax
subq 0x268(%rsp), %rax
movq %rax, 0x260(%rsp)
movq 0x280(%rsp), %rdi
addq 0x260(%rsp), %rdi
movq 0x280(%rsp), %rsi
movq 0x268(%rsp), %rdx
callq 0x9550
movq 0x280(%rsp), %rdi
movq 0x260(%rsp), %rdx
movl $0x20, %esi
callq 0x9270
movq 0x280(%rsp), %rax
movq 0x2a0(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x2a0(%rsp), %rcx
movq 0x2d0(%rsp), %rax
movq %rcx, (%rax)
jmp 0x12bad
movq 0x268(%rsp), %rcx
movq 0x2d0(%rsp), %rax
movq %rcx, (%rax)
movq 0x288(%rsp), %rax
movq %rax, 0x2c0(%rsp)
jmp 0x1358a
movq 0x2a0(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x270(%rsp)
movq 0x2b8(%rsp), %rdi
movq 0x270(%rsp), %rsi
callq 0xaa80
movq %rax, 0x288(%rsp)
movq 0x288(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x280(%rsp)
movq 0x280(%rsp), %rdi
movq 0x2b0(%rsp), %rax
movq 0x8(%rax), %rsi
movl 0x2ac(%rsp), %edx
callq 0xc6f00
movq %rax, 0x258(%rsp)
movq 0x280(%rsp), %rax
movq 0x258(%rsp), %rcx
movb $0x2f, (%rax,%rcx)
movq 0x280(%rsp), %rdi
addq 0x258(%rsp), %rdi
addq $0x1, %rdi
movq 0x2b0(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x2ac(%rsp), %edx
callq 0xc6f00
movq %rax, 0x250(%rsp)
movq 0x258(%rsp), %rax
addq $0x1, %rax
addq 0x250(%rsp), %rax
movq %rax, 0x278(%rsp)
movq 0x280(%rsp), %rax
movq 0x278(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x1347c
movb $0x0, 0x21f(%rsp)
movq 0x2b0(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x238(%rsp)
movsd 0x238(%rsp), %xmm0
callq 0x13860
testb $0x1, %al
jne 0x12cdf
jmp 0x12d14
movq 0x2b8(%rsp), %rdi
movq 0x2d0(%rsp), %rax
movq $0x6, (%rax)
leaq 0x1db41f(%rip), %rsi    # 0x1ee11c
movl $0x6, %edx
callq 0xc6e90
movq %rax, 0x2c0(%rsp)
jmp 0x1358a
movsd 0x238(%rsp), %xmm1
movaps %xmm1, %xmm0
movaps 0x1ced79(%rip), %xmm2   # 0x1e1aa0
pand %xmm2, %xmm0
movq %xmm1, %rdx
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %eax, %ecx
movsd 0x1cec27(%rip), %xmm1   # 0x1e1970
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x12dd9
xorps %xmm0, %xmm0
ucomisd 0x238(%rsp), %xmm0
jbe 0x12da4
movq 0x2b8(%rsp), %rdi
movq 0x2d0(%rsp), %rax
movq $0x6, (%rax)
leaq 0x1db396(%rip), %rsi    # 0x1ee123
movl $0x6, %edx
callq 0xc6e90
movq %rax, 0x2c0(%rsp)
jmp 0x1358a
movq 0x2b8(%rsp), %rdi
movq 0x2d0(%rsp), %rax
movq $0x6, (%rax)
leaq 0x1db368(%rip), %rsi    # 0x1ee12a
movl $0x6, %edx
callq 0xc6e90
movq %rax, 0x2c0(%rsp)
jmp 0x1358a
xorps %xmm0, %xmm0
ucomisd 0x238(%rsp), %xmm0
jbe 0x12e18
movb $0x1, 0x21f(%rsp)
movsd 0x238(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x238(%rsp)
movsd 0x238(%rsp), %xmm0
movsd 0x1ceb4f(%rip), %xmm1   # 0x1e1978
ucomisd %xmm1, %xmm0
jbe 0x1301f
movq $0x0, 0x278(%rsp)
movsd 0x238(%rsp), %xmm0
callq 0x92b0
movsd %xmm0, 0x20(%rsp)
cvtsi2sdl 0x2ac(%rsp), %xmm0
callq 0x92b0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x95f0
cvttsd2si %xmm0, %eax
movl %eax, 0x8c(%rsp)
movsd 0x238(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
cvtsi2sdl 0x2ac(%rsp), %xmm0
cvtsi2sdl 0x8c(%rsp), %xmm1
callq 0x9160
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x2b8(%rsp), %rax
movq 0x1f28(%rax), %rax
movsd %xmm0, 0x8(%rax)
movq 0x2b8(%rsp), %rdi
movq 0x2b8(%rsp), %rax
movq 0x1f28(%rax), %rsi
movl 0x2ac(%rsp), %edx
movq 0x2a0(%rsp), %rcx
movq 0x298(%rsp), %r8
leaq 0x278(%rsp), %rax
movsbl 0x297(%rsp), %r9d
movq %rax, (%rsp)
callq 0x129b0
movq %rax, 0x288(%rsp)
movq 0x2b8(%rsp), %rdi
movq 0x278(%rsp), %rsi
addq $0x8, %rsi
callq 0xaa80
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x280(%rsp)
movq 0x280(%rsp), %rax
movb $0x0, (%rax)
movq 0x280(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x278(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movb 0x21f(%rsp), %dl
leaq 0x1e1539(%rip), %rax    # 0x1f44b9
leaq 0x1df50a(%rip), %rcx    # 0x1f2491
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x288(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x2b8(%rsp), %rdi
movslq 0x8c(%rsp), %rsi
callq 0xc70d0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq %rax, %r9
leaq 0x1db163(%rip), %r8     # 0x1ee139
xorl %eax, %eax
movq $0x0, (%rsp)
movb $0x0, %al
callq 0xabd0
movq %rax, %rcx
movq 0x2d0(%rsp), %rax
movq %rcx, (%rax)
movq 0x2b8(%rsp), %rdi
movq 0x288(%rsp), %rsi
callq 0xb230
movq 0x80(%rsp), %rax
movq %rax, 0x2c0(%rsp)
jmp 0x1358a
movsd 0x238(%rsp), %xmm0
callq 0x95f0
cvttsd2si %xmm0, %rax
movq %rax, 0x240(%rsp)
movsd 0x238(%rsp), %xmm0
cvtsi2sdq 0x240(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x230(%rsp)
leaq 0x190(%rsp), %rdi
movq 0x240(%rsp), %rsi
movl 0x2ac(%rsp), %edx
callq 0xc6f00
movl 0x2ac(%rsp), %edi
xorl %eax, %eax
subq 0x298(%rsp), %rax
movl %eax, %esi
callq 0xc71d0
movsd %xmm0, 0x228(%rsp)
movl $0x0, 0x24c(%rsp)
cvtsi2sdl 0x2ac(%rsp), %xmm0
movsd %xmm0, 0x220(%rsp)
movslq 0x24c(%rsp), %rcx
xorl %eax, %eax
cmpq 0x298(%rsp), %rcx
movb %al, 0x1f(%rsp)
jge 0x130e5
movsd 0x230(%rsp), %xmm0
ucomisd 0x228(%rsp), %xmm0
seta %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x130f2
jmp 0x131cc
movsd 0x230(%rsp), %xmm0
mulsd 0x220(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movslq 0x2ac(%rsp), %rcx
cmpq %rcx, %rax
jl 0x13131
movl 0x2ac(%rsp), %eax
subl $0x1, %eax
cltq
movq %rax, 0x78(%rsp)
cvtsi2sdq 0x78(%rsp), %xmm1
divsd 0x220(%rsp), %xmm1
movsd 0x230(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x230(%rsp)
cmpq $0xa, 0x78(%rsp)
jge 0x1317b
movq 0x78(%rsp), %rax
addq $0x30, %rax
movb %al, %cl
movslq 0x24c(%rsp), %rax
movb %cl, 0x90(%rsp,%rax)
jmp 0x13199
movq 0x78(%rsp), %rax
addq $0x61, %rax
subq $0xa, %rax
movb %al, %cl
movslq 0x24c(%rsp), %rax
movb %cl, 0x90(%rsp,%rax)
jmp 0x1319b
movl 0x24c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24c(%rsp)
cvtsi2sdl 0x2ac(%rsp), %xmm0
mulsd 0x220(%rsp), %xmm0
movsd %xmm0, 0x220(%rsp)
jmp 0x130b4
cmpl $0x0, 0x24c(%rsp)
jne 0x131f3
movl 0x24c(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x24c(%rsp)
cltq
movb $0x30, 0x90(%rsp,%rax)
movslq 0x24c(%rsp), %rax
movb $0x0, 0x90(%rsp,%rax)
movq 0x2b8(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0xaa80
movq %rax, 0x288(%rsp)
movq 0x288(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x280(%rsp)
movq 0x280(%rsp), %rax
movb $0x0, (%rax)
movq 0x280(%rsp), %rdi
movb 0x21f(%rsp), %cl
leaq 0x1e1268(%rip), %rdx    # 0x1f44b9
leaq 0x1df239(%rip), %rax    # 0x1f2491
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x190(%rsp), %rcx
leaq 0x90(%rsp), %r9
movl $0x100, %esi            # imm = 0x100
leaq 0x1d65cb(%rip), %r8     # 0x1e9846
xorl %eax, %eax
movq $0x0, (%rsp)
movb $0x0, %al
callq 0xabd0
movq %rax, 0x278(%rsp)
movq $0x100, 0x270(%rsp) # imm = 0x100
jmp 0x1347c
movq 0x2b0(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x2b8(%rsp), %rax
movq 0x1f28(%rax), %rax
movsd %xmm0, 0x8(%rax)
movq 0x2b8(%rsp), %rdi
movq 0x2b8(%rsp), %rax
movq 0x1f28(%rax), %rsi
movl 0x2ac(%rsp), %edx
movq 0x298(%rsp), %r8
xorl %eax, %eax
movl %eax, %ecx
leaq 0x278(%rsp), %rax
movsbl 0x297(%rsp), %r9d
movq %rax, (%rsp)
callq 0x129b0
movq %rax, 0x70(%rsp)
movq 0x2b0(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x2b8(%rsp), %rax
movq 0x1f30(%rax), %rax
movsd %xmm0, 0x8(%rax)
movq 0x2b8(%rsp), %rdi
movq 0x2b8(%rsp), %rax
movq 0x1f30(%rax), %rsi
movl 0x2ac(%rsp), %edx
movq 0x298(%rsp), %r8
xorl %eax, %eax
movl %eax, %ecx
leaq 0x278(%rsp), %rax
movsbl 0x297(%rsp), %r9d
movq %rax, (%rsp)
callq 0x129b0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x2b8(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0xaa80
movq %rax, 0x288(%rsp)
movq 0x288(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x280(%rsp)
movq 0x280(%rsp), %rax
movb $0x0, (%rax)
movq 0x280(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, 0x1e(%rsp)
je 0x133fd
movq 0x60(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, 0x1e(%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movb 0x1e(%rsp), %sil
leaq 0x1d8f46(%rip), %rcx    # 0x1ec359
leaq 0x1e109f(%rip), %rax    # 0x1f44b9
testb $0x1, %sil
cmovneq %rax, %rcx
movq 0x60(%rsp), %r8
movl $0x200, %esi            # imm = 0x200
leaq 0x1df06f(%rip), %r9     # 0x1f24a2
xorl %eax, %eax
movq $0x0, (%rsp)
movb $0x0, %al
callq 0xabd0
movq %rax, 0x278(%rsp)
movq $0x200, 0x270(%rsp) # imm = 0x200
movq 0x2b8(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xb230
movq 0x2b8(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xb230
movq 0x2a0(%rsp), %rax
cmpq 0x278(%rsp), %rax
jle 0x13567
movq 0x2a0(%rsp), %rax
cmpq 0x270(%rsp), %rax
jl 0x134f0
movq 0x2a0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x270(%rsp)
movq 0x2b8(%rsp), %rdi
movq 0x288(%rsp), %rsi
movq 0x270(%rsp), %rdx
callq 0xbb60
movq %rax, 0x288(%rsp)
movq 0x288(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x280(%rsp)
movq 0x2a0(%rsp), %rax
subq 0x278(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x280(%rsp), %rax
movq 0x2a0(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x280(%rsp), %rdi
addq 0x58(%rsp), %rdi
movq 0x280(%rsp), %rsi
movq 0x278(%rsp), %rdx
callq 0x9550
movq 0x280(%rsp), %rdi
movq 0x58(%rsp), %rdx
movl $0x20, %esi
callq 0x9270
movq 0x2a0(%rsp), %rcx
movq 0x2d0(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1357a
movq 0x278(%rsp), %rcx
movq 0x2d0(%rsp), %rax
movq %rcx, (%rax)
movq 0x288(%rsp), %rax
movq %rax, 0x2c0(%rsp)
movq 0x2c0(%rsp), %rax
addq $0x2c8, %rsp            # imm = 0x2C8
retq
nopw (%rax,%rax)