// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movzbl (%r14), %ebp
leaq 0xe564a(%rip), %rcx     # 0x152970
cmpb $0x0, (%rbp,%rcx)
je 0x6d358
movq 0x10(%r12), %rax
movq 0x8(%rax), %r15
movzbl (%r15), %eax
cmpb $0x0, (%rax,%rcx)
je 0x6d377
cmpl $0xd, %ebp
je 0x6d3a7
cmpl $0xb, %ebp
jne 0x6d3dd
cmpq $0x0, 0x8(%r14)
sete %cl
jmp 0x6d3ba
movq 0xed8(%rbx), %rdx
movq 0xf003a(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
movl $0x1, %r9d
jmp 0x6d394
movq 0xed8(%rbx), %rdx
movq 0xf001b(%rip), %r8      # 0x15d3a0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movl $0x2, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf3da
xorpd %xmm0, %xmm0
cmpeqsd 0x8(%r14), %xmm0
movq %xmm0, %rcx
andl $0x1, %ecx
testb %cl, %cl
je 0x6d3dd
cmpl $0xd, %eax
je 0x6d455
cmpl $0xb, %eax
jne 0x6d489
cmpq $0x0, 0x8(%r15)
sete %cl
jmp 0x6d468
cmpq $0xd, %rax
je 0x6d406
cmpl $0xb, %eax
jne 0x6d8c0
cmpq $0x1, 0x8(%r15)
je 0x6d420
cmpq $0xb, %rax
je 0x6d4f0
cmpl $0xd, %eax
jne 0x6d8c0
movsd 0x8(%r15), %xmm0
ucomisd 0xa1c1c(%rip), %xmm0    # 0x10f030
jne 0x6d4e7
jp 0x6d4e7
cmpl $0xb, %eax
je 0x6d44d
leaq 0xe55c4(%rip), %rax     # 0x1529f0
cmpb $0x1, (%rbp,%rax)
jne 0x6d44d
movq 0x8(%r14), %rax
cmpl $0xb, %ebp
jne 0x6d5af
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
jmp 0x6d5d1
movq %r14, %r13
jmp 0x6ddb1
xorpd %xmm0, %xmm0
cmpeqsd 0x8(%r15), %xmm0
movq %xmm0, %rcx
andl $0x1, %ecx
testb %cl, %cl
je 0x6d489
cmpl $0xb, %ebp
jne 0x6d69b
cmpb $0xb, %al
jne 0x6d69b
movq 0xe14d4(%rip), %r13     # 0x14e958
jmp 0x6ddb1
leaq 0xe5520(%rip), %rcx     # 0x1529b0
cmpb $0x1, (%rax,%rcx)
jne 0x6d4b1
cmpl $0xc, %eax
je 0x6d4a4
cmpl $0xb, %eax
jne 0x6d559
movq 0x8(%r15), %rcx
shrq $0x3f, %rcx
jmp 0x6d566
movsd 0x8(%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x6d56a
ucomisd %xmm0, %xmm0
jp 0x6d4db
movsd 0x10(%r15), %xmm0
ucomisd %xmm0, %xmm0
jnp 0x6d683
movq 0xe89b6(%rip), %r13     # 0x155e98
jmp 0x6ddb1
cmpl $0xb, %eax
jne 0x6d8c0
movq 0x8(%r15), %r11
testq %r11, %r11
je 0x6d61c
leal -0xb(%rbp), %eax
cmpl $0x3, %eax
ja 0x6d8b6
leaq 0xa34c4(%rip), %rcx     # 0x1109d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
cmpq $0x1, %rax
je 0x6d7b7
cmpq $-0x1, %rax
jne 0x6d7c1
movl 0xe54f1(%rip), %eax     # 0x152a28
shlq $0x3f, %rax
cmpq %rax, %r11
je 0x6d54d
movq %r14, %r13
testb $0x1, %r11b
jne 0x6d890
movq 0xe1404(%rip), %r13     # 0x14e958
jmp 0x6d890
xorpd %xmm0, %xmm0
ucomisd 0x8(%r15), %xmm0
seta %cl
testb %cl, %cl
je 0x6d58a
movq 0xed8(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe1ae
leaq 0xe545f(%rip), %rcx     # 0x1529f0
cmpb $0x0, (%rax,%rcx)
jne 0x6d683
cmpl $0xd, %eax
jne 0x6d663
movsd 0x8(%r15), %xmm0
jmp 0x6d679
movq %rax, 0x18(%rsp)
fildll 0x18(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x20(%rsp)
fildll 0x20(%rsp)
fdivrp %st, %st(1)
fstpl 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6d5f3
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r13
movq $0xd, (%r13)
movsd %xmm0, 0x8(%r13)
jmp 0x6ddb1
leaq 0xe53cd(%rip), %rax     # 0x1529f0
cmpb $0x1, (%rbp,%rax)
jne 0x6d636
movq 0xe1327(%rip), %r13     # 0x14e958
jmp 0x6d896
movq %r14, %rdi
callq 0xefb9
ucomisd %xmm0, %xmm0
jp 0x6ddc3
cmpl $0xe, %ebp
jne 0x6d775
movsd 0x10(%r14), %xmm0
ucomisd %xmm0, %xmm0
setp %al
jmp 0x6d777
movq 0xe53c6(%rip), %rdi     # 0x152a30
leaq 0xa58f7(%rip), %rdx     # 0x112f68
movq %r15, %rsi
callq 0xe212
ucomisd %xmm0, %xmm0
jp 0x6ddae
cmpb $0xb, (%r14)
jne 0x6d69b
cmpb $0xb, (%r15)
jne 0x6d69b
movq 0xe12ba(%rip), %r13     # 0x14e950
jmp 0x6ddb1
movq 0xe55b6(%rip), %r13     # 0x152c58
jmp 0x6ddb1
movsd 0x8(%r14), %xmm0
ucomisd 0xa199b(%rip), %xmm0    # 0x10f050
jne 0x6d8b6
jp 0x6d8b6
movl 0xe5361(%rip), %eax     # 0x152a28
shlq $0x3f, %rax
cmpq %rax, %r11
je 0x6d782
movq %r14, %r13
testb $0x1, %r11b
je 0x6d782
jmp 0x6d896
movq %r11, (%rsp)
movq %r14, %rdi
callq 0xefb9
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6d8b6
jp 0x6d8b6
cmpq $0xe, %rbp
jne 0x6d8b6
movsd 0x10(%r14), %xmm0
ucomisd 0xa1912(%rip), %xmm0    # 0x10f030
jne 0x6d89a
jp 0x6d89a
cmpb $0xe, %bpl
jne 0x6daa1
movsd 0x10(%r14), %xmm0
ucomisd %xmm1, %xmm0
seta %al
jmp 0x6daa3
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movl 0xe52d4(%rip), %edx     # 0x152a28
shlq $0x3f, %rdx
cmpq %rdx, %r11
jne 0x6d78e
movq %rax, %rdx
negq %rdx
cmovsq %rax, %rdx
cmpq %rcx, %rdx
jle 0x6d7dc
movq 0xe11dd(%rip), %r13     # 0x14e950
jmp 0x6d7e3
xorl %eax, %eax
movq %r14, %r13
testb %al, %al
jne 0x6d896
movq 0xefcdf(%rip), %r13     # 0x15d468
jmp 0x6d896
movq %r11, %rdi
negq %rdi
movq %r11, %rsi
cmovnsq %rdi, %rsi
movb 0xe54be(%rip), %r8b     # 0x152c60
cmpb $0x1, %r8b
jne 0x6d7e7
cmpq $0x3e, %rsi
ja 0x6d824
leaq 0xa520b(%rip), %rdx     # 0x1129c0
jmp 0x6d7f4
xorl %eax, %eax
movq %r14, %r13
jmp 0x6d892
movl 0xe5261(%rip), %ecx     # 0x152a28
shlq $0x3f, %rcx
cmpq %rcx, %r11
jne 0x6d82f
movq 0xe1179(%rip), %r13     # 0x14e950
jmp 0x6d890
movq 0xe86bd(%rip), %r13     # 0x155ea0
xorl %edx, %edx
jmp 0x6d826
cmpq $0x1e, %rsi
ja 0x6d824
leaq 0xa53cc(%rip), %rdx     # 0x112bc0
leaq (%rdx,%rsi,8), %r9
movq %rax, %r10
negq %r10
cmovsq %rax, %r10
movb $0x1, %dl
cmpq %r10, (%r9)
jl 0x6d826
testb %r8b, %r8b
je 0x6db0f
cmpq $0x3e, %rsi
ja 0x6d826
leaq 0xa51a1(%rip), %r8      # 0x1129c0
jmp 0x6db20
movb $0x1, %dl
testb %dl, %dl
je 0x6d896
jmp 0x6d8b6
cmpq %rcx, %rax
jne 0x6dadf
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
cvtsi2sd %r11, %xmm1
callq 0x9160
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6d86c
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r13
movq $0xd, (%r13)
movsd %xmm0, 0x8(%r13)
xorl %eax, %eax
testb %al, %al
jne 0x6d8b6
xorl %eax, %eax
jmp 0x6d8b8
cmpb $0xe, %bpl
jne 0x6d8b6
movsd 0x10(%r14), %xmm0
ucomisd 0xa17a2(%rip), %xmm0    # 0x10f050
jne 0x6d8b6
jnp 0x6d72a
movb $0x1, %al
testb %al, %al
je 0x6ddb1
movzbl (%r14), %eax
leaq 0xe50e5(%rip), %rdx     # 0x1529b0
cmpb $0x1, (%rax,%rdx)
jne 0x6da24
movzbl (%r15), %ecx
cmpb $0x1, (%rcx,%rdx)
jne 0x6da24
cmpb $0xc, %cl
jne 0x6d916
cmpq $0x1, 0x8(%r15)
jne 0x6d916
movq 0x10(%r15), %rcx
cmpq $0x3, %rcx
je 0x6d9ad
cmpq $0x2, %rcx
jne 0x6d916
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6cf9b
movq %rax, %r13
jmp 0x6da1a
cmpb $0xd, %al
jne 0x6d922
movsd 0x8(%r14), %xmm2
jmp 0x6d93c
movq 0xe5107(%rip), %rdi     # 0x152a30
leaq 0xa5638(%rip), %rdx     # 0x112f68
movq %r14, %rsi
callq 0xe212
movapd %xmm0, %xmm2
cmpb $0xd, (%r15)
jne 0x6d94a
movsd 0x8(%r15), %xmm1
jmp 0x6d96e
movq 0xe50df(%rip), %rdi     # 0x152a30
leaq 0xa5610(%rip), %rdx     # 0x112f68
movq %r15, %rsi
movsd %xmm2, (%rsp)
callq 0xe212
movsd (%rsp), %xmm2
movapd %xmm0, %xmm1
ucomisd %xmm2, %xmm2
jp 0x6dd9a
ucomisd %xmm1, %xmm1
jp 0x6dda4
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x6d99a
jp 0x6d99a
movq 0xefad3(%rip), %r13     # 0x15d468
jmp 0x6da1a
movb $0x1, %al
ucomisd %xmm0, %xmm2
jbe 0x6da1c
movapd %xmm2, %xmm0
callq 0x9160
jmp 0x6d9d4
cmpb $0xd, %al
jne 0x6d9b9
movsd 0x8(%r14), %xmm0
jmp 0x6d9cf
movq 0xe5070(%rip), %rdi     # 0x152a30
leaq 0xa55a1(%rip), %rdx     # 0x112f68
movq %r14, %rsi
callq 0xe212
callq 0x9570
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6d9f6
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0xb389
movsd (%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r13
movq $0xd, (%r13)
movsd %xmm0, 0x8(%r13)
xorl %eax, %eax
testb %al, %al
je 0x6ddb1
movq %r14, %rdi
callq 0xefb9
xorpd %xmm1, %xmm1
cmpb $0xe, (%r14)
xorpd %xmm2, %xmm2
jne 0x6da40
movsd 0x10(%r14), %xmm2
movsd %xmm2, 0x8(%rsp)
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0xefb9
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm2
cmpb $0xe, (%r15)
jne 0x6da6f
movsd 0x10(%r15), %xmm3
xorpd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm0, %xmm2
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x91f0
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe101
xorl %eax, %eax
movq (%rsp), %rsi
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
andl $0x3, %ecx
leaq 0xa2f29(%rip), %rdx     # 0x1109e4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testq %rsi, %rsi
setg %cl
xorb %al, %cl
je 0x6dc0a
movsd 0xa1576(%rip), %xmm1    # 0x10f050
jmp 0x6dc12
movq %r11, %rcx
negq %rcx
movq %r11, %rdx
cmovnsq %rcx, %rdx
cmpb $0x1, 0xe516d(%rip)     # 0x152c60
jne 0x6dc26
cmpq $0x3e, %rdx
ja 0x6dc46
leaq 0xa4eb6(%rip), %rsi     # 0x1129c0
jmp 0x6dc33
cmpq $0x1e, %rsi
ja 0x6d826
leaq 0xa50a0(%rip), %r8      # 0x112bc0
leaq (%r8,%rsi,8), %rsi
movq %rcx, %r8
negq %r8
cmovsq %rcx, %r8
cmpq %r8, (%rsi)
jl 0x6d826
movl $0x1, %edx
testq %r11, %r11
jle 0x6dca3
movq %r11, %r9
movq %r11, %rdi
movl $0x1, %esi
movq %rsi, %r8
testb $0x1, %dil
movq %rax, %rsi
cmoveq %rdx, %rsi
imulq %r8, %rsi
imulq %rax, %rax
seto %r8b
cmpq $0x2, %rdi
jb 0x6db78
shrq %rdi
testb %r8b, %r8b
je 0x6db50
movl $0x1, %eax
movl $0x1, %edx
movq %rdx, %rdi
testb $0x1, %r9b
movq %rcx, %rdx
cmoveq %rax, %rdx
imulq %rdi, %rdx
imulq %rcx, %rcx
seto %dil
cmpq $0x2, %r9
jb 0x6dd05
shrq %r9
testb %dil, %dil
je 0x6db82
jmp 0x6dd05
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6dbcb
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r13
movq $0xd, (%r13)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x8(%r13)
jmp 0x6d896
testq %rsi, %rsi
setg %cl
xorb %al, %cl
je 0x6dad2
movsd 0xa141e(%rip), %xmm1    # 0x10f030
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0xe101
movq %rax, %r13
jmp 0x6d896
cmpq $0x1e, %rdx
ja 0x6dc46
leaq 0xa4f8d(%rip), %rsi     # 0x112bc0
leaq (%rsi,%rdx,8), %rdx
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
cmpq %rsi, (%rdx)
jge 0x6dc4d
movb $0x1, %al
jmp 0x6d892
testq %r11, %r11
jle 0x6dd15
movl $0x1, %ecx
movl $0x1, %ebp
movq %rbp, %rdx
testb $0x1, %r11b
movq %rax, %rbp
cmoveq %rcx, %rbp
imulq %rdx, %rbp
imulq %rax, %rax
seto %dl
cmpq $0x2, %r11
jb 0x6dc86
shrq %r11
testb %dl, %dl
je 0x6dc60
cmpq $0x7ff, %rbp            # imm = 0x7FF
ja 0x6dd5b
leaq 0xe0cb6(%rip), %rax     # 0x14e950
movq (%rax,%rbp,8), %r13
jmp 0x6d890
movq %rdi, %r8
movl $0x1, %esi
movq %rsi, %r9
testb $0x1, %r8b
movq %rcx, %rsi
cmoveq %rdx, %rsi
imulq %r9, %rsi
imulq %rcx, %rcx
seto %r9b
cmpq $0x2, %r8
jb 0x6dcd3
sarq %r8
testb %r9b, %r9b
je 0x6dcab
movl $0x1, %ecx
movl $0x1, %edx
movq %rdx, %r8
testb $0x1, %dil
movq %rax, %rdx
cmoveq %rcx, %rdx
imulq %r8, %rdx
imulq %rax, %rax
seto %r8b
cmpq $0x2, %rdi
jb 0x6dd05
sarq %rdi
testb %r8b, %r8b
je 0x6dcdd
movq %rbx, %rdi
callq 0xdd7f
movq %rax, %r13
jmp 0x6d7e3
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 0x6dd46
sarq %rcx
testb %dil, %dil
je 0x6dd1f
movl $0x1, %esi
movq %rbx, %rdi
callq 0xdd7f
movq %rax, %r13
jmp 0x6d890
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0x6dd73
movq %rbx, %rdi
callq 0xb389
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %r13
movq $0xb, (%r13)
movq %rbp, 0x8(%r13)
jmp 0x6d890
xorl %eax, %eax
movq %r14, %r13
jmp 0x6da1c
xorl %eax, %eax
movq %r15, %r13
jmp 0x6da1c
movq %r15, %r13
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
movq %r14, %r13
jmp 0x6d8b8