// File: /workspace/github_c_makefile_star2_O3/FredTheDino[P]Fog/src/engine/logic/block_physics.cpp
// Function: Physics::check_overlap(Physics::Body*, Physics::Body*)
Overlap check_overlap(Body *body_a, Body *body_b) {
    // NOTE: If I find that dragging along a surface is jagged,
    // we could try having weighted directions and add a little bit
    // of weight to the ones along the closing velocity. It might
    // help. I don't know.

    Overlap overlap = {body_a, body_b, -1.0f};
    if ((body_a->layer & body_b->layer) == 0) return overlap;

    Shape shape_a = find_shape(body_a->shape);
    Shape shape_b = find_shape(body_b->shape);

    Vec2 center = (body_a->position + body_b->position) * 0.5;

    Vec2 relative_position = (body_b->position) - (body_a->position);

    Vec2 scale = inverse(body_a->scale);
    List<Vec2> normals = shape_a.normals;
    for (u32 n = 0; n < 2; n++) {
        for (u32 i = 0; i < normals.length; i++) {
            Vec2 normal, axis_a, axis_b;
            normal = normals[i];
            normal = normalize(hadamard(normal, scale));

            if (n == 0) {
                f32 rotation = body_a->rotation - body_b->rotation;
                axis_a = normal;
                axis_b = rotate(normal, rotation);
                normal = rotate(normal, body_a->rotation);
                if (debug_view_is_on())
                    Renderer::push_line(MAX_LAYER, body_a->position, body_a->position + normal,
                                        V4(0.6, 0.0, 0.3, 1.0));
            } else {
                f32 rotation = body_b->rotation - body_a->rotation;
                axis_a = rotate(normal, rotation);
                axis_b = normal;
                normal = rotate(normal, body_b->rotation);
                if (debug_view_is_on())
                    Renderer::push_line(MAX_LAYER, body_b->position, body_b->position + normal,
                                        V4(0.0, 0.6, 0.3, 1.0));
            }

#if 0
            Vec2 axis_a, axis_b;
            axis_a = normal;
            axis_b = normal;
#endif

            Limit limit_a, limit_b;
            limit_a = project_shape(shape_a, axis_a, body_a->scale, body_a->offset);
            limit_b = project_shape(shape_b, axis_b, body_b->scale, body_b->offset);

            f32 projected_distance = dot(relative_position, normal);


            f32 depth;
            if (projected_distance > 0)
                depth = limit_a.upper - limit_b.lower - projected_distance;
            else
                depth = limit_b.upper - limit_a.lower + projected_distance;

            if (debug_view_is_on()) {
                Vec2 a1, a2;
                a1 = body_a->position + normal * limit_a.lower;
                a2 = body_a->position + normal * limit_a.upper;
                Renderer::push_line(MAX_LAYER, a1, a2, V4(1, 0, 1, 1));

                Vec2 b1, b2;
                b1 = body_b->position + normal * limit_b.lower;
                b2 = body_b->position + normal * limit_b.upper;
                Renderer::push_line(MAX_LAYER, b1, b2, V4(0, 1, 1, 1));

                //debug_line(body_a->position, body_a->position + axis_a);
                //debug_line(body_b->position, body_b->position + axis_b);
                Vec4 color = depth > 0 ? V4(1, 1, 0, 1) : V4(1, 0, 0, 1);
                Renderer::push_line(MAX_LAYER, center, center + normal * depth, color);
            }

            if (depth < 0)
                return overlap;

            if (depth < overlap.depth || overlap.depth == -1.0f) {
                overlap.depth = depth;
                overlap.normal = normal;
            }
        }

        normals = shape_b.normals;
        scale = inverse(body_b->scale);
    }

    if (debug_view_is_on())
        Renderer::push_line(MAX_LAYER, center, center + overlap.normal * overlap.depth,
                            V4(0, 1, 0, 1));

    if (dot(overlap.normal, relative_position) < 0) {
        // Make sure the normal faces body a
        overlap.normal = -overlap.normal;
    }

    overlap.is_valid = true;
    return overlap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movl $0xbf800000, 0x10(%rdi) # imm = 0xBF800000
movq $0x0, 0x14(%rdi)
movb $0x0, 0x1c(%rdi)
movl 0x4(%rdx), %eax
testl %eax, 0x4(%rsi)
je 0x25bff
movq %rdx, %r15
movq %rsi, %r14
movq %rbx, -0xb8(%rbp)
addq $0x14, %rbx
movl (%rsi), %esi
leaq -0x1d0(%rbp), %r12
movq %r12, %rdi
callq 0x24b24
movl (%r15), %esi
leaq -0x190(%rbp), %rdi
callq 0x24b24
movsd 0x14(%r15), %xmm2
movss 0x14(%r14), %xmm1
addss %xmm2, %xmm1
movaps %xmm2, %xmm3
shufps $0x55, %xmm2, %xmm3     # xmm3 = xmm3[1,1],xmm2[1,1]
addss 0x18(%r14), %xmm3
movss 0xabc3(%rip), %xmm0     # 0x30008
mulss %xmm0, %xmm1
mulss %xmm0, %xmm3
movaps %xmm1, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movaps %xmm1, -0xf0(%rbp)
movsd 0x14(%r14), %xmm0
movq %r14, -0x70(%rbp)
movsd 0x1c(%r14), %xmm1
subps %xmm0, %xmm2
movaps %xmm2, -0x120(%rbp)
movss 0xab7d(%rip), %xmm0     # 0x30004
movaps %xmm0, %xmm2
divss %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
divss %xmm1, %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps %xmm2, -0x130(%rbp)
movl 0x14(%r12), %eax
movq 0x18(%r12), %rcx
movq %rcx, -0xc0(%rbp)
movb 0x20(%r12), %cl
movq %rbx, -0xc8(%rbp)
movsd (%rbx), %xmm4
movl 0x2c(%r12), %r13d
movq 0x30(%r12), %r12
leaq -0x190(%rbp), %rsi
movl 0x2c(%rsi), %ebx
movq 0x30(%rsi), %r14
movl 0x14(%rsi), %edx
movl %edx, -0x94(%rbp)
movq 0x18(%rsi), %rdx
movq %rdx, -0xd0(%rbp)
movss 0xad33(%rip), %xmm3     # 0x30228
movb $0x1, %dl
movl %edx, -0x38(%rbp)
movb 0x20(%rsi), %dl
movb %dl, -0x2d(%rbp)
movq %r15, -0x68(%rbp)
testl %eax, %eax
je 0x25adc
xorl %edx, %edx
testb %cl, %cl
setne %dl
movl %edx, -0x98(%rbp)
movl %eax, %eax
movq %rax, -0xd8(%rbp)
xorl %eax, %eax
movaps %xmm3, %xmm0
movaps %xmm4, %xmm1
movaps %xmm1, -0x140(%rbp)
movaps %xmm0, -0x150(%rbp)
leaq 0x2044f(%rip), %rdi     # 0x4598e
movl $0x21, %esi
leaq 0x20460(%rip), %rdx     # 0x459ab
movl -0x98(%rbp), %ecx
movq %rax, %r15
callq 0x729c
movq -0xc0(%rbp), %rax
movq %r15, -0xe0(%rbp)
movsd (%rax,%r15,8), %xmm3
mulps -0x130(%rbp), %xmm3
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0     # xmm0 = xmm0[1,1],xmm3[1,1]
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
addss %xmm1, %xmm2
xorps %xmm1, %xmm1
sqrtss %xmm2, %xmm1
movss 0xaa68(%rip), %xmm2     # 0x30004
divss %xmm1, %xmm2
mulss %xmm2, %xmm3
mulss %xmm0, %xmm2
movaps %xmm3, -0x50(%rbp)
movaps %xmm3, %xmm0
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movaps %xmm0, -0xb0(%rbp)
movaps %xmm2, -0x90(%rbp)
xorps 0xaa79(%rip), %xmm2     # 0x30040
movaps %xmm2, -0x80(%rbp)
testb $0x1, -0x38(%rbp)
je 0x256e2
movq -0x70(%rbp), %r15
movss 0x10(%r15), %xmm0
movq -0x68(%rbp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
callq 0x2050
movss %xmm0, -0x60(%rbp)
movss -0x2c(%rbp), %xmm0
callq 0x2350
movaps -0x50(%rbp), %xmm2
movaps %xmm2, %xmm1
movss -0x60(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss -0x80(%rbp), %xmm3
mulss %xmm0, %xmm2
addss %xmm3, %xmm2
mulss -0x90(%rbp), %xmm0
addss %xmm1, %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps %xmm2, -0x60(%rbp)
movss 0x10(%r15), %xmm0
movss %xmm0, -0x34(%rbp)
callq 0x2050
movss %xmm0, -0x2c(%rbp)
movss -0x34(%rbp), %xmm0
callq 0x2350
movaps -0x50(%rbp), %xmm3
movaps -0x80(%rbp), %xmm2
movss -0x2c(%rbp), %xmm4
mulss %xmm4, %xmm2
movaps %xmm3, %xmm1
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
movaps -0x90(%rbp), %xmm2
mulss %xmm0, %xmm2
mulss %xmm4, %xmm3
addss %xmm2, %xmm3
movaps %xmm1, %xmm0
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movaps %xmm0, -0x50(%rbp)
cmpb $0x0, 0x3f2d5(%rip)     # 0x64965
je 0x256d2
movsd 0x14(%r15), %xmm0
addss %xmm0, %xmm1
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
addss %xmm2, %xmm3
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movl $0xe, %edi
movss 0xaba9(%rip), %xmm2     # 0x30260
movsd 0xacc1(%rip), %xmm3     # 0x30380
movaps %xmm2, %xmm4
movaps %xmm3, %xmm5
movss 0xab8f(%rip), %xmm6     # 0x3025c
callq 0x20a3f
movaps -0xb0(%rbp), %xmm5
movaps -0x60(%rbp), %xmm6
jmp 0x257ee
movq -0x68(%rbp), %r15
movss 0x10(%r15), %xmm0
movq -0x70(%rbp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
callq 0x2050
movss %xmm0, -0x60(%rbp)
movss -0x2c(%rbp), %xmm0
callq 0x2350
movaps -0x50(%rbp), %xmm2
movaps %xmm2, %xmm1
movss -0x60(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss -0x80(%rbp), %xmm3
mulss %xmm0, %xmm2
addss %xmm3, %xmm2
mulss -0x90(%rbp), %xmm0
addss %xmm1, %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps %xmm2, -0x60(%rbp)
movss 0x10(%r15), %xmm0
movss %xmm0, -0x34(%rbp)
callq 0x2050
movss %xmm0, -0x2c(%rbp)
movss -0x34(%rbp), %xmm0
callq 0x2350
movaps -0x50(%rbp), %xmm3
movaps -0x80(%rbp), %xmm2
movss -0x2c(%rbp), %xmm4
mulss %xmm4, %xmm2
movaps %xmm3, %xmm1
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
movaps -0x90(%rbp), %xmm2
mulss %xmm0, %xmm2
mulss %xmm4, %xmm3
addss %xmm2, %xmm3
movaps %xmm1, %xmm0
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movaps %xmm0, -0x50(%rbp)
cmpb $0x0, 0x3f1c8(%rip)     # 0x64965
je 0x257df
movsd 0x14(%r15), %xmm0
addss %xmm0, %xmm1
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
addss %xmm2, %xmm3
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movl $0xe, %edi
movsd 0xabac(%rip), %xmm2     # 0x30370
movsd 0xabb4(%rip), %xmm3     # 0x30380
movaps %xmm2, %xmm4
movaps %xmm3, %xmm5
movss 0xaa82(%rip), %xmm6     # 0x3025c
callq 0x20a3f
movaps -0xb0(%rbp), %xmm6
movaps -0x60(%rbp), %xmm5
movq -0x70(%rbp), %r15
xorps %xmm7, %xmm7
xorps %xmm1, %xmm1
testq %r13, %r13
je 0x25855
movsd 0x8(%r15), %xmm0
movaps %xmm5, %xmm1
mulps %xmm0, %xmm1
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm5, %xmm0
addss %xmm1, %xmm0
movsd 0x1c(%r15), %xmm2
xorps %xmm1, %xmm1
xorl %eax, %eax
movsd (%r12,%rax,8), %xmm3
mulps %xmm2, %xmm3
movaps %xmm5, %xmm4
mulps %xmm3, %xmm4
shufps $0x55, %xmm4, %xmm4     # xmm4 = xmm4[1,1,1,1]
mulss %xmm5, %xmm3
addss %xmm4, %xmm3
addss %xmm0, %xmm3
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
maxss %xmm3, %xmm4
minss %xmm3, %xmm1
unpcklps %xmm4, %xmm1            # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
incq %rax
cmpq %rax, %r13
jne 0x2581c
testq %rbx, %rbx
je 0x258b8
movq -0x68(%rbp), %rax
movsd 0x8(%rax), %xmm0
movaps %xmm6, %xmm2
mulps %xmm0, %xmm2
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
mulss %xmm6, %xmm0
addss %xmm2, %xmm0
movsd 0x1c(%rax), %xmm2
xorps %xmm7, %xmm7
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm3
mulps %xmm2, %xmm3
movaps %xmm6, %xmm4
mulps %xmm3, %xmm4
shufps $0x55, %xmm4, %xmm4     # xmm4 = xmm4[1,1,1,1]
mulss %xmm6, %xmm3
addss %xmm4, %xmm3
addss %xmm0, %xmm3
movaps %xmm7, %xmm4
shufps $0x55, %xmm7, %xmm4     # xmm4 = xmm4[1,1],xmm7[1,1]
maxss %xmm3, %xmm4
minss %xmm3, %xmm7
unpcklps %xmm4, %xmm7            # xmm7 = xmm7[0],xmm4[0],xmm7[1],xmm4[1]
incq %rax
cmpq %rax, %rbx
jne 0x2587f
movaps -0x120(%rbp), %xmm0
movaps %xmm0, %xmm2
movaps -0x50(%rbp), %xmm4
mulps %xmm4, %xmm2
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
mulss %xmm4, %xmm0
addss %xmm2, %xmm0
ucomiss 0xa95c(%rip), %xmm0     # 0x30238
movaps %xmm7, %xmm5
shufps $0x55, %xmm7, %xmm5     # xmm5 = xmm5[1,1],xmm7[1,1]
movaps %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
jbe 0x258f9
movaps %xmm2, %xmm3
subss %xmm7, %xmm3
subss %xmm0, %xmm3
jmp 0x25907
movaps %xmm5, %xmm3
subss %xmm1, %xmm3
addss %xmm3, %xmm0
movaps %xmm0, %xmm3
cmpb $0x0, 0x3f057(%rip)     # 0x64965
je 0x25a81
movaps %xmm4, %xmm6
shufps $0x55, %xmm4, %xmm6     # xmm6 = xmm6[1,1],xmm4[1,1]
movaps %xmm4, %xmm0
mulss %xmm1, %xmm0
mulss %xmm6, %xmm1
movaps %xmm6, %xmm8
movaps %xmm6, -0x80(%rbp)
movaps %xmm3, -0x90(%rbp)
movss 0x14(%r15), %xmm3
movaps %xmm4, %xmm6
movaps %xmm4, -0x50(%rbp)
movss 0x18(%r15), %xmm4
addss %xmm3, %xmm0
addss %xmm4, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movaps %xmm6, %xmm1
mulss %xmm2, %xmm1
mulss %xmm8, %xmm2
addss %xmm3, %xmm1
addss %xmm4, %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movl $0xe, %edi
movss 0xa68d(%rip), %xmm2     # 0x30004
movaps 0xa922(%rip), %xmm3     # 0x302a0
movaps %xmm2, %xmm4
movaps %xmm5, -0xb0(%rbp)
movaps %xmm3, %xmm5
movss 0xa8c9(%rip), %xmm6     # 0x3025c
movaps %xmm7, -0x60(%rbp)
callq 0x20a3f
movaps -0x50(%rbp), %xmm1
movaps %xmm1, %xmm0
movaps -0x60(%rbp), %xmm5
mulss %xmm5, %xmm0
movaps -0x80(%rbp), %xmm4
mulss %xmm4, %xmm5
movq -0x68(%rbp), %rax
movss 0x14(%rax), %xmm2
movss 0x18(%rax), %xmm3
addss %xmm2, %xmm0
addss %xmm3, %xmm5
unpcklps %xmm5, %xmm0            # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1]
movaps -0xb0(%rbp), %xmm5
mulss %xmm5, %xmm1
mulss %xmm4, %xmm5
addss %xmm2, %xmm1
addss %xmm3, %xmm5
unpcklps %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1]
movl $0xe, %edi
movsd 0xa99d(%rip), %xmm2     # 0x30390
movaps 0xa8a6(%rip), %xmm3     # 0x302a0
movaps %xmm2, %xmm4
movaps %xmm3, %xmm5
movss 0xa854(%rip), %xmm6     # 0x3025c
callq 0x20a3f
movaps -0x90(%rbp), %xmm0
ucomiss 0xa81d(%rip), %xmm0     # 0x30238
movaps 0xa87e(%rip), %xmm2     # 0x302a0
ja 0x25a2c
movss 0xa5d8(%rip), %xmm2     # 0x30004
movaps -0x50(%rbp), %xmm1
mulss %xmm0, %xmm1
movaps -0x80(%rbp), %xmm3
mulss %xmm0, %xmm3
addss -0x110(%rbp), %xmm1
addss -0x100(%rbp), %xmm3
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movl $0xe, %edi
movaps -0xf0(%rbp), %xmm0
movsd 0xa92d(%rip), %xmm3     # 0x30390
movaps %xmm2, %xmm4
movaps %xmm3, %xmm5
movss 0xa7eb(%rip), %xmm6     # 0x3025c
callq 0x20a3f
movaps -0x90(%rbp), %xmm3
movaps -0x50(%rbp), %xmm4
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
ja 0x25be1
movaps -0x150(%rbp), %xmm2
movaps %xmm2, %xmm0
movss 0xa789(%rip), %xmm1     # 0x30228
cmpeqps %xmm1, %xmm0
movaps %xmm3, %xmm1
cmpltps %xmm2, %xmm1
orps %xmm0, %xmm1
movd %xmm1, %eax
testb $0x1, %al
jne 0x25abf
movaps -0x140(%rbp), %xmm4
movaps %xmm2, %xmm3
movq -0xe0(%rbp), %rax
incq %rax
movaps %xmm3, %xmm0
movaps %xmm4, %xmm1
cmpq -0xd8(%rbp), %rax
jne 0x2552a
movq -0x68(%rbp), %r15
movsd 0x1c(%r15), %xmm0
movss 0xa516(%rip), %xmm1     # 0x30004
movaps %xmm1, %xmm2
divss %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
divss %xmm0, %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movaps %xmm2, -0x130(%rbp)
movb -0x2d(%rbp), %cl
movq -0xd0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl -0x94(%rbp), %eax
testb $0x1, -0x38(%rbp)
movl $0x0, -0x38(%rbp)
jne 0x25504
movq -0xb8(%rbp), %rbx
movss %xmm3, 0x10(%rbx)
movlps %xmm4, 0x14(%rbx)
cmpb $0x0, 0x3ee1f(%rip)     # 0x64965
je 0x25ba5
movaps %xmm4, %xmm0
shufps $0x55, %xmm4, %xmm0     # xmm0 = xmm0[1,1],xmm4[1,1]
movaps %xmm3, %xmm2
mulss %xmm4, %xmm2
mulss %xmm3, %xmm0
movaps -0x110(%rbp), %xmm1
addss %xmm2, %xmm1
movaps -0x100(%rbp), %xmm2
addss %xmm0, %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movsd 0xa815(%rip), %xmm2     # 0x30390
movss 0xa6d9(%rip), %xmm6     # 0x3025c
movl $0xe, %edi
movaps -0xf0(%rbp), %xmm0
movaps %xmm2, %xmm3
movaps %xmm4, -0x50(%rbp)
movaps %xmm2, %xmm4
movaps %xmm2, %xmm5
callq 0x20a3f
movaps -0x50(%rbp), %xmm4
movaps -0x120(%rbp), %xmm1
movaps %xmm1, %xmm0
mulps %xmm4, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm4, %xmm1
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x25bdb
movss %xmm4, %xmm4            # xmm4 = xmm4[0,1,2,3]
xorps 0xa46f(%rip), %xmm4     # 0x30040
movq -0xc8(%rbp), %rax
movlps %xmm4, (%rax)
movb $0x1, 0x1c(%rbx)
jmp 0x25bff
movq -0xb8(%rbp), %rbx
movaps -0x150(%rbp), %xmm0
movss %xmm0, 0x10(%rbx)
movaps -0x140(%rbp), %xmm0
movlps %xmm0, 0x14(%rbx)
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq