// File: /workspace/github_c_makefile_star2_O1/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 $0x58, %rsp
movl %ecx, %r9d
movl %edx, %r10d
movq %rsi, %r14
movq %rdi, %rbp
incq %rsi
movzbl (%r14), %r8d
leal -0x23(%r8), %eax
cmpl $0xe, %eax
ja 0x97cc4
leaq 0x7926a(%rip), %rcx     # 0x110f08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0x1(%r14), %r11b
cmpb $0x2e, %r11b
jne 0x98079
leaq 0x3(%r14), %rsi
movb 0x2(%r14), %r11b
movb $0x1, %al
jmp 0x9807f
cmpl $0x6e, %r8d
je 0x981ac
cmpl $0x69, %r8d
jne 0x97d07
xorl %eax, %eax
leaq 0x8786a(%rip), %rcx     # 0x11f547
movb 0x1(%r14,%rax), %dl
movb (%rax,%rcx), %sil
testb %dl, %dl
je 0x97cf2
incq %rax
cmpb %sil, %dl
je 0x97cdd
cmpb %sil, %dl
jne 0x9830a
movq 0xbe19e(%rip), %rax     # 0x155ea0
jmp 0x98b07
leaq 0xc5952(%rip), %rax     # 0x15d660
cmpl %r10d, (%rax,%r8,4)
jge 0x9824f
xorl %eax, %eax
movb $0x0, 0x7(%rsp)
movb (%rsi), %cl
testb %cl, %cl
je 0x98063
movq %r8, 0x20(%rsp)
movl %r9d, 0x8(%rsp)
xorl %edi, %edi
leaq 0xc5924(%rip), %r8      # 0x15d660
leaq 0x87af2(%rip), %r9      # 0x11f835
xorl %r11d, %r11d
xorl %r13d, %r13d
movq $0x0, 0x40(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x48(%rsp)
xorl %ebx, %ebx
xorl %r15d, %r15d
movl %r10d, %r12d
movzbl %cl, %edx
cmpl %r12d, (%r8,%rdx,4)
jl 0x98033
cmpl $0x3f, %edx
jg 0x97e9f
addl $-0x2b, %edx
cmpl $0x4, %edx
ja 0x983d3
leaq 0x791af(%rip), %r12     # 0x110f44
movslq (%r12,%rdx,4), %rdx
addq %r12, %rdx
jmpq *%rdx
testl %r15d, %r15d
jne 0x9862b
xorl %edx, %edx
cmpb $0x2b, %cl
sete %dl
leal -0x1(,%rdx,2), %r15d
leaq 0x1(%rsi), %r13
movzbl 0x1(%rsi), %r12d
cmpl $0x69, %r12d
je 0x97e44
cmpl $0x6e, %r12d
jne 0x98017
movl %r10d, %edx
movl %eax, %r10d
movq %r8, %rax
movq %rdi, %r8
movq %r15, %rdi
movq %rbx, %r15
movq %r11, %rbx
movq %r13, %r11
movl %edx, 0x1c(%rsp)
movq %rbp, 0x38(%rsp)
xorl %edx, %edx
movb 0x1(%rsi,%rdx), %r13b
leaq 0x87a2f(%rip), %rbp     # 0x11f82e
movb (%rdx,%rbp), %bpl
testb %r13b, %r13b
je 0x97e10
incq %rdx
cmpb %bpl, %r13b
je 0x97df3
cmpb %bpl, %r13b
je 0x98845
cmpb $0x69, %r12b
movq 0x38(%rsp), %rbp
movl 0x1c(%rsp), %edx
movq %r11, %r13
movq %rbx, %r11
movq %r15, %rbx
movq %rdi, %r15
movq %r8, %rdi
movq %rax, %r8
movl %r10d, %eax
movl %edx, %r10d
jne 0x98017
movl %eax, 0x54(%rsp)
movq %r8, %rax
movq %rdi, %r8
movq %r15, %rdi
movq %rbx, %r15
movq %r11, %rbx
movq %rbp, %r11
movq %r13, %rbp
xorl %r12d, %r12d
movb 0x1(%rsi,%r12), %dl
movb (%r12,%r9), %r13b
testb %dl, %dl
je 0x97e75
incq %r12
cmpb %r13b, %dl
je 0x97e60
movl %r10d, %r12d
cmpb %r13b, %dl
movq %rbp, %r13
movq %r11, %rbp
movq %rbx, %r11
movq %r15, %rbx
movq %rdi, %r15
movq %r8, %rdi
movq %rax, %r8
movl 0x54(%rsp), %eax
jne 0x98033
jmp 0x987bd
cmpl $0x64, %edx
jg 0x97eb3
cmpl $0x40, %edx
je 0x97eee
cmpl $0x45, %edx
je 0x97ee4
jmp 0x983d3
cmpl $0x65, %edx
je 0x97ee4
cmpl $0x69, %edx
jne 0x983d3
testl %r15d, %r15d
je 0x983d3
movl %r10d, %r12d
testb $0x1, 0x48(%rsp)
movb $0x1, %cl
movq %rcx, 0x48(%rsp)
je 0x98033
jmp 0x983d3
cmpl $0xb, %r10d
jge 0x98668
movq 0x40(%rsp), %r12
movq %r12, %rcx
orq %rdi, %rcx
je 0x97f04
testl %r15d, %r15d
je 0x9850e
movq 0x10(%rsp), %rdx
movq %rdx, %rcx
orq %r11, %rcx
je 0x97f1a
testl %r15d, %r15d
jne 0x9854b
movzbl -0x1(%rsi), %ecx
cmpl $0x2e, %ecx
je 0x97f2d
cmpl %r10d, (%r8,%rcx,4)
jge 0x98588
testl %r15d, %r15d
movzbl %bl, %ebx
movl $0x1, %ecx
cmovnel %ecx, %ebx
cmovneq %rsi, %rdx
cmoveq %rsi, %r12
movzbl %al, %eax
cmovel %ecx, %eax
movzbl 0x1(%rsi), %ecx
cmpl $0x2d, %ecx
movq %rdx, 0x10(%rsp)
movq %r12, 0x40(%rsp)
je 0x97f65
cmpl $0x2b, %ecx
jne 0x9801c
addq $0x2, %rsi
jmp 0x9801f
movzbl 0x1(%rsi), %ecx
cmpl %r10d, (%r8,%rcx,4)
jl 0x97f86
movzbl -0x1(%rsi), %ecx
cmpl %r10d, (%r8,%rcx,4)
jge 0x98a58
testl %r15d, %r15d
je 0x98046
testb $0x1, %bl
jne 0x98975
testq %r11, %r11
jne 0x98975
movb $0x1, %bl
movl %r10d, %r12d
xorl %r11d, %r11d
jmp 0x98033
testl %r15d, %r15d
movq 0x10(%rsp), %rdx
jne 0x97fd3
movq 0x40(%rsp), %rcx
orq %rdi, %rcx
jne 0x98808
testb $0x1, %al
jne 0x98808
testl %r15d, %r15d
je 0x97fe8
movq %rdx, %rcx
orq %r11, %rcx
jne 0x98759
testb $0x1, %bl
jne 0x98759
movzbl 0x1(%rsi), %ecx
cmpl %r10d, (%r8,%rcx,4)
jge 0x9871c
leaq 0x1(%rsi), %rcx
testl %r15d, %r15d
cmoveq %rcx, %rdi
cmovneq %rcx, %r11
movzbl -0x1(%rsi), %ecx
movl %r10d, %r12d
cmpl %r10d, (%r8,%rcx,4)
jl 0x98033
jmp 0x9871c
movl %r10d, %r12d
jmp 0x98033
incq %rsi
movzbl (%rsi), %ecx
cmpl $0xa, (%r8,%rcx,4)
jge 0x983d3
movl $0xa, %r12d
movb 0x1(%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x97d6c
jmp 0x9811b
testb $0x1, %al
jne 0x98ad3
testq %rdi, %rdi
jne 0x98ad3
movb $0x1, %al
xorl %r15d, %r15d
movl %r10d, %r12d
xorl %edi, %edi
jmp 0x98033
xorl %r15d, %r15d
xorl %ebx, %ebx
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r13d, %r13d
xorl %r11d, %r11d
xorl %edi, %edi
jmp 0x9813e
leaq 0x2(%r14), %rsi
xorl %eax, %eax
testb %r11b, %r11b
je 0x981df
movzbl %r11b, %edx
leaq 0xc55cd(%rip), %rdi     # 0x15d660
cmpl %r10d, (%rdi,%rdx,4)
jl 0x97d1a
testb %al, %al
je 0x98342
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98942
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x980c9
jmp 0x98944
movq %rbp, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x98bb4
movzbl (%rsi), %eax
testq %rax, %rax
je 0x98217
leaq 0xc555a(%rip), %rcx     # 0x15d660
cmpl %r10d, (%rcx,%rax,4)
jge 0x98217
leaq 0x2(%r14), %rsi
movb $0x1, %al
jmp 0x97d1a
cmpq $0x0, 0x40(%rsp)
setne %cl
cmpq $0x0, 0x10(%rsp)
setne %dl
orb %dl, %bl
movl 0x8(%rsp), %r9d
movq 0x20(%rsp), %r8
movq 0x48(%rsp), %rsi
testl %r15d, %r15d
sete %dl
orb %sil, %dl
testb $0x1, %dl
je 0x98174
testb $0x1, %sil
je 0x98287
testq %r14, %r14
sete %dl
testq %r8, %r8
sete %sil
orb %dl, %sil
je 0x98410
xorl %r12d, %r12d
jmp 0x98426
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98198
jmp 0x98af3
xorl %eax, %eax
leaq 0x87384(%rip), %rcx     # 0x11f539
movb 0x1(%r14,%rax), %dl
movb (%rax,%rcx), %sil
testb %dl, %dl
je 0x981ca
incq %rax
cmpb %sil, %dl
je 0x981b5
cmpb %sil, %dl
jne 0x982d2
movq 0xbdcbe(%rip), %rax     # 0x155e98
jmp 0x98b07
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98942
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98203
jmp 0x98944
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98942
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x9823b
jmp 0x98944
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98942
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98273
jmp 0x98944
orb %cl, %al
testb $0x1, %al
je 0x98483
testq %rdi, %rdi
je 0x986a5
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x982be
jmp 0x98af3
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98942
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x982f6
jmp 0x98944
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98942
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x9832e
jmp 0x98944
cmpb $0x69, %r11b
je 0x9887b
cmpl $0x6e, %edx
jne 0x98929
movl %r10d, %ecx
movq %r8, %r10
xorl %edx, %edx
leaq 0x871d5(%rip), %rax     # 0x11f539
movb (%rsi,%rdx), %dil
movb (%rdx,%rax), %r8b
testb %dil, %dil
je 0x98379
incq %rdx
cmpb %r8b, %dil
je 0x98364
cmpb %r8b, %dil
je 0x981d3
movl %r9d, %ebx
xorl %edx, %edx
movb (%rsi,%rdx), %dil
movb (%rdx,%rax), %r8b
cmpb %r8b, %dil
jne 0x983a1
leaq 0x1(%rdx), %r9
cmpq $0x3, %rdx
movq %r9, %rdx
jne 0x98387
cmpb %r8b, %dil
jne 0x98868
movzbl 0x4(%rsi), %eax
cmpl $0x2d, %eax
je 0x983bc
cmpl $0x2b, %eax
jne 0x98868
movzbl %bl, %r8d
movsd 0x76cb8(%rip), %xmm0    # 0x10f080
movq %rbp, %rdi
movq %r14, %rdx
jmp 0x98916
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x983fc
jmp 0x98af3
movq $-0x1, %rdx
leaq 0x1(%rdx), %r12
cmpb $0x0, 0x1(%r14,%rdx)
movq %r12, %rdx
jne 0x98417
movb -0x1(%r14,%r12), %dl
cmpb $0x69, %dl
jne 0x984d6
movb %dl, 0x40(%rsp)
movq %r11, 0x8(%rsp)
movb -0x1(%r13), %dl
movb %dl, 0x48(%rsp)
movb -0x2(%r14,%r12), %dl
addb $-0x2b, %dl
xorl %esi, %esi
testb $-0x3, %dl
movl $0x31, %edx
cmovnel %esi, %edx
movb %dl, -0x1(%r14,%r12)
movb $0x0, -0x1(%r13)
orb %cl, %al
testb $0x1, %al
movl %r10d, 0x1c(%rsp)
je 0x985c5
movq %r14, %rdi
movl %r10d, %esi
callq 0x9958c
jmp 0x989cf
movq %r8, %rbx
leaq 0x7(%rsp), %rdx
movq %rdi, %r12
movq %r14, %rdi
movl %r10d, %esi
movl %r10d, %r15d
callq 0x99f91
movq %rax, %r14
testq %r12, %r12
je 0x986fb
movq %r12, %rdi
leaq 0x7(%rsp), %rdx
movl %r15d, %esi
callq 0x99f91
testq %r14, %r14
jne 0x98796
testq %rax, %rax
je 0x98796
movq 0xb647f(%rip), %rax     # 0x14e950
jmp 0x98b07
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x984fa
jmp 0x98af3
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98537
jmp 0x98af3
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98574
jmp 0x98af3
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x985b1
jmp 0x98af3
movq %rbp, 0x38(%rsp)
movq %r13, 0x10(%rsp)
leaq 0x7(%rsp), %rdx
movq %rdi, %rbp
movq %r14, %rdi
movl %r10d, %esi
movl %r10d, %r13d
callq 0x99f91
movq %rbp, %rdi
movq %rax, %rbp
testq %rdi, %rdi
je 0x987e1
leaq 0x7(%rsp), %rdx
movl %r13d, %esi
callq 0x99f91
testq %rax, %rax
je 0x989b2
testq %rbp, %rbp
movq 0x10(%rsp), %r13
je 0x98b16
cvtsi2sd %rbp, %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
jmp 0x989bf
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98654
jmp 0x98af3
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98691
jmp 0x98af3
movq %r14, %rdi
movl %r10d, %esi
callq 0x9958c
movq 0x90(%rbp), %rax
cmpq 0x98(%rbp), %rax
ja 0x986d4
movq %rbp, %rdi
movsd %xmm0, 0x10(%rsp)
callq 0xb389
movsd 0x10(%rsp), %xmm0
movq 0x90(%rbp), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbp)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0x98b07
cmpb $0x1, 0x7(%rsp)
jne 0x987eb
cmpl $0x2d, %ebx
leaq 0xc1bc8(%rip), %rax     # 0x15a2d8
leaq 0xbd789(%rip), %rcx     # 0x155ea0
jmp 0x988ae
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98745
jmp 0x98af3
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98782
jmp 0x98af3
testq %rax, %rax
je 0x981d3
cmpb $0x1, 0x7(%rsp)
je 0x981d3
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xdd7f
jmp 0x98b07
xorl %eax, %eax
cmpb $0x2b, %cl
sete %al
leaq 0x7a6e4(%rip), %rcx     # 0x112eb0
movsd (%rcx,%rax,8), %xmm0
movzbl 0x8(%rsp), %ecx
movq %rbp, %rdi
movq %r14, %rsi
movl %r10d, %edx
jmp 0x9885e
cvtsi2sd %rbp, %xmm0
jmp 0x989ba
cmpq $0x7ff, %r14            # imm = 0x7FF
ja 0x98a8e
leaq 0xb6151(%rip), %rax     # 0x14e950
movq (%rax,%r14,8), %rax
jmp 0x98b07
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98831
jmp 0x98af3
movzbl 0x8(%rsp), %ecx
movsd 0x7682e(%rip), %xmm0    # 0x10f080
movq 0x38(%rsp), %rdi
movq %r14, %rsi
movl 0x1c(%rsp), %edx
callq 0x993d7
jmp 0x98b07
cmpb $0x69, %r11b
movq %r10, %r8
movl %ecx, %r10d
movl %ebx, %r9d
jne 0x98929
xorl %ecx, %ecx
leaq 0x86cc3(%rip), %rax     # 0x11f547
movb (%rsi,%rcx), %dl
movb (%rcx,%rax), %dil
testb %dl, %dl
je 0x98897
incq %rcx
cmpb %dil, %dl
je 0x98884
cmpb %dil, %dl
jne 0x988ba
cmpl $0x2b, %r8d
leaq 0xbd5f9(%rip), %rax     # 0x155ea0
leaq 0xc1a2a(%rip), %rcx     # 0x15a2d8
cmoveq %rax, %rcx
movq (%rcx), %rax
jmp 0x98b07
movl %r9d, %r11d
movq %r8, %r9
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
movb (%rcx,%rax), %dil
cmpb %dil, %dl
jne 0x988db
leaq 0x1(%rcx), %r8
cmpq $0x3, %rcx
movq %r8, %rcx
jne 0x988c2
cmpb %dil, %dl
movq %r9, %r8
movl %r11d, %r9d
jne 0x98929
movzbl 0x4(%rsi), %eax
cmpl $0x2d, %eax
je 0x988f4
cmpl $0x2b, %eax
jne 0x98929
xorl %eax, %eax
cmpl $0x2d, %r8d
sete %al
leaq 0x7a59c(%rip), %rcx     # 0x112ea0
movsd (%rcx,%rax,8), %xmm0
movzbl %r9b, %r8d
movq %rbp, %rdi
movq %r14, %rdx
movl %r10d, %ecx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x991b9
testb %r9b, %r9b
je 0x98b00
testq %r14, %r14
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
je 0x9895d
xorl %edx, %edx
movq %rbp, %rdi
movq %r14, %rsi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9d9f
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98964
jmp 0x98944
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x9899e
jmp 0x98af3
movsd 0x766c6(%rip), %xmm0    # 0x10f080
movq 0x10(%rsp), %r13
movq 0x38(%rsp), %rbp
cmpb $0x1, 0x7(%rsp)
je 0x981d3
movapd %xmm0, 0x20(%rsp)
testb $0x1, %bl
je 0x989ef
movq %r13, %rdi
movl 0x1c(%rsp), %esi
callq 0x9958c
movapd %xmm0, %xmm1
jmp 0x98b3d
leaq 0x7(%rsp), %rdx
movq %r13, 0x10(%rsp)
movq %r13, %rdi
movl 0x1c(%rsp), %ebx
movl %ebx, %esi
callq 0x99f91
movq %rax, %r13
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x98a4b
leaq 0x7(%rsp), %rdx
movl %ebx, %esi
callq 0x99f91
testq %rax, %rax
je 0x98ac9
testq %r13, %r13
je 0x98b24
xorps %xmm1, %xmm1
cvtsi2sd %r13, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd %xmm0, %xmm1
jmp 0x98b2d
xorps %xmm1, %xmm1
cvtsi2sd %r13, %xmm1
jmp 0x98b2d
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
jne 0x98af1
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98a7d
jmp 0x98af3
movq 0x90(%rbp), %rax
cmpq 0x98(%rbp), %rax
ja 0x98aa6
movq %rbp, %rdi
callq 0xb389
movq 0x90(%rbp), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbp)
movq -0x8(%rax), %rax
movq $0xb, (%rax)
movq %r14, 0x8(%rax)
jmp 0x98b07
movsd 0x765af(%rip), %xmm1    # 0x10f080
jmp 0x98b2d
cmpb $0x0, 0x8(%rsp)
je 0x98b00
testq %r14, %r14
sete %al
cmpq $0x0, 0x20(%rsp)
sete %cl
orb %al, %cl
je 0x98b99
xorl %edx, %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x9d9f
jmp 0x98b07
movq 0x120(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, 0x7(%rsp)
xorpd %xmm0, %xmm0
jmp 0x989bf
movb $0x0, 0x7(%rsp)
xorpd %xmm1, %xmm1
cmpb $0x1, 0x7(%rsp)
movq 0x10(%rsp), %r13
je 0x981d3
xorpd %xmm0, %xmm0
movapd 0x20(%rsp), %xmm2
cmpeqsd %xmm2, %xmm0
andnpd %xmm2, %xmm0
cmpl $-0x1, %r15d
jne 0x98b7b
movapd 0x7a262(%rip), %xmm2    # 0x112dc0
xorpd %xmm1, %xmm2
movapd %xmm1, %xmm3
cmpneqsd %xmm2, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movapd %xmm3, %xmm1
movq %rbp, %rdi
callq 0xe101
movb 0x40(%rsp), %cl
movb %cl, -0x1(%r14,%r12)
movb 0x48(%rsp), %cl
movb %cl, -0x1(%r13)
jmp 0x98b07
movq $-0x1, %rax
leaq 0x1(%rax), %rdx
cmpb $0x0, 0x1(%r14,%rax)
movq %rdx, %rax
jne 0x98ba0
jmp 0x98af3