// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_expt
static s7_pointer g_expt(s7_scheme *sc, s7_pointer args)
    {
#define H_expt "(expt z1 z2) returns z1^z2"
#define Q_expt sc->pcl_n
        s7_pointer n, pw;

        n = car(args);
        if (!s7_is_number(n))
            return(method_or_bust_with_type(sc, n, sc->expt_symbol, args, a_number_string, 1));

        pw = cadr(args);
        if (!s7_is_number(pw))
            return(method_or_bust_with_type(sc, pw, sc->expt_symbol, args, a_number_string, 2));

        /* this provides more than 2 args to expt:
         *  if (is_not_null(cddr(args)))
         *    return(g_expt(sc, list_2(sc, car(args), g_expt(sc, cdr(args)))));
         * but it's unusual in scheme to process args in reverse order, and the
         * syntax by itself is ambiguous (does (expt 2 2 3) = 256 or 64?)
         */

        if (s7_is_zero(n))
        {
            if (s7_is_zero(pw))
            {
                if ((s7_is_integer(n)) && (s7_is_integer(pw)))       /* (expt 0 0) -> 1 */
                    return(small_int(1));
                return(real_zero);                                   /* (expt 0.0 0) -> 0.0 */
            }

            if (s7_is_real(pw))
            {
                if (s7_is_negative(pw))                              /* (expt 0 -1) */
                    return(division_by_zero_error(sc, sc->expt_symbol, args));
                /* (Clisp gives divide-by-zero error here, Guile returns inf.0) */

                if ((!s7_is_rational(pw)) &&                         /* (expt 0 most-positive-fixnum) */
                        (is_NaN(s7_real(pw))))                           /* (expt 0 +nan.0) */
                    return(pw);
            }
            else
            {                                                      /* (expt 0 a+bi) */
                if (real_part(pw) < 0.0)                             /* (expt 0 -1+i) */
                    return(division_by_zero_error(sc, sc->expt_symbol, args));
                if ((is_NaN(real_part(pw))) ||                       /* (expt 0 0+1/0i) */
                        (is_NaN(imag_part(pw))))
                    return(real_NaN);
            }

            if ((s7_is_integer(n)) && (s7_is_integer(pw)))           /* pw != 0, (expt 0 2312) */
                return(small_int(0));
            return(real_zero);                                       /* (expt 0.0 123123) */
        }

        if (s7_is_one(pw))
        {
            if (s7_is_integer(pw))                                   /* (expt x 1) */
                return(n);
            if (is_rational(n))                                      /* (expt ratio 1.0) */
                return(make_real(sc, rational_to_double(sc, n)));
            return(n);
        }

        if (is_t_integer(pw))
        {
            s7_int y;
            y = integer(pw);
            if (y == 0)
            {
                if (is_rational(n))                                 /* (expt 3 0) */
                    return(small_int(1));
                if ((is_NaN(s7_real_part(n))) ||                    /* (expt 1/0 0) -> NaN */
                        (is_NaN(s7_imag_part(n))))                      /* (expt (complex 0 1/0) 0) -> NaN */
                    return(n);
                return(real_one);                                   /* (expt 3.0 0) */
            }

            switch (type(n))
            {
                case T_INTEGER:
                    {
                        s7_int x;
                        x = s7_integer(n);
                        if (x == 1)                                       /* (expt 1 y) */
                            return(n);

                        if (x == -1)
                        {
                            if (y == s7_int_min)                          /* (expt -1 most-negative-fixnum) */
                                return(small_int(1));

                            if (s7_int_abs(y) & 1)                        /* (expt -1 odd-int) */
                                return(n);
                            return(small_int(1));                         /* (expt -1 even-int) */
                        }

                        if (y == s7_int_min)                              /* (expt x most-negative-fixnum) */
                            return(small_int(0));
                        if (x == s7_int_min)                              /* (expt most-negative-fixnum y) */
                            return(make_real(sc, pow((double)x, (double)y)));

                        if (int_pow_ok(x, s7_int_abs(y)))
                        {
                            if (y > 0)
                                return(make_integer(sc, int_to_int(x, y)));
                            return(s7_make_ratio(sc, 1, int_to_int(x, -y)));
                        }
                    }
                    break;

                case T_RATIO:
                    {
                        s7_int nm, dn;

                        nm = numerator(n);
                        dn = denominator(n);

                        if (y == s7_int_min)
                        {
                            if (s7_int_abs(nm) > dn)
                                return(small_int(0));              /* (expt 4/3 most-negative-fixnum) -> 0? */
                            return(real_infinity);               /* (expt 3/4 most-negative-fixnum) -> inf? */
                        }

                        if ((int_pow_ok(nm, s7_int_abs(y))) &&
                                (int_pow_ok(dn, s7_int_abs(y))))
                        {
                            if (y > 0)
                                return(s7_make_ratio(sc, int_to_int(nm, y), int_to_int(dn, y)));
                            return(s7_make_ratio(sc, int_to_int(dn, -y), int_to_int(nm, -y)));
                        }
                    }
                    break;
                    /* occasionally int^rat can be int32_t but it happens so infrequently it's probably not worth checking
                     *  one possibly easy case: (expt 1 1/2) -> 1 (-1?) etc
                     */

                case T_REAL:
                    /* (expt -1.0 most-positive-fixnum) should be -1.0
                     * (expt -1.0 (+ (expt 2 53) 1)) -> -1.0
                     * (expt -1.0 (- 1 (expt 2 54))) -> -1.0
                     */
                    if (real(n) == -1.0)
                    {
                        if (y == s7_int_min)
                            return(real_one);

                        if (s7_int_abs(y) & 1)
                            return(n);
                        return(real_one);
                    }
                    break;

                case T_COMPLEX:
#if HAVE_COMPLEX_NUMBERS
                    if ((s7_real_part(n) == 0.0) &&
                            ((s7_imag_part(n) == 1.0) ||
                             (s7_imag_part(n) == -1.0)))
                    {
                        bool yp, np;
                        yp = (y > 0);
                        np = (s7_imag_part(n) > 0.0);
                        switch (s7_int_abs(y) % 4)
                        {
                            case 0: return(real_one);
                            case 1: return(s7_make_complex(sc, 0.0, (yp == np) ? 1.0 : -1.0));
                            case 2: return(make_real(sc, -1.0));
                            case 3: return(s7_make_complex(sc, 0.0, (yp == np) ? -1.0 : 1.0));
                        }
                    }
#else
                    return(out_of_range(sc, sc->expt_symbol, small_int(2), n, no_complex_numbers_string));
#endif
                    break;
            }
        }

        if ((s7_is_real(n)) &&
                (s7_is_real(pw)))
        {
            s7_double x, y;

            if ((is_t_ratio(pw)) &&
                    (numerator(pw) == 1))
            {
                if (denominator(pw) == 2)
                    return(g_sqrt(sc, args));
                if (denominator(pw) == 3)
                    return(make_real(sc, cbrt(s7_real(n)))); /* (expt 27 1/3) should be 3, not 3.0... */

                /* but: (expt 512/729 1/3) -> 0.88888888888889, and 4 -> sqrt(sqrt...) etc? */
            }

            x = s7_real(n);
            y = s7_real(pw);

            if (is_NaN(x)) return(n);
            if (is_NaN(y)) return(pw);
            if (y == 0.0) return(real_one);

            if (x > 0.0)
                return(make_real(sc, pow(x, y)));      /* tricky cases abound here: (expt -1 1/9223372036854775807) */
        }

        /* (expt 0+i 1e+16) = 0.98156860153485-0.19111012657867i ?
         * (expt 0+i 1+1/0i) = 0.0 ??
         */
        return(s7_from_c_complex(sc, cpow(s7_to_c_complex(n), s7_to_c_complex(pw))));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %r9
movq 0x8(%rsi), %r15
movb (%r15), %bpl
movzbl %bpl, %eax
movl %eax, %r13d
leaq 0xe279f(%rip), %rcx     # 0x14a970
cmpb $0x0, (%r13,%rcx)
je 0x6824c
movq 0x10(%r12), %rdx
movq 0x8(%rdx), %r14
movb (%r14), %dil
movzbl %dil, %ebx
cmpb $0x0, (%rbx,%rcx)
je 0x6826b
cmpl $0xb, %eax
je 0x6829b
cmpl $0xd, %eax
jne 0x682a6
movsd 0x8(%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x682a6
jp 0x682a6
cmpl $0xb, %ebx
je 0x68317
cmpl $0xd, %ebx
jne 0x68322
movsd 0x8(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x68322
jnp 0x684bb
jmp 0x68322
movq 0xed8(%r9), %rdx
movq 0xed146(%rip), %r8      # 0x1553a0
movq %r9, %rdi
movq %r15, %rsi
movq %r12, %rcx
movl $0x1, %r9d
jmp 0x68288
movq 0xed8(%r9), %rdx
movq 0xed127(%rip), %r8      # 0x1553a0
movq %r9, %rdi
movq %r14, %rsi
movq %r12, %rcx
movl $0x2, %r9d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe659
cmpq $0x0, 0x8(%r15)
je 0x6821b
cmpl $0xb, %ebx
je 0x682f8
cmpl $0xd, %ebx
jne 0x68832
movsd 0x8(%r14), %xmm0
ucomisd 0x9dd6e(%rip), %xmm0    # 0x106030
jne 0x68832
jp 0x68832
leaq 0xe271b(%rip), %rax     # 0x14a9f0
cmpb $0x1, (%r13,%rax)
jne 0x6830f
movq 0x8(%r15), %rax
cmpb $0xb, %bpl
jne 0x684c7
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
jmp 0x684e9
movq 0x8(%r14), %r11
testq %r11, %r11
je 0x6838a
cmpq $0x1, %r11
jne 0x683ce
movq %r15, %r14
jmp 0x68994
cmpq $0x0, 0x8(%r14)
je 0x68427
leaq 0xe2687(%rip), %rax     # 0x14a9b0
cmpb $0x1, (%rbx,%rax)
jne 0x68354
cmpl $0xb, %ebx
je 0x6833d
cmpl $0xc, %ebx
jne 0x6843d
movq 0x8(%r14), %rax
testq %rax, %rax
js 0x6844d
movq %rax, %xmm0
jmp 0x6846d
movsd 0x8(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x6844d
ucomisd %xmm0, %xmm0
jp 0x6837e
movsd 0x10(%r14), %xmm0
ucomisd %xmm0, %xmm0
jnp 0x684a3
movq 0xe5b13(%rip), %r14     # 0x14de98
jmp 0x68994
leaq 0xe265f(%rip), %rax     # 0x14a9f0
cmpb $0x1, (%r13,%rax)
je 0x68431
movq %r15, %rdi
callq 0xe238
ucomisd %xmm0, %xmm0
jp 0x6830f
cmpb $0xe, %bpl
jne 0x6898d
movsd 0x10(%r15), %xmm0
ucomisd %xmm0, %xmm0
jp 0x6830f
jmp 0x68572
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0x68832
leaq 0x9f673(%rip), %rcx     # 0x107a54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r15), %rax
cmpq $0x1, %rax
je 0x6830f
cmpq $-0x1, %rax
jne 0x6867c
movl 0xe2620(%rip), %eax     # 0x14aa28
shlq $0x3f, %rax
cmpq %rax, %r11
je 0x68431
testb $0x1, %r11b
jne 0x6830f
movq 0xde536(%rip), %r15     # 0x146958
jmp 0x6830f
cmpb $0xb, %bpl
jne 0x684bb
movq 0xde520(%rip), %r14     # 0x146958
jmp 0x68994
movsd 0x8(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x6846d
movq 0xed8(%r9), %rsi
movq %r9, %rdi
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd434
leaq 0xe257c(%rip), %rax     # 0x14a9f0
cmpb $0x0, (%rbx,%rax)
jne 0x684a3
cmpb $0xd, %dil
je 0x68496
movq 0xe25a9(%rip), %rdi     # 0x14aa30
leaq 0xa1bea(%rip), %rdx     # 0x10a078
movq %r14, %rsi
callq 0xd498
ucomisd %xmm0, %xmm0
jp 0x68994
movb (%r15), %bpl
cmpb $0xb, %bpl
jne 0x684bb
cmpb $0xb, (%r14)
jne 0x684bb
movq 0xde49a(%rip), %r14     # 0x146950
jmp 0x68994
movq 0xe2796(%rip), %r14     # 0x14ac58
jmp 0x68994
movq %rax, 0x28(%rsp)
fildll 0x28(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x30(%rsp)
fildll 0x30(%rsp)
fdivrp %st, %st(1)
fstpl 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movq 0x90(%r9), %rax
cmpq 0x98(%r9), %rax
ja 0x6851a
movq %r9, %rdi
movq %r9, %rbx
movsd %xmm0, 0x10(%rsp)
callq 0xa550
movsd 0x10(%rsp), %xmm0
movq %rbx, %r9
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r9)
movq -0x8(%rax), %r14
movq $0xd, (%r14)
movsd %xmm0, 0x8(%r14)
jmp 0x68994
movsd 0x8(%r15), %xmm0
ucomisd 0x9db07(%rip), %xmm0    # 0x106050
jne 0x68832
jp 0x68832
movl 0xe24cd(%rip), %eax     # 0x14aa28
shlq $0x3f, %rax
cmpq %rax, %r11
je 0x6898d
testb $0x1, %r11b
jne 0x6830f
movq 0xeceef(%rip), %r15     # 0x155468
jmp 0x6830f
movb %dil, 0xf(%rsp)
movq %r15, %rdi
movq %r9, 0x10(%rsp)
movq %r11, 0x18(%rsp)
callq 0xe238
movb 0xf(%rsp), %dil
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %r9
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x68832
jp 0x68832
movsd 0x10(%r15), %xmm0
ucomisd 0x9da6a(%rip), %xmm0    # 0x106030
jne 0x685ca
jnp 0x685de
ucomisd 0x9da7e(%rip), %xmm0    # 0x106050
jne 0x68832
jp 0x68832
movq %rdx, %rax
negq %rax
cmovsq %rdx, %rax
andl $0x3, %eax
leaq 0x9f472(%rip), %rcx     # 0x107a64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
ucomisd %xmm1, %xmm0
seta %al
testq %rdx, %rdx
setg %cl
xorb %al, %cl
je 0x687fa
movsd 0x9da38(%rip), %xmm1    # 0x106050
jmp 0x68802
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rax
movl 0xe23fd(%rip), %edx     # 0x14aa28
shlq $0x3f, %rdx
cmpq %rdx, %r11
jne 0x68653
movq %rcx, %rdx
negq %rdx
cmovsq %rcx, %rdx
cmpq %rax, %rdx
jg 0x684af
movq 0xe5852(%rip), %r14     # 0x14dea0
jmp 0x68994
movq %r11, %r10
negq %r10
movq %r11, %rdx
cmovnsq %r10, %rdx
cmpb $0x1, 0xe25f9(%rip)     # 0x14ac60
jne 0x686b5
cmpq $0x3f, %rdx
jae 0x68832
leaq 0xa1506(%rip), %rsi     # 0x109b80
jmp 0x686c6
movl 0xe23a6(%rip), %ecx     # 0x14aa28
shlq $0x3f, %rcx
cmpq %rcx, %r11
je 0x684af
cmpq %rcx, %rax
jne 0x68768
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r11, %xmm1
movq %r9, %rbx
callq 0x8160
jmp 0x68a24
cmpq $0x1f, %rdx
jae 0x68832
leaq 0xa16ba(%rip), %rsi     # 0x109d80
movq (%rsi,%rdx,8), %rdx
movq %rcx, %rsi
negq %rsi
cmovsq %rcx, %rsi
cmpq %rsi, %rdx
jl 0x68832
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
cmpq %rsi, %rdx
jb 0x68832
testq %r11, %r11
jle 0x68a62
movl $0x1, %edx
movq %r11, %rdi
movl $0x1, %esi
movq %rsi, %r8
testb $0x1, %dil
movq %rcx, %rsi
cmoveq %rdx, %rsi
imulq %r8, %rsi
imulq %rcx, %rcx
seto %r8b
cmpq $0x2, %rdi
jb 0x6872e
shrq %rdi
testb %r8b, %r8b
je 0x68706
movl $0x1, %ecx
movl $0x1, %edx
movq %rdx, %rdi
testb $0x1, %r11b
movq %rax, %rdx
cmoveq %rcx, %rdx
imulq %rdi, %rdx
imulq %rax, %rax
seto %dil
cmpq $0x2, %r11
jb 0x68760
shrq %r11
testb %dil, %dil
je 0x68738
movq %r9, %rdi
jmp 0x68b5f
movq %r11, %rcx
negq %rcx
movq %r11, %rdx
cmovnsq %rcx, %rdx
cmpb $0x1, 0xe24e4(%rip)     # 0x14ac60
jne 0x6880e
cmpq $0x3e, %rdx
ja 0x68832
leaq 0xa13ed(%rip), %rsi     # 0x109b80
jmp 0x6881b
movq 0x90(%r9), %rax
cmpq 0x98(%r9), %rax
ja 0x687bc
movq %r9, %rdi
callq 0xa550
movq 0x10(%rsp), %r9
movq 0x90(%r9), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r9)
movq -0x8(%rax), %r14
movq $0xd, (%r14)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x8(%r14)
jmp 0x68994
ucomisd %xmm1, %xmm0
seta %al
testq %rdx, %rdx
setg %cl
xorb %al, %cl
je 0x68610
movsd 0x9d82e(%rip), %xmm1    # 0x106030
xorpd %xmm0, %xmm0
movq %r9, %rdi
jmp 0x688fc
cmpq $0x1e, %rdx
ja 0x68832
leaq 0xa1565(%rip), %rsi     # 0x109d80
leaq (%rsi,%rdx,8), %rdx
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
cmpq %rsi, (%rdx)
jge 0x68ad5
leaq 0xe2177(%rip), %rax     # 0x14a9b0
cmpb $0x1, (%r13,%rax)
jne 0x6888d
cmpb $0x1, (%rbx,%rax)
jne 0x6888d
cmpb $0xc, %dil
jne 0x6890f
cmpq $0x1, 0x8(%r14)
jne 0x6890f
movq 0x10(%r14), %rax
cmpq $0x3, %rax
je 0x689f8
cmpq $0x2, %rax
jne 0x6890f
movq %r9, %rdi
movq %r12, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x67eef
movq %r9, %rbx
movq %r15, %rdi
callq 0xe238
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
cmpb $0xe, %bpl
jne 0x688ac
movsd 0x10(%r15), %xmm2
movsd %xmm2, 0x18(%rsp)
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0xe238
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm2
cmpb $0xe, (%r14)
jne 0x688dc
movsd 0x10(%r14), %xmm3
xorpd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x81f0
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd387
movq %r9, %rbx
cmpb $0xd, %bpl
jne 0x68920
movsd 0x8(%r15), %xmm2
jmp 0x6893d
movq 0xe2109(%rip), %rdi     # 0x14aa30
leaq 0xa174a(%rip), %rdx     # 0x10a078
movq %r15, %rsi
callq 0xd498
movapd %xmm0, %xmm2
movb (%r14), %dil
cmpb $0xd, %dil
jne 0x6894b
movsd 0x8(%r14), %xmm1
jmp 0x68971
movq 0xe20de(%rip), %rdi     # 0x14aa30
leaq 0xa171f(%rip), %rdx     # 0x10a078
movq %r14, %rsi
movsd %xmm2, 0x10(%rsp)
callq 0xd498
movsd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm1
ucomisd %xmm2, %xmm2
jp 0x6830f
ucomisd %xmm1, %xmm1
jp 0x68994
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x689a6
jp 0x689a6
movq 0xecad4(%rip), %r14     # 0x155468
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
ucomisd %xmm0, %xmm2
jbe 0x689f0
movapd %xmm2, %xmm0
callq 0x8160
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x689e0
movq %rbx, %rdi
movsd %xmm0, 0x10(%rsp)
callq 0xa550
movsd 0x10(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
jmp 0x68525
movb (%r15), %bpl
jmp 0x68890
movq %r9, %rbx
cmpb $0xd, %bpl
jne 0x68a09
movsd 0x8(%r15), %xmm0
jmp 0x68a1f
movq 0xe2020(%rip), %rdi     # 0x14aa30
leaq 0xa1661(%rip), %rdx     # 0x10a078
movq %r15, %rsi
callq 0xd498
callq 0x8570
movq %rbx, %rdi
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x68a52
movsd %xmm0, 0x10(%rsp)
callq 0xa550
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rdi)
jmp 0x68525
movq %r9, %rdi
movl $0x1, %edx
movq %r10, %r8
movl $0x1, %esi
movq %rsi, %r9
testb $0x1, %r8b
movq %rax, %rsi
cmoveq %rdx, %rsi
imulq %r9, %rsi
imulq %rax, %rax
seto %r9b
cmpq $0x2, %r8
jb 0x68a9a
sarq %r8
testb %r9b, %r9b
je 0x68a72
movl $0x1, %eax
movl $0x1, %edx
movq %rdx, %r8
testb $0x1, %r10b
movq %rcx, %rdx
cmoveq %rax, %rdx
imulq %r8, %rdx
imulq %rcx, %rcx
seto %r8b
cmpq $0x2, %r10
jb 0x68b5f
sarq %r10
testb %r8b, %r8b
je 0x68aa4
jmp 0x68b5f
movq %r9, %r14
testq %r11, %r11
jle 0x68b26
movl $0x1, %ecx
movl $0x1, %ebx
movq %rbx, %rdx
testb $0x1, %r11b
movq %rax, %rbx
cmoveq %rcx, %rbx
imulq %rdx, %rbx
imulq %rax, %rax
seto %dl
cmpq $0x2, %r11
jb 0x68b0d
shrq %r11
testb %dl, %dl
je 0x68ae7
cmpq $0x7ff, %rbx            # imm = 0x7FF
ja 0x68b72
leaq 0xdde33(%rip), %rax     # 0x146950
movq (%rax,%rbx,8), %r14
jmp 0x68994
movl $0x1, %esi
movl $0x1, %edx
movq %rdx, %rdi
testb $0x1, %cl
movq %rax, %rdx
cmoveq %rsi, %rdx
imulq %rdi, %rdx
imulq %rax, %rax
seto %dil
cmpq $0x2, %rcx
jb 0x68b57
sarq %rcx
testb %dil, %dil
je 0x68b30
movl $0x1, %esi
movq %r14, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcfa8
movq 0x90(%r14), %rax
cmpq 0x98(%r14), %rax
ja 0x68b91
movq %r14, %rdi
callq 0xa550
movq 0x90(%r14), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%r14)
movq -0x8(%rax), %r14
movq $0xb, (%r14)
movq %rbx, 0x8(%r14)
jmp 0x68994