// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%rsi), %r13
movzbl (%rsi), %ecx
movq %rcx, 0x20(%rsp)
leal -0x23(%rcx), %eax
cmpl $0xe, %eax
ja 0x74de9
leaq 0x5f1a4(%rip), %rcx     # 0xd3f68
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0x1(%r14), %al
cmpb $0x2e, %al
jne 0x751ac
leaq 0x3(%r14), %r13
movb 0x2(%r14), %al
movb $0x1, %r12b
jmp 0x751b3
cmpl $0x69, 0x20(%rsp)
je 0x75234
cmpl $0x6e, 0x20(%rsp)
jne 0x74e1e
leaq 0x6d7e7(%rip), %rsi     # 0xe25e9
movq %r13, %rdi
callq 0x70b07
testb %al, %al
je 0x75530
movq 0xa807f(%rip), %rax     # 0x11ce98
jmp 0x75555
leaq 0xaf83b(%rip), %rax     # 0x124660
movq 0x20(%rsp), %rcx
cmpl %edx, (%rax,%rcx,4)
jge 0x75530
movl %r15d, 0xc(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
xorl %r12d, %r12d
movb $0x0, 0xb(%rsp)
xorl %ebp, %ebp
leaq 0xaf80d(%rip), %r9      # 0x124660
pushq $0x1
popq %r10
pushq $0xa
popq %r11
leaq 0x5f142(%rip), %rbx     # 0xd3fa4
movl %edx, %ecx
xorl %r14d, %r14d
movq $0x0, 0x40(%rsp)
xorl %esi, %esi
xorl %r8d, %r8d
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
xorl %edi, %edi
movzbl (%r13), %r15d
testq %r15, %r15
je 0x75175
cmpl %ecx, (%r9,%r15,4)
jl 0x7516d
leal -0x2b(%r15), %eax
cmpl $0x4, %eax
jbe 0x74ef3
cmpl $0x40, %r15d
je 0x74fb2
cmpl $0x45, %r15d
je 0x74fa9
cmpl $0x65, %r15d
je 0x74fa9
cmpl $0x69, %r15d
jne 0x7518d
testl %ebp, %ebp
je 0x7518d
movl %edx, %ecx
testb $0x1, 0x40(%rsp)
movb $0x1, %al
movq %rax, 0x40(%rsp)
je 0x7516d
jmp 0x7518d
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
testl %ebp, %ebp
jne 0x7518d
xorl %eax, %eax
cmpq $0x2b, %r15
sete %al
leal -0x1(%rax,%rax), %ebp
leaq 0x1(%r13), %rax
movq %rax, 0x30(%rsp)
movzbl 0x1(%r13), %eax
cmpl $0x69, %eax
je 0x750a4
cmpl $0x6e, %eax
jne 0x75115
movq %rdi, 0x48(%rsp)
movq 0x30(%rsp), %rdi
movq %rbp, 0x60(%rsp)
movl %r12d, 0x3c(%rsp)
movl %r14d, 0x38(%rsp)
movq %rsi, 0x50(%rsp)
leaq 0x6d988(%rip), %rsi     # 0xe28de
movl %edx, %r15d
movq %r8, %rbp
movq %r9, %rbx
movl %r10d, %r12d
movl %r11d, %r14d
callq 0x70b07
movl %r14d, %r11d
movl %r12d, %r10d
movq %rbx, %r9
leaq 0x5f02a(%rip), %rbx     # 0xd3fa4
movq %rbp, %r8
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x38(%rsp), %r14d
movl 0x3c(%rsp), %r12d
movq 0x60(%rsp), %rbp
movl %r15d, %edx
movl %r15d, %ecx
testb %al, %al
je 0x7516d
jmp 0x75496
cmpl $0xb, %edx
jge 0x7518d
movq %r8, %rax
orq %rdi, %rax
je 0x74fc2
testl %ebp, %ebp
je 0x7518d
movq %rsi, %rax
orq 0x28(%rsp), %rax
je 0x74fd4
testl %ebp, %ebp
jne 0x7518d
movzbl -0x1(%r13), %eax
cmpl $0x2e, %eax
je 0x74fe8
cmpl %edx, (%r9,%rax,4)
jge 0x7518d
testl %ebp, %ebp
movzbl %r14b, %r14d
cmovnel %r10d, %r14d
cmovneq %r13, %rsi
cmoveq %r13, %r8
movzbl %r12b, %r12d
cmovel %r10d, %r12d
movzbl 0x1(%r13), %eax
cmpl $0x2d, %eax
je 0x75011
cmpl $0x2b, %eax
jne 0x7508b
movb 0x2(%r13), %al
addq $0x2, %r13
jmp 0x7508e
movzbl 0x1(%r13), %eax
cmpl %edx, (%r9,%rax,4)
jl 0x75035
movzbl -0x1(%r13), %eax
cmpl %edx, (%r9,%rax,4)
jge 0x7518d
testl %ebp, %ebp
je 0x75159
testb $0x1, %r14b
jne 0x7518d
cmpq $0x0, 0x28(%rsp)
jne 0x7518d
movb $0x1, %r14b
movl %edx, %ecx
movq $0x0, 0x28(%rsp)
jmp 0x7516d
testl %ebp, %ebp
je 0x75119
movq %rsi, %rax
orq 0x28(%rsp), %rax
jne 0x7518d
testb $0x1, %r14b
je 0x75127
jmp 0x7518d
incq %r13
movzbl %al, %eax
cmpl $0xa, (%r9,%rax,4)
jge 0x7518d
movl %r11d, %ecx
jmp 0x7516d
movl %r12d, 0x3c(%rsp)
movq %rdi, 0x48(%rsp)
movq 0x30(%rsp), %rdi
movq %rsi, 0x50(%rsp)
leaq 0x6d826(%rip), %rsi     # 0xe28e5
movq %rbp, 0x60(%rsp)
movl %r14d, 0x38(%rsp)
movl %edx, %r14d
movq %r8, %r12
movq %r9, %rbx
movl %r10d, %ebp
callq 0x70b07
pushq $0xa
popq %r11
movl %ebp, %r10d
movq %rbx, %r9
leaq 0x5eeb9(%rip), %rbx     # 0xd3fa4
movq %r12, %r8
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %r12d
movq 0x50(%rsp), %rsi
movl %r14d, %edx
movl 0x38(%rsp), %r14d
movq 0x60(%rsp), %rbp
movl %edx, %ecx
testb %al, %al
je 0x7516d
jmp 0x754a5
movl %edx, %ecx
jmp 0x7516d
movq %r8, %rax
orq %rdi, %rax
jne 0x7518d
testb $0x1, %r12b
jne 0x7518d
movzbl 0x1(%r13), %eax
cmpl %edx, (%r9,%rax,4)
jge 0x7518d
leaq 0x1(%r13), %rax
testl %ebp, %ebp
cmoveq %rax, %rdi
movq 0x28(%rsp), %rcx
cmovneq %rax, %rcx
movq %rcx, 0x28(%rsp)
movzbl -0x1(%r13), %eax
movl %edx, %ecx
cmpl %edx, (%r9,%rax,4)
jl 0x7516d
jmp 0x7518d
testb $0x1, %r12b
jne 0x7518d
testq %rdi, %rdi
jne 0x7518d
movb $0x1, %r12b
xorl %ebp, %ebp
movl %edx, %ecx
xorl %edi, %edi
incq %r13
jmp 0x74e89
movq %r8, %r13
movl %edx, %ebx
testl %ebp, %ebp
je 0x752ca
testb $0x1, 0x40(%rsp)
jne 0x752d5
cmpb $0x0, 0xc(%rsp)
je 0x753b3
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x94d4
jmp 0x75555
leaq 0x2(%r14), %r13
xorl %r12d, %r12d
testb %al, %al
je 0x75530
movzbl %al, %ecx
leaq 0xaf49b(%rip), %rsi     # 0x124660
cmpl %edx, (%rsi,%rcx,4)
jge 0x75257
movl %r15d, 0xc(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
jmp 0x74e45
movq %rbx, %rdi
movq %r13, %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7578c
movzbl (%r13), %eax
testq %rax, %rax
je 0x75530
leaq 0xaf450(%rip), %rcx     # 0x124660
cmpl %edx, (%rcx,%rax,4)
jge 0x75530
movl %r15d, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
movq %r14, 0x18(%rsp)
leaq 0x2(%r14), %r13
movb $0x1, %r12b
jmp 0x74e45
leaq 0x6d3bc(%rip), %rsi     # 0xe25f7
movq %r13, %rdi
callq 0x70b07
testb %al, %al
je 0x75530
movq 0xa7c4e(%rip), %rax     # 0x11cea0
jmp 0x75555
testb %r12b, %r12b
jne 0x75530
cmpb $0x69, %al
je 0x7545f
cmpl $0x6e, %ecx
jne 0x75530
movl %edx, %ebp
leaq 0x6d36f(%rip), %rsi     # 0xe25e9
movq %r13, %rdi
callq 0x70b07
testb %al, %al
jne 0x74e12
leaq 0x6d358(%rip), %rsi     # 0xe25e9
pushq $0x4
popq %rdx
movq %r13, %rdi
callq 0x70ab0
testb %al, %al
je 0x75530
movl %ebp, %ecx
movzbl 0x4(%r13), %eax
cmpl $0x2d, %eax
je 0x752b9
cmpl $0x2b, %eax
jne 0x75530
movzbl %r15b, %r8d
movsd 0x5cdab(%rip), %xmm0    # 0xd2070
jmp 0x75514
testb $0x1, 0x40(%rsp)
je 0x753c4
movq %rdi, 0x48(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x8d06
cmpb $0x69, -0x1(%r15,%rax)
jne 0x7539f
movb -0x2(%r15,%rax), %dl
addb $-0x2b, %dl
xorl %ecx, %ecx
testb $-0x3, %dl
pushq $0x31
popq %rdx
cmovnel %ecx, %edx
movq 0x30(%rsp), %rcx
movb -0x1(%rcx), %sil
movb %sil, 0x20(%rsp)
movq %r15, 0x18(%rsp)
movq %rax, 0x40(%rsp)
movb %dl, -0x1(%r15,%rax)
movb $0x0, -0x1(%rcx)
testb $0x1, %r12b
jne 0x75423
testq %r13, %r13
jne 0x75423
movq %rbp, %r15
leaq 0xb(%rsp), %rdx
movq 0x18(%rsp), %rdi
movl %ebx, %ebp
movl %ebx, %esi
callq 0x7666e
movq %rax, %r13
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x7548c
leaq 0xb(%rsp), %rdx
movl %ebp, %esi
callq 0x7666e
testq %rax, %rax
je 0x75613
testq %r13, %r13
movq %r15, %rbp
movq 0x50(%rsp), %r12
je 0x756a6
cvtsi2sd %r13, %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
jmp 0x75623
cmpb $0x0, 0xc(%rsp)
je 0x753b3
movq 0x10(%rsp), %rdi
movq %r15, %rsi
jmp 0x751a2
movq 0x10(%rsp), %rax
movq 0x120(%rax), %rax
jmp 0x75555
testb $0x1, %r12b
jne 0x75439
testq %r13, %r13
jne 0x75439
leaq 0xb(%rsp), %rdx
movq %rdi, %r14
movq 0x18(%rsp), %rdi
movl %ebx, %ebp
movl %ebx, %esi
callq 0x7666e
movq %r14, %rdi
movq %rax, %rbx
testq %r14, %r14
movq 0x10(%rsp), %r14
je 0x755b6
leaq 0xb(%rsp), %rdx
movl %ebp, %esi
callq 0x7666e
testq %rbx, %rbx
jne 0x755ec
testq %rax, %rax
je 0x755ec
movq 0xa0532(%rip), %rax     # 0x115950
jmp 0x75555
movq 0x18(%rsp), %rdi
movl %ebx, %esi
callq 0x75f25
movq 0x50(%rsp), %r12
jmp 0x7562e
testq %rdi, %rdi
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rsi
je 0x75564
cmpb $0x0, 0xc(%rsp)
je 0x755e0
movq %r14, %rdi
jmp 0x751a2
movl %edx, %ebp
leaq 0x6d18f(%rip), %rsi     # 0xe25f7
movq %r13, %rdi
callq 0x70b07
testb %al, %al
je 0x754d3
cmpl $0x2b, 0x20(%rsp)
leaq 0xa7a20(%rip), %rax     # 0x11cea0
leaq 0xabe51(%rip), %rcx     # 0x1212d8
jmp 0x755d4
cvtsi2sd %r13, %xmm0
jmp 0x7561b
movzbl 0xc(%rsp), %ecx
movsd 0x5cbcd(%rip), %xmm0    # 0xd2070
jmp 0x754bf
xorl %eax, %eax
cmpb $0x2b, %r15b
sete %al
leaq 0x60a8b(%rip), %rcx     # 0xd5f40
movsd (%rcx,%rax,8), %xmm0
movzbl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x75dad
jmp 0x75555
leaq 0x6d11d(%rip), %rsi     # 0xe25f7
pushq $0x4
popq %rdx
movq %r13, %rdi
callq 0x70ab0
testb %al, %al
je 0x75530
movl %ebp, %ecx
movzbl 0x4(%r13), %eax
cmpl $0x2d, %eax
je 0x754fa
cmpl $0x2b, %eax
jne 0x75530
xorl %eax, %eax
cmpl $0x2d, 0x20(%rsp)
sete %al
leaq 0x60a25(%rip), %rdx     # 0xd5f30
movsd (%rdx,%rax,8), %xmm0
movzbl %r15b, %r8d
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x75c18
testb %r15b, %r15b
je 0x7554e
movq %rbx, %rdi
movq %r14, %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x94d4
movq 0x120(%rbx), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rdi
movl %ebx, %esi
callq 0x75f25
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x75599
movq %r14, %rdi
movsd %xmm0, 0x28(%rsp)
callq 0x9c27
movsd 0x28(%rsp), %xmm0
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0x75555
cmpb $0x1, 0xb(%rsp)
jne 0x756b4
cmpl $0x2d, 0x20(%rsp)
leaq 0xabd0b(%rip), %rax     # 0x1212d8
leaq 0xa78cc(%rip), %rcx     # 0x11cea0
cmoveq %rax, %rcx
movq (%rcx), %rax
jmp 0x75555
movq 0x120(%r14), %rax
jmp 0x75555
testq %rax, %rax
je 0x74e12
cmpb $0x1, 0xb(%rsp)
je 0x74e12
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xbd87
jmp 0x75555
movsd 0x5ca55(%rip), %xmm0    # 0xd2070
movq %r15, %rbp
movq 0x50(%rsp), %r12
cmpb $0x1, 0xb(%rsp)
je 0x74e12
movapd %xmm0, 0x50(%rsp)
testb $0x1, %r14b
jne 0x75683
testq %r12, %r12
jne 0x75683
leaq 0xb(%rsp), %rdx
movq 0x30(%rsp), %rdi
movl %ebx, %esi
callq 0x7666e
movq %rax, %r15
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x75695
leaq 0xb(%rsp), %rdx
movl %ebx, %esi
callq 0x7666e
testq %rax, %rax
je 0x7569c
testq %r15, %r15
je 0x756d1
cvtsi2sd %r15, %xmm1
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
jmp 0x756da
movq 0x30(%rsp), %rdi
movl %ebx, %esi
callq 0x75f25
movapd %xmm0, %xmm1
jmp 0x756e5
cvtsi2sd %r15, %xmm1
jmp 0x756da
movsd 0x5c9cc(%rip), %xmm1    # 0xd2070
jmp 0x756da
movb $0x0, 0xb(%rsp)
xorpd %xmm0, %xmm0
jmp 0x75623
cmpq $0x7ff, %rbx            # imm = 0x7FF
ja 0x7574e
leaq 0xa0288(%rip), %rax     # 0x115950
movq (%rax,%rbx,8), %rax
jmp 0x75555
movb $0x0, 0xb(%rsp)
xorpd %xmm1, %xmm1
cmpb $0x1, 0xb(%rsp)
je 0x74e12
xorpd %xmm0, %xmm0
movapd 0x50(%rsp), %xmm2
cmpeqsd %xmm2, %xmm0
andnpd %xmm2, %xmm0
cmpl $-0x1, %ebp
jne 0x75722
movapd 0x607ab(%rip), %xmm2    # 0xd5eb0
xorpd %xmm1, %xmm2
movapd %xmm1, %xmm3
cmpneqsd %xmm2, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movapd %xmm3, %xmm1
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rbx
movb 0x20(%rsp), %bpl
callq 0xc152
movq 0x40(%rsp), %rcx
movb $0x69, -0x1(%rbx,%rcx)
movq 0x30(%rsp), %rcx
movb %bpl, -0x1(%rcx)
jmp 0x75555
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x7576d
movq %r14, %rdi
callq 0x9c27
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %rbx, 0x8(%rax)
jmp 0x75555