// File: /workspace/github_c_makefile_star2_O3/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 $0x48, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1(%rsi), %r10
movzbl (%rsi), %r12d
leal -0x23(%r12), %eax
cmpl $0xe, %eax
ja 0x91b8e
leaq 0x7641f(%rip), %rdx     # 0x107f88
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movb 0x1(%r14), %dl
cmpb $0x2e, %dl
jne 0x91fbe
leaq 0x3(%r14), %r10
movb 0x2(%r14), %dl
movb $0x1, %al
jmp 0x91fc4
cmpl $0x6e, %r12d
je 0x92078
cmpl $0x69, %r12d
jne 0x91bd2
xorl %eax, %eax
leaq 0x84ab0(%rip), %rdx     # 0x116657
movb 0x1(%r14,%rax), %sil
movb (%rax,%rdx), %dil
testb %sil, %sil
je 0x91bbd
incq %rax
cmpb %dil, %sil
je 0x91ba7
cmpb %dil, %sil
jne 0x922e0
movq 0xbc2d3(%rip), %rax     # 0x14dea0
jmp 0x9247f
leaq 0xc3a87(%rip), %rax     # 0x155660
cmpl %ebx, (%rax,%r12,4)
jge 0x922e0
xorl %eax, %eax
movb $0x0, 0x7(%rsp)
movb (%r10), %r11b
testb %r11b, %r11b
je 0x91f79
movq %r15, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0xc3a5b(%rip), %r8      # 0x155660
movq $0x0, 0x28(%rsp)
xorl %edi, %edi
xorl %r9d, %r9d
movq $0x0, 0x18(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x14(%rsp)
xorl %r15d, %r15d
movl %ebx, %ebp
addq $0x2, %r10
movq %r10, %rsi
movzbl %r11b, %r10d
cmpl %ebp, (%r8,%r10,4)
jl 0x91e4e
cmpb $0x2e, %r11b
jne 0x91c9d
movzbl -0x1(%rsi), %edx
cmpl %ebx, (%r8,%rdx,4)
jl 0x91c65
movzbl -0x3(%rsi), %edx
cmpl %ebx, (%r8,%rdx,4)
jge 0x921a6
testl %r15d, %r15d
jne 0x91e57
testb $0x1, %al
jne 0x921a6
testq %r13, %r13
jne 0x921a6
movb -0x1(%rsi), %r11b
incq %rsi
xorl %r13d, %r13d
movb $0x1, %al
movl $0x0, %r15d
movl %ebx, %ebp
testb %r11b, %r11b
jne 0x91c39
jmp 0x920ac
cmpl $0x3f, %r10d
jle 0x91cc5
cmpl $0x64, %r10d
movq %r9, %r11
jg 0x91d0f
cmpl $0x40, %r10d
je 0x91d4c
cmpl $0x45, %r10d
je 0x91d43
jmp 0x921a6
cmpl $0x2b, %r10d
je 0x91dda
cmpl $0x2d, %r10d
je 0x91dda
cmpl $0x2f, %r10d
jne 0x921a6
testl %r15d, %r15d
je 0x91ee1
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %r10
orq %r10, %rdx
jne 0x921a6
testb $0x1, 0x14(%rsp)
je 0x91efa
jmp 0x921a6
cmpl $0x65, %r10d
je 0x91d43
cmpl $0x69, %r10d
jne 0x921a6
testl %r15d, %r15d
je 0x921a6
testb $0x1, 0x30(%rsp)
jne 0x921a6
addq $-0x2, %rsi
movb $0x1, %dl
movq %rdx, 0x30(%rsp)
jmp 0x91f2e
cmpl $0xb, %ebx
jge 0x921a6
movq %r11, %rdx
orq %r13, %rdx
je 0x91d5d
testl %r15d, %r15d
je 0x921a6
movq 0x18(%rsp), %rdx
orq 0x28(%rsp), %rdx
je 0x91d72
testl %r15d, %r15d
jne 0x921a6
movzbl -0x3(%rsi), %edx
cmpl $0x2e, %edx
je 0x91d85
cmpl %ebx, (%r8,%rdx,4)
jge 0x921a6
leaq -0x2(%rsi), %rdx
testl %r15d, %r15d
movl 0x14(%rsp), %r10d
movzbl %r10b, %r10d
movl $0x1, %r9d
cmovnel %r9d, %r10d
movl %r10d, 0x14(%rsp)
movq 0x18(%rsp), %r10
cmovneq %rdx, %r10
movq %r10, 0x18(%rsp)
cmoveq %rdx, %r11
movzbl %al, %eax
cmovel %r9d, %eax
movzbl -0x1(%rsi), %r10d
cmpl $0x2b, %r10d
je 0x91dd2
cmpl $0x2d, %r10d
jne 0x91e88
movb (%rsi), %r10b
jmp 0x91e8b
testl %r15d, %r15d
jne 0x921a6
leaq -0x2(%rsi), %r10
xorl %edx, %edx
cmpb $0x2b, %r11b
sete %dl
leal -0x1(,%rdx,2), %r15d
movzbl -0x1(%rsi), %edx
movq %rsi, %rdi
decq %rdi
cmpl $0x69, %edx
je 0x91ea7
cmpl $0x6e, %edx
jne 0x91edd
movq %rdi, 0x20(%rsp)
movq %rdi, %rsi
leaq 0x84b1b(%rip), %r11     # 0x11693e
movb (%rsi), %dil
movb (%r11), %dl
testb %dil, %dil
je 0x91e39
incq %r11
incq %rsi
cmpb %dl, %dil
je 0x91e23
movl %ebx, %ebp
cmpb %dl, %dil
movq 0x20(%rsp), %rdi
jne 0x91f33
jmp 0x924b6
addq $-0x2, %rsi
jmp 0x91f30
testb $0x1, 0x14(%rsp)
jne 0x921a6
cmpq $0x0, 0x28(%rsp)
jne 0x921a6
addq $-0x2, %rsi
movb $0x1, %dl
movl %edx, 0x14(%rsp)
movl %ebx, %ebp
movq $0x0, 0x28(%rsp)
jmp 0x91f30
decq %rsi
movzbl %r10b, %edx
cmpl $0xa, (%r8,%rdx,4)
jge 0x921a6
movq %r11, %r9
movl $0xa, %ebp
jmp 0x91f30
movq %rdi, 0x20(%rsp)
movq %rdi, %rsi
leaq 0x84a8f(%rip), %rbp     # 0x116945
movb (%rsi), %dil
movb (%rbp), %dl
testb %dil, %dil
je 0x91ecc
incq %rbp
incq %rsi
cmpb %dl, %dil
je 0x91eb6
movl %ebx, %ebp
cmpb %dl, %dil
movq 0x20(%rsp), %rdi
jne 0x91f33
jmp 0x9249c
movl %ebx, %ebp
jmp 0x91f33
movq %r9, %rdx
orq %r13, %rdx
movq 0x28(%rsp), %r10
jne 0x921a6
testb $0x1, %al
jne 0x921a6
movzbl -0x1(%rsi), %edx
cmpl %ebx, (%r8,%rdx,4)
jge 0x921a6
leaq -0x1(%rsi), %rdx
testl %r15d, %r15d
cmoveq %rdx, %r13
cmovneq %rdx, %r10
movzbl -0x3(%rsi), %edx
cmpl %ebx, (%r8,%rdx,4)
jge 0x921a6
movq %r10, 0x28(%rsp)
addq $-0x2, %rsi
movl %ebx, %ebp
movq %rsi, %r10
movb 0x1(%r10), %r11b
incq %r10
testb %r11b, %r11b
jne 0x91c32
testq %r9, %r9
setne %sil
cmpq $0x0, 0x18(%rsp)
setne %dl
movl 0x14(%rsp), %r8d
orb %dl, %r8b
movl %r8d, 0x14(%rsp)
testl %r15d, %r15d
je 0x92301
testb $0x1, 0x30(%rsp)
jne 0x920de
jmp 0x921a6
testb %al, %al
jne 0x9242f
movq %r15, %r13
leaq 0x7(%rsp), %r15
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x9390c
cmpb $0x1, (%r15)
jne 0x920f6
cmpl $0x2d, %r12d
leaq 0xc032d(%rip), %rax     # 0x1522d8
leaq 0xbbeee(%rip), %rcx     # 0x14dea0
cmoveq %rax, %rcx
movq (%rcx), %rax
jmp 0x9247f
leaq 0x2(%r14), %r10
xorl %eax, %eax
testb %dl, %dl
je 0x922e0
movzbl %dl, %esi
leaq 0xc368a(%rip), %rdi     # 0x155660
cmpl %ebx, (%rdi,%rsi,4)
jl 0x91be5
testb %al, %al
jne 0x922e0
cmpb $0x6e, %dl
je 0x921cd
cmpl $0x69, %esi
jne 0x922e0
xorl %edx, %edx
leaq 0x84655(%rip), %rax     # 0x116657
movb (%r10,%rdx), %sil
movb (%rdx,%rax), %dil
testb %sil, %sil
je 0x92017
incq %rdx
cmpb %dil, %sil
je 0x92002
cmpb %dil, %sil
jne 0x92285
cmpl $0x2b, %r12d
leaq 0xbbe75(%rip), %rax     # 0x14dea0
leaq 0xc02a6(%rip), %rcx     # 0x1522d8
jmp 0x91fb2
movq %r15, %rdi
movq %r10, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9256e
movzbl (%r10), %eax
testq %rax, %rax
je 0x922e0
leaq 0xc35fc(%rip), %rdx     # 0x155660
cmpl %ebx, (%rdx,%rax,4)
jge 0x922e0
leaq 0x2(%r14), %r10
movb $0x1, %al
jmp 0x91be5
xorl %eax, %eax
leaq 0x845c8(%rip), %rdx     # 0x116649
movb 0x1(%r14,%rax), %sil
movb (%rax,%rdx), %dil
testb %sil, %sil
je 0x92097
incq %rax
cmpb %dil, %sil
je 0x92081
cmpb %dil, %sil
jne 0x922e0
movq 0xbbdf1(%rip), %rax     # 0x14de98
jmp 0x9247f
testq %r9, %r9
setne %sil
cmpq $0x0, 0x18(%rsp)
setne %al
testb $0x1, 0x30(%rsp)
movq 0x8(%rsp), %r15
je 0x9242f
movl 0x14(%rsp), %edx
orb %al, %dl
movl %edx, 0x14(%rsp)
movb $0x1, %al
xorl %r15d, %r15d
xorl %r13d, %r13d
testq %r12, %r12
je 0x92152
xorl %edx, %edx
leaq 0x1(%rdx), %r12
cmpb $0x0, 0x1(%r14,%rdx)
movq %r12, %rdx
jne 0x920e5
jmp 0x92155
movq %rax, %r14
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x92111
leaq 0xb4848(%rip), %rax     # 0x146950
movq (%rax,%r14,8), %rax
jmp 0x9247f
movq %r13, %rbx
movq 0x90(%r13), %rax
cmpq 0x98(%r13), %rax
ja 0x92133
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0x9247f
xorl %r12d, %r12d
cmpb $0x69, -0x1(%r14,%r12)
jne 0x921a6
movb -0x1(%rdi), %cl
movb %cl, 0x18(%rsp)
movb -0x2(%r14,%r12), %cl
addb $-0x2b, %cl
xorl %edx, %edx
testb $-0x3, %cl
movl $0x31, %ecx
cmovnel %edx, %ecx
movb %cl, -0x1(%r14,%r12)
movq %rdi, 0x20(%rsp)
movb $0x0, -0x1(%rdi)
orb %sil, %al
testb $0x1, %al
je 0x92231
movq %r14, %rdi
movl %ebx, %esi
callq 0x92f12
movq 0x20(%rsp), %rdi
jmp 0x9238d
testb %cl, %cl
je 0x921bc
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x9afc
jmp 0x9247f
movq 0x8(%rsp), %rax
movq 0x120(%rax), %rax
jmp 0x9247f
xorl %edx, %edx
leaq 0x84473(%rip), %rax     # 0x116649
movb (%r10,%rdx), %sil
movb (%rdx,%rax), %dil
testb %sil, %sil
je 0x921eb
incq %rdx
cmpb %dil, %sil
je 0x921d6
cmpb %dil, %sil
je 0x920a0
xorl %edx, %edx
movb (%r10,%rdx), %sil
cmpb (%rdx,%rax), %sil
jne 0x922e0
incq %rdx
cmpq $0x4, %rdx
jne 0x921f6
movzbl 0x4(%r10), %eax
cmpl $0x2d, %eax
je 0x92220
cmpl $0x2b, %eax
jne 0x922e0
movzbl %cl, %r8d
movsd 0x73e54(%rip), %xmm0    # 0x106080
jmp 0x922c2
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9390c
testq %r13, %r13
je 0x9236e
movq %rax, %rbp
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movl %ebx, %esi
callq 0x9390c
testq %rax, %rax
je 0x92375
testq %rbp, %rbp
movq 0x20(%rsp), %rdi
je 0x9248e
cvtsi2sd %rbp, %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
jmp 0x92382
xorl %edx, %edx
movb (%r10,%rdx), %sil
cmpb (%rdx,%rax), %sil
jne 0x922e0
incq %rdx
cmpq $0x4, %rdx
jne 0x92287
movzbl 0x4(%r10), %eax
cmpl $0x2d, %eax
je 0x922a9
cmpl $0x2b, %eax
jne 0x922e0
xorl %eax, %eax
cmpl $0x2d, %r12d
sete %al
leaq 0x77cd7(%rip), %rdx     # 0x109f90
movsd (%rdx,%rax,8), %xmm0
movzbl %cl, %r8d
movq %r15, %rdi
movq %r10, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x92b2b
testb %cl, %cl
je 0x92426
movq %r15, %rdi
movq %r14, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9afc
xorl %r15d, %r15d
testb $0x1, 0x30(%rsp)
jne 0x920de
testb $0x1, %al
jne 0x92410
testq %r9, %r9
jne 0x92410
testq %r13, %r13
movq 0x8(%rsp), %r15
je 0x91f81
leaq 0x7(%rsp), %r15
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x9390c
movq %rax, %r14
movq %r13, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x9390c
testq %r14, %r14
jne 0x92545
testq %rax, %rax
je 0x92545
movq 0xb45e7(%rip), %rax     # 0x146950
jmp 0x9247f
cvtsi2sd %rax, %xmm0
jmp 0x9237d
movsd 0x73d03(%rip), %xmm0    # 0x106080
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x7(%rsp)
je 0x920a0
movapd %xmm0, 0x30(%rsp)
testb $0x1, 0x14(%rsp)
je 0x923aa
movl %ebx, %esi
callq 0x92f12
movapd %xmm0, %xmm1
jmp 0x924e6
leaq 0x7(%rsp), %rdx
movl %ebx, %esi
callq 0x9390c
movq %rax, %r13
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x923f6
leaq 0x7(%rsp), %rdx
movl %ebx, %esi
callq 0x9390c
testq %rax, %rax
je 0x92403
testq %r13, %r13
je 0x924d2
xorps %xmm1, %xmm1
cvtsi2sd %r13, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
jmp 0x924db
xorps %xmm1, %xmm1
cvtsi2sd %r13, %xmm1
jmp 0x924db
movsd 0x73c75(%rip), %xmm1    # 0x106080
jmp 0x924db
testq %r13, %r13
movq 0x8(%rsp), %r15
je 0x9242f
testb %cl, %cl
je 0x92426
movq %r15, %rdi
jmp 0x921af
movq 0x120(%r15), %rax
jmp 0x9247f
movq %r14, %rdi
movl %ebx, %esi
callq 0x92f12
movq 0x90(%r15), %rax
cmpq 0x98(%r15), %rax
ja 0x92464
movq %r15, %rdi
movsd %xmm0, 0x18(%rsp)
callq 0xa550
movsd 0x18(%rsp), %xmm0
movq 0x90(%r15), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r15)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, 0x7(%rsp)
xorpd %xmm0, %xmm0
jmp 0x92382
xorl %eax, %eax
cmpb $0x2b, %r11b
sete %al
leaq 0x77af4(%rip), %rdx     # 0x109fa0
movsd (%rdx,%rax,8), %xmm0
movzbl %cl, %ecx
jmp 0x924c1
movzbl %cl, %ecx
movsd 0x73bbf(%rip), %xmm0    # 0x106080
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x92d4b
jmp 0x9247f
movb $0x0, 0x7(%rsp)
xorpd %xmm1, %xmm1
cmpb $0x1, 0x7(%rsp)
je 0x920a0
xorpd %xmm0, %xmm0
movapd 0x30(%rsp), %xmm2
cmpeqsd %xmm2, %xmm0
andnpd %xmm2, %xmm0
cmpl $-0x1, %r15d
jne 0x92524
movapd 0x779a9(%rip), %xmm2    # 0x109eb0
xorpd %xmm1, %xmm2
movapd %xmm1, %xmm3
cmpneqsd %xmm2, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movapd %xmm3, %xmm1
movq 0x8(%rsp), %rdi
movb 0x18(%rsp), %bl
callq 0xd387
movb $0x69, -0x1(%r14,%r12)
movq 0x20(%rsp), %rcx
movb %bl, -0x1(%rcx)
jmp 0x9247f
testq %rax, %rax
je 0x920a0
cmpb $0x1, 0x7(%rsp)
je 0x920a0
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xcfa8
jmp 0x9247f