// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: g_divide_xy
static s7_pointer g_divide_xy(s7_scheme *sc, s7_pointer x, s7_pointer y, s7_pointer args)
    {
        /* splitting out real/real here saves very little */
        switch (type(x))
        {
            case T_INTEGER:
                switch (type(y))
                {
                    /* -------- integer x -------- */
                    case T_INTEGER:
                        if (integer(y) == 0)
                            return(division_by_zero_error(sc, sc->divide_symbol, set_elist_2(sc, x, y)));
                        return(s7_make_ratio(sc, integer(x), integer(y)));

                    case T_RATIO:
#if HAVE_OVERFLOW_CHECKS
                        {
                            s7_int dn;
                            if (multiply_overflow(integer(x), denominator(y), &dn))
                                return(make_real(sc, integer(x) * inverted_fraction(y)));
                            return(s7_make_ratio(sc, dn, numerator(y)));
                        }
#else
                        return(s7_make_ratio(sc, integer(x) * denominator(y), numerator(y)));
#endif

                    case T_REAL:
                        if (is_NaN(real(y))) return(real_NaN);
                        if (is_inf(real(y))) return(real_zero);
                        if (real(y) == 0.0)
                            return(division_by_zero_error(sc, sc->divide_symbol, args));
                        return(make_real(sc, (s7_double)(integer(x)) / real(y)));

                    case T_COMPLEX:
                        {
                            s7_double r1, i2, r2, den;
                            r1 = (s7_double)integer(x);
                            r2 = real_part(y);
                            i2 = imag_part(y);
                            den = 1.0 / (r2 * r2 + i2 * i2);
                            /* we could avoid the squaring (see Knuth II p613 16), not a big deal: (/ 1.0e308+1.0e308i 2.0e308+2.0e308i) => nan, (gmp case is ok here) */
                            return(s7_make_complex(sc, r1 * r2 * den, -(r1 * i2 * den)));
                        }

                    default:
#if WITH_GMP
                        if (s7_is_bignum(y))
                            return(big_divide(sc, list_2(sc, x, y)));
#endif
                        return(method_or_bust_with_type(sc, y, sc->divide_symbol, list_2(sc, x, y), a_number_string, 2));
                }
                break;

                /* -------- ratio x -------- */
            case T_RATIO:
                switch (type(y))
                {
                    case T_INTEGER:
                        if (integer(y) == 0)
                            return(division_by_zero_error(sc, sc->divide_symbol, set_elist_2(sc, x, y)));
#if HAVE_OVERFLOW_CHECKS
                        {
                            s7_int dn;
                            if (multiply_overflow(denominator(x), integer(y), &dn))
                                return(make_real(sc, (long_double)numerator(x) / ((long_double)denominator(x) * (s7_double)integer(y))));
                            return(s7_make_ratio(sc, numerator(x), dn));
                        }
#else
                        return(s7_make_ratio(sc, numerator(x), denominator(x) * integer(y)));
#endif

                    case T_RATIO:
                        {
                            s7_int d1, d2, n1, n2;
                            d1 = denominator(x);
                            n1 = numerator(x);
                            d2 = denominator(y);
                            n2 = numerator(y);
                            if (d1 == d2)
                                return(s7_make_ratio(sc, n1, n2));
#if (!WITH_GMP) && HAVE_OVERFLOW_CHECKS
                            if ((multiply_overflow(n1, d2, &n1)) ||
                                    (multiply_overflow(n2, d1, &d1)))
                            {
                                s7_double r1, r2;
                                r1 = fraction(x);
                                r2 = inverted_fraction(y);
                                return(make_real(sc, r1 * r2));
                            }
                            return(s7_make_ratio(sc, n1, d1));
#else
                            return(s7_make_ratio(sc, n1 * d2, n2 * d1));
#endif
                        }

                    case T_REAL:
                        if (real(y) == 0.0)
                            return(division_by_zero_error(sc, sc->divide_symbol, args));
                        return(make_real(sc, fraction(x) / real(y)));

                    case T_COMPLEX:
                        {
                            s7_double rx, r2, i2, den;
                            rx = fraction(x);
                            r2 = real_part(y);
                            i2 = imag_part(y);
                            den = 1.0 / (r2 * r2 + i2 * i2);
                            return(s7_make_complex(sc, rx * r2 * den, -rx * i2 * den));
                        }

                    default:
                        return(method_or_bust_with_type(sc, y, sc->divide_symbol, list_2(sc, x, y), a_number_string, 2));
                }

                /* -------- real x -------- */
            case T_REAL:
                switch (type(y))
                {
                    case T_INTEGER:
                        if (integer(y) == 0)
                            return(division_by_zero_error(sc, sc->divide_symbol, args));
                        if (is_NaN(real(x))) return(real_NaN); /* what is (/ +nan.0 0)? */
                        if (is_inf(real(x))) return((real(x) > 0.0) ? ((integer(y) > 0) ? real_infinity : real_minus_infinity) : ((integer(y) > 0) ? real_minus_infinity : real_infinity));
                        return(make_real(sc, real(x) / (s7_double)integer(y)));

                    case T_RATIO:
                        if (is_NaN(real(x))) return(real_NaN);
                        if (is_inf(real(x))) return((real(x) > 0) ? ((numerator(y) > 0) ? real_infinity : real_minus_infinity) : ((numerator(y) > 0) ? real_minus_infinity : real_infinity));
                        return(make_real(sc, real(x) * inverted_fraction(y)));

                    case T_REAL:
                        if (is_NaN(real(y))) return(real_NaN);
                        if (real(y) == 0.0)
                            return(division_by_zero_error(sc, sc->divide_symbol, args));
                        if (is_NaN(real(x))) return(real_NaN);
                        if (is_inf(real(y)))
                        {
                            if (is_inf(real(x))) return(real_NaN);
                            return(real_zero);
                        }
                        return(make_real(sc, real(x) / real(y)));

                    case T_COMPLEX:
                        {
                            s7_double den, r2, i2;
                            if (is_NaN(real(x))) return(real_NaN);
                            if (is_NaN(real_part(y))) return(real_NaN);
                            if (is_NaN(imag_part(y))) return(real_NaN);
                            if (is_inf(real_part(y))) return(real_zero);
                            r2 = real_part(y);
                            i2 = imag_part(y);
                            den = 1.0 / (r2 * r2 + i2 * i2);
                            return(s7_make_complex(sc, real(x) * r2 * den, -real(x) * i2 * den));
                        }

                    default:
                        return(method_or_bust_with_type(sc, y, sc->divide_symbol, list_2(sc, x, y), a_number_string, 2));
                }

                /* -------- complex x -------- */
            case T_COMPLEX:
                switch (type(y))
                {
                    case T_INTEGER:
                        {
                            s7_double r1;
                            if (integer(y) == 0)
                                return(division_by_zero_error(sc, sc->divide_symbol, args));
                            r1 = 1.0 / (s7_double)integer(y);
                            return(s7_make_complex(sc, real_part(x) * r1, imag_part(x) * r1));
                        }

                    case T_RATIO:
                        {
                            s7_double frac;
                            frac = inverted_fraction(y);
                            return(s7_make_complex(sc, real_part(x) * frac, imag_part(x) * frac));
                        }

                    case T_REAL:
                        {
                            s7_double r1;
                            if (real(y) == 0.0)
                                return(division_by_zero_error(sc, sc->divide_symbol, args));
                            r1 = 1.0 / real(y);
                            return(s7_make_complex(sc, real_part(x) * r1, imag_part(x) * r1));
                        }

                    case T_COMPLEX:
                        {
                            s7_double r1, r2, i1, i2, den;
                            r1 = real_part(x);
                            if (is_NaN(r1)) return(real_NaN);
                            i1 = imag_part(x);
                            if (is_NaN(i1)) return(real_NaN);
                            r2 = real_part(y);
                            if (is_NaN(r2)) return(real_NaN);
                            i2 = imag_part(y);
                            if (is_NaN(i2)) return(real_NaN);
                            den = 1.0 / (r2 * r2 + i2 * i2);
                            return(s7_make_complex(sc, (r1 * r2 + i1 * i2) * den, (r2 * i1 - r1 * i2) * den));
                        }

                    default:
                        return(method_or_bust_with_type(sc, y, sc->divide_symbol, list_2(sc, x, y), a_number_string, 2));
                }

                /* -------- any other type x -------- */
            default:
                return(method_or_bust_with_type(sc, x, sc->divide_symbol, list_2(sc, x, y), a_number_string, 1)); /* not args here! y = apply * to cdr(args) */
                break;
        }

        return(NULL); /* make the compiler happy */
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xfb87f
leaq 0xd711(%rip), %rdx      # 0x108e2c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movzbl (%r15), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xfb907
leaq 0xd731(%rip), %rdx      # 0x108e6c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r15), %rdx
testq %rdx, %rdx
jne 0xfbe05
jmp 0xfbe0b
movzbl (%r15), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xfb907
leaq 0xd6df(%rip), %rdx      # 0x108e4c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xfbe68
movsd 0x8(%r14), %xmm1
ucomisd %xmm1, %xmm1
jp 0xfb9f7
movq %xmm1, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jne 0xfbf1a
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
ja 0xfbb1c
testq %rax, %rax
leaq 0x56b10(%rip), %rax     # 0x1522d8
leaq 0x526d1(%rip), %rcx     # 0x14dea0
jmp 0xfbb2d
movzbl (%r15), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xfb907
leaq 0xd651(%rip), %rdx      # 0x108e3c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xfbe68
cvtsi2sd %rax, %xmm0
jmp 0xfba93
movzbl (%r15), %eax
addl $-0xb, %eax
cmpl $0x3, %eax
ja 0xfb907
leaq 0xd63a(%rip), %rdx      # 0x108e5c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xfbe0b
movq 0x10(%r14), %rcx
movq %rcx, %rdx
imulq %rax, %rdx
jno 0xfbe05
movq 0x8(%r14), %rdx
movq %rdx, 0x48(%rsp)
fildll 0x48(%rsp)
movq %rcx, 0x40(%rsp)
fildll 0x40(%rsp)
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x38(%rsp)
fmull 0x38(%rsp)
fdivrp %st, %st(1)
fstpl 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
jmp 0xfbed2
movq 0xe88(%rbx), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xfb8ac
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0x59aad(%rip), %r8      # 0x1553a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x1, %r9d
jmp 0xfb98a
movq 0xe88(%rbx), %r12
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %r13
cmpq 0x98(%rbx), %rax
ja 0xfb934
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq 0x59a25(%rip), %r8      # 0x1553a0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x2, %r9d
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe659
movsd 0x8(%r15), %xmm0
ucomisd %xmm0, %xmm0
jp 0xfb9f7
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xfb9bb
jnp 0xfbe68
movsd 0x8(%r14), %xmm1
ucomisd %xmm1, %xmm1
jp 0xfb9f7
movq %xmm0, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
cmpq %rax, %rcx
jne 0xfbf2a
movq %xmm1, %rcx
btrq $0x3f, %rcx
cmpq %rax, %rcx
jne 0xfbad1
movq 0x5249a(%rip), %rax     # 0x14de98
jmp 0xfbf74
movsd 0x8(%r14), %xmm1
ucomisd %xmm1, %xmm1
jp 0xfb9f7
movsd 0x8(%r15), %xmm3
ucomisd %xmm3, %xmm3
jp 0xfb9f7
movsd 0x10(%r15), %xmm2
ucomisd %xmm2, %xmm2
jp 0xfb9f7
movq %xmm3, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
je 0xfbad1
movapd %xmm2, %xmm4
mulsd %xmm2, %xmm4
movapd %xmm1, %xmm0
mulsd %xmm3, %xmm0
mulsd %xmm3, %xmm3
addsd %xmm4, %xmm3
movsd 0xa5cc(%rip), %xmm4     # 0x106030
divsd %xmm3, %xmm4
mulsd %xmm4, %xmm0
xorpd 0xe43c(%rip), %xmm1     # 0x109eb0
mulsd %xmm2, %xmm1
jmp 0xfbc1c
movsd 0x8(%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xfba93
jnp 0xfbe68
movsd 0xa595(%rip), %xmm1     # 0x106030
divsd %xmm0, %xmm1
jmp 0xfbcac
movsd 0x8(%r15), %xmm0
ucomisd %xmm0, %xmm0
jp 0xfb9f7
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rax
jne 0xfbe54
movq 0x4f180(%rip), %rax     # 0x14ac58
jmp 0xfbf74
movsd 0x8(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0xfb9f7
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jne 0xfbe8a
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq 0x8(%r15), %rax
jbe 0xfb7be
testq %rax, %rax
leaq 0x5237a(%rip), %rax     # 0x14dea0
leaq 0x567ab(%rip), %rcx     # 0x1522d8
cmovgq %rax, %rcx
movq (%rcx), %rax
jmp 0xfbf74
movsd 0x8(%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xfbb4f
jnp 0xfbe68
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movq %rax, 0x98(%rsp)
fildll 0x98(%rsp)
movq %rcx, 0x90(%rsp)
fildll 0x90(%rsp)
fdivrp %st, %st(1)
movsd %xmm0, 0x88(%rsp)
fdivl 0x88(%rsp)
fstpl 0x80(%rsp)
movsd 0x80(%rsp), %xmm0
jmp 0xfbed2
movsd 0x8(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0xfb9f7
movsd 0x10(%r14), %xmm2
ucomisd %xmm2, %xmm2
jp 0xfb9f7
movsd 0x8(%r15), %xmm1
ucomisd %xmm1, %xmm1
jp 0xfb9f7
movsd 0x10(%r15), %xmm3
ucomisd %xmm3, %xmm3
jp 0xfb9f7
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm1, %xmm5
mulsd %xmm1, %xmm5
addsd %xmm4, %xmm5
movsd 0xa438(%rip), %xmm4     # 0x106030
divsd %xmm5, %xmm4
movapd %xmm2, %xmm5
mulsd %xmm3, %xmm5
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm0
addsd %xmm5, %xmm0
mulsd %xmm4, %xmm0
mulsd %xmm2, %xmm1
subsd %xmm3, %xmm1
mulsd %xmm4, %xmm1
jmp 0xfbd36
cvtsi2sdq 0x8(%r14), %xmm2
movsd 0x8(%r15), %xmm0
movsd 0x10(%r15), %xmm1
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm4
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0xa3dd(%rip), %xmm3     # 0x106030
divsd %xmm4, %xmm3
mulsd %xmm2, %xmm0
mulsd %xmm3, %xmm0
xorpd 0xe249(%rip), %xmm1     # 0x109eb0
mulsd %xmm2, %xmm1
mulsd %xmm3, %xmm1
jmp 0xfbd36
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq %rcx, 0xe0(%rsp)
fildll 0xe0(%rsp)
movq %rax, 0xe8(%rsp)
fildll 0xe8(%rsp)
fdivrp %st, %st(1)
fstpl 0xd8(%rsp)
movsd 0xd8(%rsp), %xmm1
movsd 0x8(%r14), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x10(%r14), %xmm1
jmp 0xfbd36
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movq %rax, 0xb0(%rsp)
fildll 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
fildll 0xa8(%rsp)
fdivrp %st, %st(1)
fstpl 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm1
movsd 0x8(%r15), %xmm0
movsd 0x10(%r15), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm1, %xmm0
xorpd 0xe19e(%rip), %xmm1     # 0x109eb0
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm2
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
movsd 0xa306(%rip), %xmm2     # 0x106030
divsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
movq %rbx, %rdi
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd387
movq 0x8(%r14), %rcx
movq 0x10(%r15), %rax
movq %rcx, %rsi
imulq %rax, %rsi
jno 0xfbe38
movq %rcx, 0x18(%rsp)
fildll 0x18(%rsp)
movq %rax, 0x20(%rsp)
fildll 0x20(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x28(%rsp)
fildll 0x28(%rsp)
fdivrp %st, %st(1)
fmulp %st, %st(1)
fstpl 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
jmp 0xfbed2
movq 0x8(%r14), %rsi
movq 0x10(%r14), %r8
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rdi
cmpq %rdi, %r8
je 0xfbe3c
movq %rsi, %rax
imulq %rdi, %rax
jo 0xfbdc4
movq %rdx, %rcx
imulq %r8, %rcx
jno 0xfbf85
movq %rsi, 0x60(%rsp)
fildll 0x60(%rsp)
movq %r8, 0x68(%rsp)
fildll 0x68(%rsp)
fdivrp %st, %st(1)
fstpl 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
movq %rdi, 0x70(%rsp)
fildll 0x70(%rsp)
movq %rdx, 0x78(%rsp)
fildll 0x78(%rsp)
fdivrp %st, %st(1)
fstpl 0x50(%rsp)
mulsd 0x50(%rsp), %xmm0
jmp 0xfbed2
movq 0x8(%r14), %rsi
jmp 0xfbe3c
movq 0xe88(%rbx), %rsi
movq 0x6e0(%rbx), %rax
movq %r14, 0x8(%rax)
movq 0x6e0(%rbx), %rax
movq 0x10(%rax), %rax
movq %r15, 0x8(%rax)
movq 0x6e0(%rbx), %rdx
movq %rbx, %rdi
jmp 0xfbe75
movq 0x8(%r15), %rdx
movq %rbx, %rdi
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcfa8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xfbf21
jp 0xfbf21
movq 0xe88(%rbx), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd434
movsd %xmm0, 0xc0(%rsp)
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq %rcx, 0xd0(%rsp)
fildll 0xd0(%rsp)
movq %rax, 0xc8(%rsp)
fildll 0xc8(%rsp)
fdivrp %st, %st(1)
fmull 0xc0(%rsp)
fstpl 0xb8(%rsp)
movsd 0xb8(%rsp), %xmm0
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfbefd
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm0
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0xfbf74
cvtsi2sd %rax, %xmm0
jmp 0xfbf2a
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%r14), %xmm1
divsd %xmm0, %xmm1
movq 0x90(%rbx), %rax
cmpq 0x98(%rbx), %rax
ja 0xfbf59
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xa550
movsd 0x8(%rsp), %xmm1
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movq $0xd, (%rax)
movsd %xmm1, 0x8(%rax)
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
jmp 0xfbe3f