// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: make_atom
static s7_pointer make_atom(s7_scheme *sc, char *q, int32_t radix, bool want_symbol, bool with_error)
    {
        /* make symbol or number from string */
#define IS_DIGIT(Chr, Rad) (digits[(uint8_t)Chr] < Rad)

        char c, *p;
        bool has_dec_point1 = false;

        p = q;
        c = *p++;

        /* a number starts with + - . or digit, but so does 1+ for example (and there's also nan.0 and inf.0) */

        switch (c)
        {
            case '#':
                return(make_sharp_constant(sc, p, with_error)); /* make_sharp_constant expects the '#' to be removed */

            case '+':
            case '-':
                c = *p++;
                if (c == '.')
                {
                    has_dec_point1 = true;
                    c = *p++;
                }
                if (!c)
                    return((want_symbol) ? make_symbol(sc, q) : sc->F);
                if (!IS_DIGIT(c, radix))
                {
                    if (has_dec_point1)
                        return((want_symbol) ? make_symbol(sc, q) : sc->F);
                    if (c == 'n')
                    {
                        if (local_strcmp(p, "an.0"))      /* +nan.0 */
                            return(real_NaN);
                        if ((local_strncmp(p, "an.0", 4)) &&
                                ((p[4] == '+') || (p[4] == '-')))
                            return(nan1_or_bust(sc, NAN, p, q, radix, want_symbol));
                    }
                    if (c == 'i')
                    {
                        if (local_strcmp(p, "nf.0"))  /* +inf.0 */
                            return((q[0] == '+') ? real_infinity : real_minus_infinity);
                        if ((local_strncmp(p, "nf.0", 4)) &&
                                ((p[4] == '+') || (p[4] == '-')))
                            return(nan1_or_bust(sc, (q[0] == '-') ? -INFINITY : INFINITY, p, q, radix, want_symbol));
                    }
                    return((want_symbol) ? make_symbol(sc, q) : sc->F);
                }
                break;

            case '.':
                has_dec_point1 = true;
                c = *p++;

                if ((!c) || (!IS_DIGIT(c, radix)))
                    return((want_symbol) ? make_symbol(sc, q) : sc->F);
                break;

            case 'n':
                if (local_strcmp(p, "an.0"))      /* nan.0 */
                    return(real_NaN);
                return((want_symbol) ? make_symbol(sc, q) : sc->F);

            case 'i':
                if (local_strcmp(p, "nf.0"))      /* inf.0 */
                    return(real_infinity);
                return((want_symbol) ? make_symbol(sc, q) : sc->F);

            case '0':        /* these two are always digits */
            case '1':
                break;

            default:
                if (!IS_DIGIT(c, radix))
                    return((want_symbol) ? make_symbol(sc, q) : sc->F);
                break;
        }

        /* now it's possibly a number -- the first character(s) could be part of a number in the current radix */
        {
            char *slash1 = NULL, *slash2 = NULL, *plus = NULL, *ex1 = NULL, *ex2 = NULL;
            bool has_i = false, has_dec_point2 = false;
            int32_t has_plus_or_minus = 0, current_radix;
#if (!WITH_GMP)
            bool overflow = false; /* for string_to_integer */
#endif
            current_radix = radix;  /* current_radix is 10 for the exponent portions, but radix for all the rest */

            for ( ; (c = *p) != 0; ++p)
            {
                /* what about embedded null? (string->number (string #\1 (integer->char 0) #\0))
                 *   currently we stop and return 1, but Guile returns #f
                 */
                if (!IS_DIGIT(c, current_radix))         /* moving this inside the switch statement was much slower */
                {
                    current_radix = radix;

                    switch (c)
                    {
                        /* -------- decimal point -------- */
                        case '.':
                            if ((!IS_DIGIT(p[1], current_radix)) &&
                                    (!IS_DIGIT(p[-1], current_radix)))
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);

                            if (has_plus_or_minus == 0)
                            {
                                if ((has_dec_point1) || (slash1))
                                    return((want_symbol) ? make_symbol(sc, q) : sc->F);
                                has_dec_point1 = true;
                            }
                            else
                            {
                                if ((has_dec_point2) || (slash2))
                                    return((want_symbol) ? make_symbol(sc, q) : sc->F);
                                has_dec_point2 = true;
                            }
                            continue;

                            /* -------- exponent marker -------- */
#if WITH_EXTRA_EXPONENT_MARKERS
                            /* 1st 3d-perspective 0.0f 128.0f 3d 1s -- in 2 million lines of public scheme code, not one actual use! */
                        case 's': case 'S':
                        case 'd': case 'D':
                        case 'f': case 'F':
                        case 'l': case 'L':
#endif
                        case 'e': case 'E':
                            if (current_radix > 10) /* see above */
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);
                            /* fall through -- if '@' used, radices>10 are ok */

                        case '@':
                            current_radix = 10;

                            if (((ex1) ||
                                        (slash1)) &&
                                    (has_plus_or_minus == 0)) /* ee */
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);

                            if (((ex2) ||
                                        (slash2)) &&
                                    (has_plus_or_minus != 0)) /* 1+1.0ee */
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);

                            if ((!IS_DIGIT(p[-1], radix)) && /* was current_radix but that's always 10! */
                                    (p[-1] != '.'))
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);

                            if (has_plus_or_minus == 0)
                            {
                                ex1 = p;
                                has_dec_point1 = true; /* decimal point illegal from now on */
                            }
                            else
                            {
                                ex2 = p;
                                has_dec_point2 = true;
                            }
                            p++;
                            if ((*p == '-') || (*p == '+')) p++;
                            if (IS_DIGIT(*p, current_radix))
                                continue;
                            break;

                            /* -------- internal + or - -------- */
                        case '+':
                        case '-':
                            if (has_plus_or_minus != 0) /* already have the separator */
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);

                            if (c == '+') has_plus_or_minus = 1; else has_plus_or_minus = -1;
                            plus = (char *)(p + 1);
                            /* now check for nan/inf as imaginary part */

                            if ((plus[0] == 'n') &&
                                    (local_strcmp(plus, "nan.0i")))
                                return(nan2_or_bust(sc, NAN, p, q, radix, want_symbol));
                            if ((plus[0] == 'i') &&
                                    (local_strcmp(plus, "inf.0i")))
                                return(nan2_or_bust(sc, (c == '+') ? INFINITY : -INFINITY, p, q, radix, want_symbol));
                            continue;

                            /* ratio marker */
                        case '/':
                            if ((has_plus_or_minus == 0) &&
                                    ((ex1) ||
                                     (slash1) ||
                                     (has_dec_point1)))
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);

                            if ((has_plus_or_minus != 0) &&
                                    ((ex2) ||
                                     (slash2) ||
                                     (has_dec_point2)))
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);

                            if (has_plus_or_minus == 0)
                                slash1 = (char *)(p + 1);
                            else slash2 = (char *)(p + 1);

                            if ((!IS_DIGIT(p[1], current_radix)) ||
                                    (!IS_DIGIT(p[-1], current_radix)))
                                return((want_symbol) ? make_symbol(sc, q) : sc->F);

                            continue;

                            /* -------- i for the imaginary part -------- */
                        case 'i':
                            if ((has_plus_or_minus != 0) &&
                                    (!has_i))
                            {
                                has_i = true;
                                continue;
                            }
                            break;

                        default:
                            break;
                    }
                    return((want_symbol) ? make_symbol(sc, q) : sc->F);
                }
            }

            if ((has_plus_or_minus != 0) &&        /* that is, we have an internal + or - */
                    (!has_i))                          /*   but no i for the imaginary part */
                return((want_symbol) ? make_symbol(sc, q) : sc->F);

            if (has_i)
            {
#if (!WITH_GMP)
                s7_double rl = 0.0, im = 0.0;
#else
                char e1 = 0, e2 = 0;
#endif
                s7_pointer result;
                s7_int len;
                char ql1, pl1;

                len = safe_strlen(q);

                if (q[len - 1] != 'i')
                    return((want_symbol) ? make_symbol(sc, q) : sc->F);

                /* save original string */
                ql1 = q[len - 1];
                pl1 = (*(plus - 1));
#if WITH_GMP
                if (ex1) {e1 = *ex1; (*ex1) = '@';} /* for mpfr */
                if (ex2) {e2 = *ex2; (*ex2) = '@';}
#endif

                /* look for cases like 1+i */
                if ((q[len - 2] == '+') || (q[len - 2] == '-'))
                    q[len - 1] = '1';
                else q[len - 1] = '\0'; /* remove 'i' */

                (*((char *)(plus - 1))) = '\0';

#if (!WITH_GMP)
                if ((has_dec_point1) ||
                        (ex1))
                {
                    /* (string->number "1100.1+0.11i" 2) -- need to split into 2 honest reals before passing to non-base-10 str->dbl */
                    rl = string_to_double_with_radix(q, radix, ignored);
                }
                else
                {
                    if (slash1)
                    {
                        /* here the overflow could be innocuous if it's in the denominator and the numerator is 0
                         *    0/100000000000000000000000000000000000000-0i
                         */
                        s7_int num, den;
                        num = string_to_integer(q, radix, &overflow);
                        den = string_to_integer(slash1, radix, &overflow);
                        if (den == 0)
                            rl = NAN;
                        else
                        {
                            if (num == 0)
                            {
                                rl = 0.0;
                                overflow = false;
                            }
                            else rl = (s7_double)num / (s7_double)den;
                        }
                    }
                    else rl = (s7_double)string_to_integer(q, radix, &overflow);
                    if (overflow) return(real_NaN);
                }
                if (rl == -0.0) rl = 0.0;

                if ((has_dec_point2) ||
                        (ex2))
                    im = string_to_double_with_radix(plus, radix, ignored);
                else
                {
                    if (slash2)
                    {
                        /* same as above: 0-0/100000000000000000000000000000000000000i */
                        s7_int num, den;
                        num = string_to_integer(plus, radix, &overflow);
                        den = string_to_integer(slash2, radix, &overflow);
                        if (den == 0)
                            im = NAN;
                        else
                        {
                            if (num == 0)
                            {
                                im = 0.0;
                                overflow = false;
                            }
                            else im = (s7_double)num / (s7_double)den;
                        }
                    }
                    else im = (s7_double)string_to_integer(plus, radix, &overflow);
                    if (overflow) return(real_NaN);
                }
                if ((has_plus_or_minus == -1) &&
                        (im != 0.0))
                    im = -im;
                result = s7_make_complex(sc, rl, im);
#else
                result = string_to_either_complex(sc, q, slash1, ex1, has_dec_point1, plus, slash2, ex2, has_dec_point2, radix, has_plus_or_minus);
#endif

                /* restore original string */
                q[len - 1] = ql1;
                (*((char *)(plus - 1))) = pl1;
#if WITH_GMP
                if (ex1) (*ex1) = e1;
                if (ex2) (*ex2) = e2;
#endif
                return(result);
            }

            /* not complex */
            if ((has_dec_point1) ||
                    (ex1))
            {
                s7_pointer result;

                if (slash1)  /* not complex, so slash and "." is not a number */
                    return((want_symbol) ? make_symbol(sc, q) : sc->F);

#if (!WITH_GMP)
                result = make_real(sc, string_to_double_with_radix(q, radix, ignored));
#else
                {
                    char old_e = 0;
                    if (ex1)
                    {
                        old_e = (*ex1);
                        (*ex1) = '@';
                    }
                    result = string_to_either_real(sc, q, radix);
                    if (ex1)
                        (*ex1) = old_e;
                }
#endif
                return(result);
            }

            /* not real */
            if (slash1)
#if (!WITH_GMP)
            {
                s7_int n, d;

                n = string_to_integer(q, radix, &overflow);
                d = string_to_integer(slash1, radix, &overflow);

                if ((n == 0) && (d != 0))                        /* 0/100000000000000000000000000000000000000 */
                    return(small_int(0));
                if ((d == 0) || (overflow))
                    return(real_NaN);
                /* it would be neat to return 1 from 10000000000000000000000000000/10000000000000000000000000000
                 *   but q is the entire number ('/' included) and slash1 is the stuff after the '/', and every
                 *   big number comes through here, so there's no clean and safe way to check that q == slash1.
                 */
                return(s7_make_ratio(sc, n, d));
            }
#else
            return(string_to_either_ratio(sc, q, slash1, radix));
#endif

            /* integer */
#if (!WITH_GMP)
            {
                s7_int x;
                x = string_to_integer(q, radix, &overflow);
                if (overflow)
                    return((q[0] == '-') ? real_minus_infinity : real_infinity);
                return(make_integer(sc, x));
            }
#else
            return(string_to_either_integer(sc, q, radix));
#endif
        }
    }

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movb %r8b, %al
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movl %edx, 0x1ec(%rsp)
andb $0x1, %cl
movb %cl, 0x1eb(%rsp)
andb $0x1, %al
movb %al, 0x1ea(%rsp)
movb $0x0, 0x1df(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x1e0(%rsp)
movb (%rax), %al
movb %al, 0x1e9(%rsp)
movsbl 0x1e9(%rsp), %eax
addl $-0x23, %eax
movl %eax, %ecx
movq %rcx, 0xf8(%rsp)
subl $0x4b, %eax
ja 0xcaa9b
movq 0xf8(%rsp), %rax
leaq 0x114ec0(%rip), %rcx    # 0x1df3c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x1f8(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movb 0x1ea(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xcbc60
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1e0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1e0(%rsp)
movb (%rax), %al
movb %al, 0x1e9(%rsp)
movsbl 0x1e9(%rsp), %eax
cmpl $0x2e, %eax
jne 0xca594
movb $0x1, 0x1df(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1e0(%rsp)
movb (%rax), %al
movb %al, 0x1e9(%rsp)
cmpb $0x0, 0x1e9(%rsp)
jne 0xca5f3
testb $0x1, 0x1eb(%rsp)
je 0xca5c7
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0xf0(%rsp)
jmp 0xca5de
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x15339e(%rip), %rax    # 0x21d998
movzbl 0x1e9(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1ec(%rsp), %eax
jl 0xca8e7
testb $0x1, 0x1df(%rsp)
je 0xca671
testb $0x1, 0x1eb(%rsp)
je 0xca645
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0xe8(%rsp)
jmp 0xca65c
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movsbl 0x1e9(%rsp), %eax
cmpl $0x6e, %eax
jne 0xca739
movq 0x1e0(%rsp), %rdi
leaq 0x123a8d(%rip), %rsi    # 0x1ee11e
callq 0xc0a00
testb $0x1, %al
jne 0xca69c
jmp 0xca6b0
movq 0x15332d(%rip), %rax    # 0x21d9d0
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1e0(%rsp), %rdi
leaq 0x123a5f(%rip), %rsi    # 0x1ee11e
movl $0x4, %edx
callq 0xc08f0
testb $0x1, %al
jne 0xca6cf
jmp 0xca737
movq 0x1e0(%rsp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x2b, %eax
je 0xca6f1
movq 0x1e0(%rsp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x2d, %eax
jne 0xca737
movq 0x1f8(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0x1f0(%rsp), %rdx
movl 0x1ec(%rsp), %ecx
movb 0x1eb(%rsp), %al
movsd 0x1172a9(%rip), %xmm0   # 0x1e19c8
andb $0x1, %al
movzbl %al, %r8d
callq 0xcc310
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xca739
movsbl 0x1e9(%rsp), %eax
cmpl $0x69, %eax
jne 0xca892
movq 0x1e0(%rsp), %rdi
leaq 0x1239d3(%rip), %rsi    # 0x1ee12c
callq 0xc0a00
testb $0x1, %al
jne 0xca764
jmp 0xca7a9
movq 0x1f0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0xca785
movq 0x15325d(%rip), %rax    # 0x21d9d8
movq %rax, 0xe0(%rsp)
jmp 0xca794
movq 0x15769c(%rip), %rax    # 0x221e28
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1e0(%rsp), %rdi
leaq 0x123974(%rip), %rsi    # 0x1ee12c
movl $0x4, %edx
callq 0xc08f0
testb $0x1, %al
jne 0xca7cb
jmp 0xca890
movq 0x1e0(%rsp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x2b, %eax
je 0xca7f1
movq 0x1e0(%rsp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x2d, %eax
jne 0xca890
movq 0x1f8(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0x1f0(%rsp), %rax
movsbl (%rax), %eax
movss 0x1172b0(%rip), %xmm0   # 0x1e1ac4
movss 0x1172ac(%rip), %xmm1   # 0x1e1ac8
movss %xmm1, 0xd8(%rsp)
cmpl $0x2d, %eax
movss %xmm0, 0xdc(%rsp)
je 0xca845
movss 0xd8(%rsp), %xmm0
movss %xmm0, 0xdc(%rsp)
movq 0xd0(%rsp), %rdi
movss 0xdc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x1e0(%rsp), %rsi
movq 0x1f0(%rsp), %rdx
movl 0x1ec(%rsp), %ecx
movb 0x1eb(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xcc310
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xca892
testb $0x1, 0x1eb(%rsp)
je 0xca8bb
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0xc8(%rsp)
jmp 0xca8d2
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcab0d
movb $0x1, 0x1df(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1e0(%rsp)
movb (%rax), %al
movb %al, 0x1e9(%rsp)
cmpb $0x0, 0x1e9(%rsp)
je 0xca939
movq 0x153073(%rip), %rax    # 0x21d998
movzbl 0x1e9(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1ec(%rsp), %eax
jl 0xca98e
testb $0x1, 0x1eb(%rsp)
je 0xca962
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0xc0(%rsp)
jmp 0xca979
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcab0d
movq 0x1e0(%rsp), %rdi
leaq 0x12377c(%rip), %rsi    # 0x1ee11e
callq 0xc0a00
testb $0x1, %al
jne 0xca9ad
jmp 0xca9c1
movq 0x15301c(%rip), %rax    # 0x21d9d0
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
testb $0x1, 0x1eb(%rsp)
je 0xca9ea
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0xb8(%rsp)
jmp 0xcaa01
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1e0(%rsp), %rdi
leaq 0x123707(%rip), %rsi    # 0x1ee12c
callq 0xc0a00
testb $0x1, %al
jne 0xcaa30
jmp 0xcaa44
movq 0x152fa1(%rip), %rax    # 0x21d9d8
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
testb $0x1, 0x1eb(%rsp)
je 0xcaa6d
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0xb0(%rsp)
jmp 0xcaa84
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcab0d
movq 0x152ef6(%rip), %rax    # 0x21d998
movzbl 0x1e9(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1ec(%rsp), %eax
jl 0xcab0b
testb $0x1, 0x1eb(%rsp)
je 0xcaadf
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0xa8(%rsp)
jmp 0xcaaf6
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcab0d
movq $0x0, 0x1d0(%rsp)
movq $0x0, 0x1c8(%rsp)
movq $0x0, 0x1c0(%rsp)
movq $0x0, 0x1b8(%rsp)
movq $0x0, 0x1b0(%rsp)
movb $0x0, 0x1af(%rsp)
movb $0x0, 0x1ae(%rsp)
movl $0x0, 0x1a8(%rsp)
movb $0x0, 0x1a3(%rsp)
movl 0x1ec(%rsp), %eax
movl %eax, 0x1a4(%rsp)
movq 0x1e0(%rsp), %rax
movb (%rax), %al
movb %al, 0x1e9(%rsp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xcb3df
movq 0x152dfa(%rip), %rax    # 0x21d998
movzbl 0x1e9(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1a4(%rsp), %eax
jl 0xcb3c4
movl 0x1ec(%rsp), %eax
movl %eax, 0x1a4(%rsp)
movsbl 0x1e9(%rsp), %eax
addl $-0x2b, %eax
movl %eax, %ecx
movq %rcx, 0xa0(%rsp)
subl $0x3e, %eax
ja 0xcb376
movq 0xa0(%rsp), %rax
leaq 0x114907(%rip), %rcx    # 0x1df4f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x152d97(%rip), %rax    # 0x21d998
movq 0x1e0(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1a4(%rsp), %eax
jl 0xcac8d
movq 0x152d78(%rip), %rax    # 0x21d998
movq 0x1e0(%rsp), %rcx
movzbl -0x1(%rcx), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1a4(%rsp), %eax
jl 0xcac8d
testb $0x1, 0x1eb(%rsp)
je 0xcac61
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x98(%rsp)
jmp 0xcac78
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
cmpl $0x0, 0x1a8(%rsp)
jne 0xcad0b
testb $0x1, 0x1df(%rsp)
jne 0xcacac
cmpq $0x0, 0x1d0(%rsp)
je 0xcad01
testb $0x1, 0x1eb(%rsp)
je 0xcacd5
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x90(%rsp)
jmp 0xcacec
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movb $0x1, 0x1df(%rsp)
jmp 0xcad7d
testb $0x1, 0x1ae(%rsp)
jne 0xcad20
cmpq $0x0, 0x1c8(%rsp)
je 0xcad75
testb $0x1, 0x1eb(%rsp)
je 0xcad49
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x88(%rsp)
jmp 0xcad60
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movb $0x1, 0x1ae(%rsp)
jmp 0xcb3c6
cmpl $0xa, 0x1a4(%rsp)
jle 0xcade1
testb $0x1, 0x1eb(%rsp)
je 0xcadb5
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x80(%rsp)
jmp 0xcadcc
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcade3
movl $0xa, 0x1a4(%rsp)
cmpq $0x0, 0x1b8(%rsp)
jne 0xcae04
cmpq $0x0, 0x1d0(%rsp)
je 0xcae5a
cmpl $0x0, 0x1a8(%rsp)
jne 0xcae5a
testb $0x1, 0x1eb(%rsp)
je 0xcae34
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x78(%rsp)
jmp 0xcae48
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
cmpq $0x0, 0x1b0(%rsp)
jne 0xcae70
cmpq $0x0, 0x1c8(%rsp)
je 0xcaec6
cmpl $0x0, 0x1a8(%rsp)
je 0xcaec6
testb $0x1, 0x1eb(%rsp)
je 0xcaea0
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x70(%rsp)
jmp 0xcaeb4
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x152acb(%rip), %rax    # 0x21d998
movq 0x1e0(%rsp), %rcx
movzbl -0x1(%rcx), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1ec(%rsp), %eax
jl 0xcaf42
movq 0x1e0(%rsp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2e, %eax
je 0xcaf42
testb $0x1, 0x1eb(%rsp)
je 0xcaf1c
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x68(%rsp)
jmp 0xcaf30
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
cmpl $0x0, 0x1a8(%rsp)
jne 0xcaf66
movq 0x1e0(%rsp), %rax
movq %rax, 0x1b8(%rsp)
movb $0x1, 0x1df(%rsp)
jmp 0xcaf7e
movq 0x1e0(%rsp), %rax
movq %rax, 0x1b0(%rsp)
movb $0x1, 0x1ae(%rsp)
movq 0x1e0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xcafb2
movq 0x1e0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0xcafc6
movq 0x1e0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1e0(%rsp)
movq 0x1529cb(%rip), %rax    # 0x21d998
movq 0x1e0(%rsp), %rcx
movzbl (%rcx), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1a4(%rsp), %eax
jge 0xcafe9
jmp 0xcb3c6
jmp 0xcb378
cmpl $0x0, 0x1a8(%rsp)
je 0xcb044
testb $0x1, 0x1eb(%rsp)
je 0xcb01e
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x60(%rsp)
jmp 0xcb032
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movsbl 0x1e9(%rsp), %eax
cmpl $0x2b, %eax
jne 0xcb05e
movl $0x1, 0x1a8(%rsp)
jmp 0xcb069
movl $0xffffffff, 0x1a8(%rsp) # imm = 0xFFFFFFFF
movq 0x1e0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0xcb0ed
movq 0x1c0(%rsp), %rdi
leaq 0x123377(%rip), %rsi    # 0x1ee413
callq 0xc0a00
testb $0x1, %al
jne 0xcb0a7
jmp 0xcb0ed
movq 0x1f8(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0x1f0(%rsp), %rdx
movl 0x1ec(%rsp), %ecx
movb 0x1eb(%rsp), %al
movsd 0x1168f3(%rip), %xmm0   # 0x1e19c8
andb $0x1, %al
movzbl %al, %r8d
callq 0xcc800
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1c0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x69, %eax
jne 0xcb1a5
movq 0x1c0(%rsp), %rdi
leaq 0x12330a(%rip), %rsi    # 0x1ee41a
callq 0xc0a00
testb $0x1, %al
jne 0xcb11e
jmp 0xcb1a5
movq 0x1f8(%rsp), %rax
movq %rax, 0x50(%rsp)
movsbl 0x1e9(%rsp), %eax
movss 0x11698d(%rip), %xmm0   # 0x1e1ac8
movss 0x116981(%rip), %xmm1   # 0x1e1ac4
movss %xmm1, 0x58(%rsp)
cmpl $0x2b, %eax
movss %xmm0, 0x5c(%rsp)
je 0xcb160
movss 0x58(%rsp), %xmm0
movss %xmm0, 0x5c(%rsp)
movq 0x50(%rsp), %rdi
movss 0x5c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x1e0(%rsp), %rsi
movq 0x1f0(%rsp), %rdx
movl 0x1ec(%rsp), %ecx
movb 0x1eb(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xcc800
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcb3c6
cmpl $0x0, 0x1a8(%rsp)
jne 0xcb220
cmpq $0x0, 0x1b8(%rsp)
jne 0xcb1d4
cmpq $0x0, 0x1d0(%rsp)
jne 0xcb1d4
testb $0x1, 0x1df(%rsp)
je 0xcb220
testb $0x1, 0x1eb(%rsp)
je 0xcb1fa
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x48(%rsp)
jmp 0xcb20e
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
cmpl $0x0, 0x1a8(%rsp)
je 0xcb296
cmpq $0x0, 0x1b0(%rsp)
jne 0xcb24a
cmpq $0x0, 0x1c8(%rsp)
jne 0xcb24a
testb $0x1, 0x1ae(%rsp)
je 0xcb296
testb $0x1, 0x1eb(%rsp)
je 0xcb270
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x40(%rsp)
jmp 0xcb284
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
cmpl $0x0, 0x1a8(%rsp)
jne 0xcb2b6
movq 0x1e0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1d0(%rsp)
jmp 0xcb2ca
movq 0x1e0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1c8(%rsp)
movq 0x1526c7(%rip), %rax    # 0x21d998
movq 0x1e0(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1a4(%rsp), %eax
jge 0xcb308
movq 0x1526a8(%rip), %rax    # 0x21d998
movq 0x1e0(%rsp), %rcx
movzbl -0x1(%rcx), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x1a4(%rsp), %eax
jl 0xcb354
testb $0x1, 0x1eb(%rsp)
je 0xcb32e
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x38(%rsp)
jmp 0xcb342
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcb3c6
cmpl $0x0, 0x1a8(%rsp)
je 0xcb374
testb $0x1, 0x1af(%rsp)
jne 0xcb374
movb $0x1, 0x1af(%rsp)
jmp 0xcb3c6
jmp 0xcb378
jmp 0xcb378
testb $0x1, 0x1eb(%rsp)
je 0xcb39e
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x30(%rsp)
jmp 0xcb3b2
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcb3c6
movq 0x1e0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1e0(%rsp)
jmp 0xcab7a
cmpl $0x0, 0x1a8(%rsp)
je 0xcb43f
testb $0x1, 0x1af(%rsp)
jne 0xcb43f
testb $0x1, 0x1eb(%rsp)
je 0xcb419
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x28(%rsp)
jmp 0xcb42d
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
testb $0x1, 0x1af(%rsp)
je 0xcb8dd
xorps %xmm0, %xmm0
movsd %xmm0, 0x198(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x190(%rsp)
movq 0x1f0(%rsp), %rdi
callq 0xa430
movq %rax, 0x180(%rsp)
movq 0x1f0(%rsp), %rax
movq 0x180(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x69, %eax
je 0xcb4e3
testb $0x1, 0x1eb(%rsp)
je 0xcb4bd
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x20(%rsp)
jmp 0xcb4d1
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1f0(%rsp), %rax
movq 0x180(%rsp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %al
movb %al, 0x17f(%rsp)
movq 0x1c0(%rsp), %rax
movb -0x1(%rax), %al
movb %al, 0x17e(%rsp)
movq 0x1f0(%rsp), %rax
movq 0x180(%rsp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
je 0xcb54d
movq 0x1f0(%rsp), %rax
movq 0x180(%rsp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0xcb567
movq 0x1f0(%rsp), %rax
movq 0x180(%rsp), %rcx
subq $0x1, %rcx
movb $0x31, (%rax,%rcx)
jmp 0xcb57f
movq 0x1f0(%rsp), %rax
movq 0x180(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq 0x1c0(%rsp), %rax
movb $0x0, -0x1(%rax)
testb $0x1, 0x1df(%rsp)
jne 0xcb5a0
cmpq $0x0, 0x1b8(%rsp)
je 0xcb5c2
movq 0x1f0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
callq 0xccb30
movsd %xmm0, 0x198(%rsp)
jmp 0xcb6c7
cmpq $0x0, 0x1d0(%rsp)
je 0xcb67d
movq 0x1f0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
movq %rax, 0x170(%rsp)
movq 0x1d0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
movq %rax, 0x168(%rsp)
cmpq $0x0, 0x168(%rsp)
jne 0xcb637
movsd 0x11639c(%rip), %xmm0   # 0x1e19c8
movsd %xmm0, 0x198(%rsp)
jmp 0xcb67b
cmpq $0x0, 0x170(%rsp)
jne 0xcb658
xorps %xmm0, %xmm0
movsd %xmm0, 0x198(%rsp)
movb $0x0, 0x1a3(%rsp)
jmp 0xcb679
cvtsi2sdq 0x170(%rsp), %xmm0
cvtsi2sdq 0x168(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x198(%rsp)
jmp 0xcb67b
jmp 0xcb6a7
movq 0x1f0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x198(%rsp)
testb $0x1, 0x1a3(%rsp)
je 0xcb6c5
movq 0x152318(%rip), %rax    # 0x21d9d0
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcb6c7
movsd 0x198(%rsp), %xmm0
movsd 0x116390(%rip), %xmm1   # 0x1e1a68
ucomisd %xmm1, %xmm0
jne 0xcb6ec
jp 0xcb6ec
xorps %xmm0, %xmm0
movsd %xmm0, 0x198(%rsp)
testb $0x1, 0x1ae(%rsp)
jne 0xcb701
cmpq $0x0, 0x1b0(%rsp)
je 0xcb723
movq 0x1c0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
callq 0xccb30
movsd %xmm0, 0x190(%rsp)
jmp 0xcb828
cmpq $0x0, 0x1c8(%rsp)
je 0xcb7de
movq 0x1c0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
movq %rax, 0x160(%rsp)
movq 0x1c8(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
movq %rax, 0x158(%rsp)
cmpq $0x0, 0x158(%rsp)
jne 0xcb798
movsd 0x11623b(%rip), %xmm0   # 0x1e19c8
movsd %xmm0, 0x190(%rsp)
jmp 0xcb7dc
cmpq $0x0, 0x160(%rsp)
jne 0xcb7b9
xorps %xmm0, %xmm0
movsd %xmm0, 0x190(%rsp)
movb $0x0, 0x1a3(%rsp)
jmp 0xcb7da
cvtsi2sdq 0x160(%rsp), %xmm0
cvtsi2sdq 0x158(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x190(%rsp)
jmp 0xcb7dc
jmp 0xcb808
movq 0x1c0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x190(%rsp)
testb $0x1, 0x1a3(%rsp)
je 0xcb826
movq 0x1521b7(%rip), %rax    # 0x21d9d0
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
jmp 0xcb828
cmpl $-0x1, 0x1a8(%rsp)
jne 0xcb871
movsd 0x190(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xcb848
jp 0xcb848
jmp 0xcb871
movsd 0x190(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x190(%rsp)
movq 0x1f8(%rsp), %rdi
movsd 0x198(%rsp), %xmm0
movsd 0x190(%rsp), %xmm1
callq 0x122a0
movq %rax, 0x188(%rsp)
movb 0x17f(%rsp), %dl
movq 0x1f0(%rsp), %rax
movq 0x180(%rsp), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movb 0x17e(%rsp), %cl
movq 0x1c0(%rsp), %rax
movb %cl, -0x1(%rax)
movq 0x188(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
testb $0x1, 0x1df(%rsp)
jne 0xcb8f6
cmpq $0x0, 0x1b8(%rsp)
je 0xcba1a
cmpq $0x0, 0x1d0(%rsp)
je 0xcb94d
testb $0x1, 0x1eb(%rsp)
je 0xcb927
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb400
movq %rax, 0x18(%rsp)
jmp 0xcb93b
movq 0x1f8(%rsp), %rax
movq 0x120(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1f0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
callq 0xccb30
movsd %xmm0, 0x140(%rsp)
movq 0x1f8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x1f8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xcb997
movq 0x1f8(%rsp), %rdi
callq 0xc670
movq 0x1f8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x148(%rsp)
movq 0x148(%rsp), %rax
movq $0xd, (%rax)
movsd 0x140(%rsp), %xmm0
movq 0x148(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x148(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
cmpq $0x0, 0x1d0(%rsp)
je 0xcbaee
movq 0x1f0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
movq %rax, 0x130(%rsp)
movq 0x1d0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
movq %rax, 0x128(%rsp)
cmpq $0x0, 0x130(%rsp)
jne 0xcba9b
cmpq $0x0, 0x128(%rsp)
je 0xcba9b
movq 0x14a9f2(%rip), %rax    # 0x216480
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
cmpq $0x0, 0x128(%rsp)
je 0xcbab0
testb $0x1, 0x1a3(%rsp)
je 0xcbac4
movq 0x151f19(%rip), %rax    # 0x21d9d0
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1f8(%rsp), %rdi
movq 0x130(%rsp), %rsi
movq 0x128(%rsp), %rdx
callq 0x11a80
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x1f0(%rsp), %rdi
movl 0x1ec(%rsp), %esi
leaq 0x1a3(%rsp), %rdx
callq 0xcdb90
movq %rax, 0x120(%rsp)
testb $0x1, 0x1a3(%rsp)
je 0xcbb58
movq 0x1f0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xcbb3a
movq 0x1562f5(%rip), %rax    # 0x221e28
movq %rax, 0x10(%rsp)
jmp 0xcbb46
movq 0x151e97(%rip), %rax    # 0x21d9d8
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x200(%rsp)
jmp 0xcbc4e
movq 0x120(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x118(%rsp), %rax
andq $-0x800, %rax           # imm = 0xF800
cmpq $0x0, %rax
jne 0xcbb99
movq 0x118(%rsp), %rcx
leaq 0x14a8f5(%rip), %rax    # 0x216480
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0xcbc31
jmp 0xcbb9b
movq 0x1f8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x1f8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0xcbbc8
movq 0x1f8(%rsp), %rdi
callq 0xc670
movq 0x1f8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x108(%rsp)
movq 0x108(%rsp), %rax
movq $0xb, (%rax)
movq 0x118(%rsp), %rcx
movq 0x108(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x108(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x200(%rsp)
movq 0x200(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
nop