LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmAxisAngleRotation
void hpmAxisAngleRotation(float *axis, float angle, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMpoint *a = (HPMpoint *) axis;
    initMat4(m);
    float c = cos(angle);
    float s = sin(angle);
    float C = 1 - c;
    float xx, xy, xz, yy, yz, zz, xs, ys, zs;
    hpmNormalize(axis);
    xx = a->x * a->x;
    xy = a->x * a->y;
    xz = a->x * a->z;
    yy = a->y * a->y;
    yz = a->y * a->z;
    zz = a->z * a->z;
    xs = a->x * s;
    ys = a->y * s;
    zs = a->z * s;
    
    m->_11 = xx*C + c;
    m->_12 = xy*C - zs;
    m->_13 = xz*C + ys;

    m->_21 = xy*C + zs;
    m->_22 = yy*C + c;
    m->_23 = yz*C - xs;

    m->_31 = xz*C - ys;
    m->_32 = yz*C + xs;
    m->_33 = zz*C + c;
    
    m->_44 = 1.0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm1, %xmm1
movups %xmm1, 0x30(%rsi)
movups %xmm1, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm1, (%rsi)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4310
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4210
cvtsd2ss %xmm0, %xmm4
movss 0x5489(%rip), %xmm0     # 0xb030
movaps 0x10(%rsp), %xmm12
subss %xmm12, %xmm0
movss 0x8(%r14), %xmm1
movsd (%r14), %xmm3
movaps %xmm3, %xmm2
mulps %xmm3, %xmm2
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
movaps %xmm3, %xmm5
mulss %xmm3, %xmm5
addss %xmm2, %xmm5
movaps %xmm1, %xmm2
mulss %xmm1, %xmm2
addss %xmm5, %xmm2
sqrtss %xmm2, %xmm2
divss %xmm2, %xmm1
shufps $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
divps %xmm2, %xmm3
movlps %xmm3, (%r14)
movss %xmm1, 0x8(%r14)
movaps %xmm3, %xmm6
shufps $0x55, %xmm3, %xmm6     # xmm6 = xmm6[1,1],xmm3[1,1]
movaps %xmm6, %xmm9
mulss %xmm6, %xmm9
movaps %xmm1, %xmm2
mulss %xmm1, %xmm2
movaps %xmm3, %xmm5
mulss %xmm4, %xmm5
mulss %xmm4, %xmm6
mulss %xmm1, %xmm4
movaps 0x542d(%rip), %xmm7     # 0xb050
movaps %xmm3, %xmm10
shufps $0x0, %xmm3, %xmm10     # xmm10 = xmm10[0,0],xmm3[0,0]
mulps %xmm3, %xmm10
movaps %xmm0, %xmm8
shufps $0x0, %xmm0, %xmm8      # xmm8 = xmm8[0,0],xmm0[0,0]
movaps %xmm12, %xmm11
unpcklps %xmm4, %xmm11           # xmm11 = xmm11[0],xmm4[0],xmm11[1],xmm4[1]
xorps %xmm7, %xmm4
shufps $0xd4, %xmm10, %xmm9    # xmm9 = xmm9[0,1],xmm10[1,3]
shufps $0x52, %xmm10, %xmm9    # xmm9 = xmm9[2,0],xmm10[1,1]
mulps %xmm8, %xmm10
addps %xmm11, %xmm10
movlps %xmm10, (%rbx)
unpcklps %xmm12, %xmm4           # xmm4 = xmm4[0],xmm12[0],xmm4[1],xmm12[1]
mulps %xmm8, %xmm9
addps %xmm4, %xmm9
movlps %xmm9, 0x10(%rbx)
xorps %xmm5, %xmm7
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
mulps %xmm3, %xmm1
movaps %xmm1, %xmm3
mulss %xmm0, %xmm3
subss %xmm6, %xmm3
unpcklps %xmm7, %xmm6            # xmm6 = xmm6[0],xmm7[0],xmm6[1],xmm7[1]
mulps %xmm1, %xmm8
addps %xmm6, %xmm8
movlps %xmm8, 0x20(%rbx)
movss %xmm3, 0x8(%rbx)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm0, %xmm1
addss %xmm5, %xmm1
movss %xmm1, 0x18(%rbx)
mulss %xmm0, %xmm2
addss %xmm12, %xmm2
movss %xmm2, 0x28(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateAxisAngle
void hpmRotateAxisAngle(float *axis, float angle, float *mat){
    if (angle == 0.0) return;
    float rot[16], r[16];
    hpmAxisAngleRotation(axis, angle, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x5cce
jp 0x5cce
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rsi
callq 0x43d0
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4110
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movaps 0x30(%r15), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpm2DScaling
void hpm2DScaling(float scaleX, float scaleY, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    m->_11 = scaleX;
    m->_22 = scaleY;
    m->_33 = 1.0;
    m->_44 = 1.0;
}

// Assembly:
xorps %xmm2, %xmm2
movups %xmm2, 0x14(%rdi)
movups %xmm2, 0x24(%rdi)
movups %xmm2, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movss %xmm0, (%rdi)
movss %xmm1, 0x14(%rdi)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x28(%rdi)
movl %eax, 0x3c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmScale2D
void hpmScale2D(float scaleX, float scaleY, float *mat){
    float scale[16], r[16];
    hpm2DScaling(scaleX, scaleY, scale);
    hpmMultMat4(scale, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm2, %xmm2
leaq 0x40(%rsp), %rdi
movups %xmm2, 0x14(%rdi)
movups %xmm2, 0x24(%rdi)
movups %xmm2, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movss %xmm0, (%rdi)
movss %xmm1, 0x14(%rdi)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x28(%rdi)
movl %eax, 0x3c(%rdi)
movq %rsp, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4110
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movaps 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpm3DScaling
void hpm3DScaling(float scaleX, float scaleY, float scaleZ, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    m->_11 = scaleX;
    m->_22 = scaleY;
    m->_33 = scaleZ;
    m->_44 = 1.0;
}

// Assembly:
xorps %xmm3, %xmm3
movups %xmm3, 0x14(%rdi)
movups %xmm3, 0x24(%rdi)
movups %xmm3, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movss %xmm0, (%rdi)
movss %xmm1, 0x14(%rdi)
movss %xmm2, 0x28(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmScale3D
void hpmScale3D(float scaleX, float scaleY, float scaleZ, float *mat){
    float scale[16], r[16];
    hpm3DScaling(scaleX, scaleY, scaleZ, scale);
    hpmMultMat4(scale, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm3, %xmm3
leaq 0x40(%rsp), %rdi
movups %xmm3, 0x14(%rdi)
movups %xmm3, 0x24(%rdi)
movups %xmm3, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movss %xmm0, (%rdi)
movss %xmm1, 0x14(%rdi)
movss %xmm2, 0x28(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
movq %rsp, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4110
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movaps 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmScaling
void hpmScaling(float factor, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    m->_11 = factor;
    m->_22 = factor;
    m->_33 = factor;
    m->_44 = 1.0;
}

// Assembly:
xorps %xmm1, %xmm1
movups %xmm1, 0x14(%rdi)
movups %xmm1, 0x24(%rdi)
movups %xmm1, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movss %xmm0, (%rdi)
movss %xmm0, 0x14(%rdi)
movss %xmm0, 0x28(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmScale
void hpmScale(float factor, float *mat){
    float scale[16], r[16];
    hpmScaling(factor, scale);
    hpmMultMat4(scale, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
leaq 0x40(%rsp), %rdi
movups %xmm1, 0x14(%rdi)
movups %xmm1, 0x24(%rdi)
movups %xmm1, 0x4(%rdi)
movq $0x0, 0x34(%rdi)
movss %xmm0, (%rdi)
movss %xmm0, 0x14(%rdi)
movss %xmm0, 0x28(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
movq %rsp, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4110
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movaps 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmTranslateRotateScale2D
void hpmTranslateRotateScale2D(float *point, float angle, float scale, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMpoint *p = (HPMpoint *) point;
    initMat4(m);
    float c = scale * cos(angle);
    float s = scale * sin(angle);
    m->_11 = c;
    m->_22 = c;
    m->_12 = -s;
    m->_21 = s;
    m->_33 = 1.0;
    m->_44 = 1.0;
    m->_14 = p->x;
    m->_24 = p->y;
    m->_34 = p->z;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm2, %xmm2
movups %xmm2, 0x28(%rsi)
movups %xmm2, 0x18(%rsi)
movups %xmm2, 0x8(%rsi)
movl $0x0, 0x38(%rsi)
cvtss2sd %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4310
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4210
movapd 0x10(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd 0x20(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
cvtpd2ps %xmm0, %xmm0
movss %xmm0, 0x14(%rbx)
movapd %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
xorps 0x4d08(%rip), %xmm1     # 0xb050
movss %xmm1, 0x10(%rbx)
movlpd %xmm0, (%rbx)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x28(%rbx)
movl %eax, 0x3c(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
movss 0x8(%r14), %xmm0
movss %xmm0, 0x38(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmOrthoViewport
void hpmOrthoViewport(float left, float right, float bottom, float top,
                      float near, float far,
                      float vLeft, float vRight, float vBottom, float vTop,
                      float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    m->_11 = (vRight - vLeft) / (right - left);
    m->_14 = (right*vLeft - vRight*left) / (right - left);
    m->_22 = (vTop - vBottom) / (top - bottom);
    m->_24 = (top*vBottom - vTop*bottom) / (top - bottom);
    m->_33 = -2 / (far - near);
    m->_34 = -(far + near) / (far - near);
    m->_44 = 1.0;
}

// Assembly:
movss 0x8(%rsp), %xmm9
movss 0x10(%rsp), %xmm8
xorps %xmm10, %xmm10
movups %xmm10, 0x14(%rdi)
movups %xmm10, 0x20(%rdi)
movups %xmm10, 0x4(%rdi)
movaps %xmm7, %xmm10
subss %xmm6, %xmm10
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
unpcklps %xmm9, %xmm6            # xmm6 = xmm6[0],xmm9[0],xmm6[1],xmm9[1]
mulps %xmm1, %xmm6
subps %xmm0, %xmm1
divss %xmm1, %xmm10
movss %xmm10, (%rdi)
unpcklps %xmm8, %xmm7            # xmm7 = xmm7[0],xmm8[0],xmm7[1],xmm8[1]
subss %xmm9, %xmm8
mulps %xmm0, %xmm7
subps %xmm7, %xmm6
divps %xmm1, %xmm6
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
divss %xmm1, %xmm8
movss %xmm8, 0x14(%rdi)
movlps %xmm6, 0x30(%rdi)
movaps %xmm5, %xmm0
subss %xmm4, %xmm0
movss 0x446d(%rip), %xmm1     # 0xb034
divss %xmm0, %xmm1
addss %xmm5, %xmm4
xorps 0x447a(%rip), %xmm4     # 0xb050
movss %xmm1, 0x28(%rdi)
divss %xmm0, %xmm4
movss %xmm4, 0x38(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmOrtho
void hpmOrtho(int width, int height, float near, float far, float *mat){
    float r = (float) width / 2;
    float l = -r;
    float t = (float) height / 2;
    float b = -t;
    hpmOrthoViewport(l, r, t, b, near, far, -1.0, 1.0, 1.0, -1.0, mat);
}

// Assembly:
movd %esi, %xmm2
movd %edi, %xmm3
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
cvtdq2ps %xmm3, %xmm2
xorps %xmm3, %xmm3
movups %xmm3, 0x14(%rdx)
movups %xmm3, 0x20(%rdx)
mulps 0x4473(%rip), %xmm2     # 0xb080
movups %xmm3, 0x4(%rdx)
movaps %xmm2, %xmm4
shufps $0x55, %xmm2, %xmm4     # xmm4 = xmm4[1,1],xmm2[1,1]
movaps 0x4431(%rip), %xmm3     # 0xb050
movaps %xmm2, %xmm5
xorps %xmm3, %xmm5
shufps $0x1, %xmm2, %xmm5      # xmm5 = xmm5[1,0],xmm2[0,0]
shufps $0xe2, %xmm2, %xmm5     # xmm5 = xmm5[2,0],xmm2[2,3]
movaps %xmm5, %xmm6
addps %xmm2, %xmm6
subps %xmm2, %xmm5
movaps %xmm5, %xmm7
shufps $0x1, %xmm6, %xmm7      # xmm7 = xmm7[1,0],xmm6[0,0]
shufps $0xe2, %xmm6, %xmm7     # xmm7 = xmm7[2,0],xmm6[2,3]
movss 0x43ee(%rip), %xmm8     # 0xb038
divss %xmm6, %xmm8
movss %xmm8, (%rdx)
subss %xmm2, %xmm2
shufps $0x55, %xmm5, %xmm5     # xmm5 = xmm5[1,1,1,1]
movss 0x43d0(%rip), %xmm6     # 0xb034
movaps %xmm6, %xmm8
divss %xmm5, %xmm8
movss %xmm8, 0x14(%rdx)
subss %xmm4, %xmm4
unpcklps %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
divps %xmm7, %xmm2
movlps %xmm2, 0x30(%rdx)
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
divss %xmm2, %xmm6
movss %xmm6, 0x28(%rdx)
addss %xmm1, %xmm0
xorps %xmm3, %xmm0
divss %xmm2, %xmm0
movss %xmm0, 0x38(%rdx)
movl $0x3f800000, 0x3c(%rdx) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmFrustumViewport
void hpmFrustumViewport(float left, float right, float bottom, float top,
                        float near, float far,
                        float vLeft, float vRight, float vBottom, float vTop,
                        float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    m->_11 = near * (vRight - vLeft) / (right - left);
    m->_13 = (vRight*left - right*vLeft) / (right - left);
    m->_22 = near * (vTop - vBottom) / (top - bottom);
    m->_23 = (vTop*bottom - top*vBottom) / (top - bottom);
    m->_33 = -(far + near) / (far - near);
    m->_34 = - (2.0 * far * near) / (far - near);
    m->_43 = -1.0;
}

// Assembly:
movss 0x8(%rsp), %xmm9
movss 0x10(%rsp), %xmm8
xorps %xmm10, %xmm10
movups %xmm10, 0x14(%rdi)
movups %xmm10, 0x24(%rdi)
movups %xmm10, 0x30(%rdi)
movups %xmm10, 0x4(%rdi)
movaps %xmm7, %xmm10
subss %xmm6, %xmm10
mulss %xmm4, %xmm10
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
unpcklps %xmm9, %xmm6            # xmm6 = xmm6[0],xmm9[0],xmm6[1],xmm9[1]
mulps %xmm1, %xmm6
subps %xmm0, %xmm1
divss %xmm1, %xmm10
movss %xmm10, (%rdi)
unpcklps %xmm8, %xmm7            # xmm7 = xmm7[0],xmm8[0],xmm7[1],xmm8[1]
subss %xmm9, %xmm8
mulss %xmm4, %xmm8
mulps %xmm0, %xmm7
subps %xmm6, %xmm7
divps %xmm1, %xmm7
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
divss %xmm1, %xmm8
movss %xmm8, 0x14(%rdi)
movlps %xmm7, 0x20(%rdi)
movaps %xmm4, %xmm0
addss %xmm5, %xmm0
xorps 0x4321(%rip), %xmm0     # 0xb050
xorps %xmm1, %xmm1
cvtss2sd %xmm5, %xmm1
subss %xmm4, %xmm5
divss %xmm5, %xmm0
movss %xmm0, 0x28(%rdi)
mulsd 0x42dd(%rip), %xmm1     # 0xb028
xorps %xmm0, %xmm0
cvtss2sd %xmm4, %xmm0
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm5, %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x38(%rdi)
movl $0xbf800000, 0x2c(%rdi) # imm = 0xBF800000
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmPerspective
void hpmPerspective(int width, int height, float near, float far, float angle,
		    float *mat){
    float scale = tan(hpmDegreesToRadians(angle * 0.5)) * near;
    float r = ((float) width / (float) height) * scale;
    float l = -r;
    float t = scale;
    float b = -t;
    hpmFrustum(l, r, b, t, near, far, mat);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
mulss 0x4286(%rip), %xmm2     # 0xb040
movl %esi, %ebp
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
mulsd 0x4235(%rip), %xmm0     # 0xb000
movl %edi, %r14d
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x42e0
movss 0x8(%rsp), %xmm4
xorps %xmm2, %xmm2
cvtss2sd %xmm4, %xmm2
xorps %xmm1, %xmm1
cvtsi2ss %r14d, %xmm1
mulsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
cvtsd2ss %xmm2, %xmm3
divss %xmm0, %xmm1
mulss %xmm3, %xmm1
movaps 0x4242(%rip), %xmm2     # 0xb050
movaps %xmm1, %xmm0
xorps %xmm2, %xmm0
xorps %xmm3, %xmm2
movss 0x421d(%rip), %xmm6     # 0xb03c
movss 0x4209(%rip), %xmm7     # 0xb030
movss 0xc(%rsp), %xmm5
movq %rbx, %rdi
pushq $-0x40800000            # imm = 0xBF800000
pushq $0x3f800000             # imm = 0x3F800000
callq 0x4390
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmLookAt
void hpmLookAt(float *eye, float *obj, float *up, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMpoint f, r, u;
    initMat4(m);
    hpmSubVec(eye, obj, (float *) &f);
    hpmNormalize((float *) &f);
    hpmCross(up, (float *) &f, (float *) &r);
    hpmNormalize((float *) &r);
    hpmCross((float *) &f, (float *) &r, (float *) &u);

    m->_11 = r.x;
    m->_12 = r.y;
    m->_13 = r.z;
    m->_21 = u.x;
    m->_22 = u.y;
    m->_23 = u.z;
    m->_31 = f.x;
    m->_32 = f.y;
    m->_33 = f.z;
    m->_14 =-hpmDot((float *) &r, eye);
    m->_24 =-hpmDot((float *) &u, eye);
    m->_34 =-hpmDot((float *) &f, eye);
    m->_44 = 1.0;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rcx)
movups %xmm0, 0x20(%rcx)
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
movss (%rdi), %xmm3
movss 0x4(%rdi), %xmm5
movaps %xmm3, %xmm1
subss (%rsi), %xmm1
movaps %xmm5, %xmm0
subss 0x4(%rsi), %xmm0
movss 0x8(%rdi), %xmm4
movaps %xmm4, %xmm2
subss 0x8(%rsi), %xmm2
movaps %xmm0, %xmm6
mulss %xmm0, %xmm6
movaps %xmm1, %xmm7
mulss %xmm1, %xmm7
addss %xmm6, %xmm7
movaps %xmm2, %xmm6
mulss %xmm2, %xmm6
addss %xmm7, %xmm6
sqrtss %xmm6, %xmm6
divss %xmm6, %xmm1
divss %xmm6, %xmm0
divss %xmm6, %xmm2
movss (%rdx), %xmm6
movss 0x4(%rdx), %xmm7
movss 0x8(%rdx), %xmm8
movaps %xmm0, %xmm9
mulss %xmm8, %xmm9
movaps %xmm1, %xmm10
mulss %xmm7, %xmm10
mulss %xmm2, %xmm7
subss %xmm9, %xmm7
movaps %xmm2, %xmm9
mulss %xmm6, %xmm9
mulss %xmm1, %xmm8
subss %xmm9, %xmm8
mulss %xmm0, %xmm6
subss %xmm10, %xmm6
movaps %xmm8, %xmm9
mulss %xmm8, %xmm9
movaps %xmm7, %xmm10
mulss %xmm7, %xmm10
addss %xmm9, %xmm10
movaps %xmm6, %xmm9
mulss %xmm6, %xmm9
addss %xmm10, %xmm9
sqrtss %xmm9, %xmm9
divss %xmm9, %xmm7
divss %xmm9, %xmm8
divss %xmm9, %xmm6
movaps %xmm8, %xmm10
mulss %xmm2, %xmm10
movaps %xmm0, %xmm9
mulss %xmm6, %xmm9
subss %xmm10, %xmm9
movaps %xmm6, %xmm10
mulss %xmm1, %xmm10
movaps %xmm2, %xmm11
mulss %xmm7, %xmm11
subss %xmm10, %xmm11
movaps %xmm7, %xmm12
mulss %xmm0, %xmm12
movaps %xmm1, %xmm10
mulss %xmm8, %xmm10
subss %xmm12, %xmm10
movss %xmm7, (%rcx)
movss %xmm8, 0x10(%rcx)
movss %xmm6, 0x20(%rcx)
movss %xmm9, 0x4(%rcx)
movss %xmm11, 0x14(%rcx)
movss %xmm10, 0x24(%rcx)
movss %xmm1, 0x8(%rcx)
movss %xmm0, 0x18(%rcx)
movss %xmm2, 0x28(%rcx)
mulss %xmm5, %xmm0
shufps $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
unpcklps %xmm11, %xmm8           # xmm8 = xmm8[0],xmm11[0],xmm8[1],xmm11[1]
mulps %xmm5, %xmm8
unpcklps %xmm9, %xmm7            # xmm7 = xmm7[0],xmm9[0],xmm7[1],xmm9[1]
mulss %xmm3, %xmm1
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
mulps %xmm7, %xmm3
addps %xmm8, %xmm3
unpcklps %xmm10, %xmm6           # xmm6 = xmm6[0],xmm10[0],xmm6[1],xmm10[1]
mulss %xmm4, %xmm2
unpcklps %xmm4, %xmm4            # xmm4 = xmm4[0,0,1,1]
mulps %xmm6, %xmm4
addps %xmm3, %xmm4
movaps 0x4075(%rip), %xmm3     # 0xb050
xorps %xmm3, %xmm4
movlps %xmm4, 0x30(%rcx)
addss %xmm1, %xmm0
addss %xmm2, %xmm0
xorps %xmm3, %xmm0
movss %xmm0, 0x38(%rcx)
movl $0x3f800000, 0x3c(%rcx) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmCameraInverse
void hpmCameraInverse(const float *camera, float *inverse){
    HPMmat4 *cam = (HPMmat4 *) camera;
    HPMmat4 *inv = (HPMmat4 *) inverse;
    // Rotation component
    inv->_11 = cam->_11;
    inv->_12 = cam->_21;
    inv->_13 = cam->_31;

    inv->_21 = cam->_12;
    inv->_22 = cam->_22;
    inv->_23 = cam->_32;

    inv->_31 = cam->_13;
    inv->_32 = cam->_23;
    inv->_33 = cam->_33;
    // Translation component
    inv->_14 = -(cam->_11*cam->_14 + cam->_21*cam->_24 + cam->_31*cam->_34);
    inv->_24 = -(cam->_12*cam->_14 + cam->_22*cam->_24 + cam->_32*cam->_34);
    inv->_34 = -(cam->_13*cam->_14 + cam->_23*cam->_24 + cam->_33*cam->_34);
    // Last row
    inv->_41 = 0;
    inv->_42 = 0;
    inv->_43 = 0;
    inv->_44 = 1;
}

// Assembly:
movss (%rdi), %xmm5
movss %xmm5, (%rsi)
movss 0x4(%rdi), %xmm0
movss %xmm0, 0x10(%rsi)
movss 0x8(%rdi), %xmm0
movss %xmm0, 0x20(%rsi)
movss 0x10(%rdi), %xmm3
movss %xmm3, 0x4(%rsi)
movss 0x14(%rdi), %xmm6
movss %xmm6, 0x14(%rsi)
movss 0x18(%rdi), %xmm0
movss %xmm0, 0x24(%rsi)
movss 0x20(%rdi), %xmm0
movss %xmm0, 0x8(%rsi)
movss 0x24(%rdi), %xmm1
movss %xmm1, 0x18(%rsi)
movss 0x28(%rdi), %xmm2
movss %xmm2, 0x28(%rsi)
movss 0x34(%rdi), %xmm7
movss 0x38(%rdi), %xmm4
movss 0x4(%rdi), %xmm8
mulss %xmm7, %xmm8
mulss 0x30(%rdi), %xmm5
addss %xmm8, %xmm5
movss 0x8(%rdi), %xmm8
mulss %xmm4, %xmm8
addss %xmm5, %xmm8
movaps 0x3fc8(%rip), %xmm5     # 0xb050
xorps %xmm5, %xmm8
movss %xmm8, 0x30(%rsi)
movss 0x30(%rdi), %xmm8
mulss %xmm6, %xmm7
mulss %xmm8, %xmm3
mulss %xmm4, %xmm2
mulss 0x18(%rdi), %xmm4
addss %xmm7, %xmm3
addss %xmm3, %xmm4
xorps %xmm5, %xmm4
movss %xmm4, 0x34(%rsi)
mulss 0x34(%rdi), %xmm1
mulss %xmm8, %xmm0
addss %xmm1, %xmm0
addss %xmm2, %xmm0
xorps %xmm5, %xmm0
movss %xmm0, 0x38(%rsi)
xorl %eax, %eax
movl %eax, 0xc(%rsi)
movl %eax, 0x1c(%rsi)
movl %eax, 0x2c(%rsi)
movl $0x3f800000, 0x3c(%rsi) # imm = 0x3F800000
retq
nop
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsInitVector
void hpsInitVector(HPSvector *vector, size_t initialCapacity){
    if (initialCapacity > 0){
	vector->data = malloc(initialCapacity * sizeof(void *));
    } else {
	vector->data = NULL;
    }
    vector->capacity = initialCapacity;
    vector->isStatic = false;
    vector->size = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x7106
leaq (,%r14,8), %rdi
callq 0x4260
jmp 0x7108
xorl %eax, %eax
movq %rax, (%rbx)
movq %r14, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsPush
void hpsPush(HPSvector *vector, void *value){
    if (vector->size == vector->capacity){
	if (vector->isStatic){
	    void * new = malloc(2 * vector->capacity * sizeof(void *));
	    memcpy(new, vector->data,
		   sizeof(void*) * vector->capacity);
	    vector->data = new;
	    vector->capacity *= 2;
	    vector->isStatic = false;
	} else if (vector->capacity != 0){
	    vector->data = realloc(vector->data,
				   2 * vector->capacity * sizeof(void *));
	    vector->capacity *= 2;
	} else {
	    vector->data = malloc(DEFAULT_VECTOR_SIZE * sizeof(void *));
	    vector->capacity = DEFAULT_VECTOR_SIZE;
	}

    }
    vector->data[vector->size++] = value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
jne 0x71e2
cmpb $0x1, 0x18(%r14)
jne 0x71e7
movq %r15, %rdi
shlq $0x4, %rdi
callq 0x4260
movq %rax, %r12
movq (%r14), %rsi
leaq (,%r15,8), %rdx
movq %rax, %rdi
callq 0x4220
movq %r12, (%r14)
leaq (%r15,%r15), %rax
movq %rax, 0x10(%r14)
movb $0x0, 0x18(%r14)
jmp 0x7226
movq (%r14), %r12
jmp 0x7226
testq %r15, %r15
je 0x720b
movq (%r14), %rdi
shlq $0x4, %r15
movq %r15, %rsi
callq 0x42f0
movq %rax, %r12
movq %rax, (%r14)
shlq 0x10(%r14)
movq 0x8(%r14), %r15
jmp 0x7226
movl $0x20, %edi
callq 0x4260
movq %rax, %r12
movq %rax, (%r14)
movq $0x4, 0x10(%r14)
xorl %r15d, %r15d
leaq 0x1(%r15), %rax
movq %rax, 0x8(%r14)
movq %rbx, (%r12,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsRemove
bool hpsRemove(HPSvector *vector, void *el){
    int i;
    for (i = 0; i < vector->size; i++){
	if (vector->data[i] == el){
	    hpsRemoveNth(vector, i);
	    return true;
	}
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x72b9
movq %rdi, %rbx
movq (%rdi), %rax
cmpq %rsi, (%rax)
je 0x72bd
leaq -0x1(%rdx), %rdi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x72b9
leaq 0x1(%r8), %rcx
cmpq %rsi, 0x8(%rax,%r8,8)
movq %rcx, %r8
jne 0x729d
cmpq %rcx, %rdx
seta %bpl
jmp 0x72c2
xorl %ebp, %ebp
jmp 0x72e1
movb $0x1, %bpl
xorl %ecx, %ecx
leaq (%rax,%rcx,8), %rdi
leaq (%rax,%rcx,8), %rsi
addq $0x8, %rsi
notq %rcx
addq %rcx, %rdx
shlq $0x3, %rdx
callq 0x4300
decq 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsRemoveNth
bool hpsRemoveNth(HPSvector *vector, size_t index){
    if (vector->size == 0 || index >= vector->size) return false;
    if (index <= (vector->size - 1))
	memmove(&vector->data[index], &vector->data[index + 1],
                sizeof(void*) * (vector->size - index - 1));
    --vector->size;
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %r15
cmpq %rsi, %r15
jbe 0x7323
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rax,%rbx,8), %rdi
leaq (%rax,%rbx,8), %rsi
addq $0x8, %rsi
movq %rbx, %rdx
notq %rdx
addq %r15, %rdx
shlq $0x3, %rdx
callq 0x4300
decq 0x8(%r14)
cmpq %rbx, %r15
seta %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsInitPool
void hpsInitPool(HPSpool pool, void *data, size_t blockSize, size_t nBlocks, char name[32]){
    int i;
    char *poolStart = (char *) data;
    struct pool *p = (struct pool*) pool;
    p->blockSize = blockSize;
    p->nBlocks = nBlocks;
    p->nextPool = NULL;
    p->freeBlock = (void**) data;
    strcpy(p->name, name);
    for(i = 0; i < nBlocks - 1; i++){
	void **next = (void **) &poolStart[i * blockSize];
	*next = &poolStart[(i+1) * blockSize];
    }
    void **last = (void **) &poolStart[(nBlocks - 1) * blockSize];
    *last = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movl %r15d, (%rdi)
movl %ebx, 0x4(%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x8(%rdi)
addq $0x18, %rdi
movq %r8, %rsi
callq 0x4070
decq %rbx
je 0x7376
movq %rbx, %rax
movq %r14, %rcx
leaq (%rcx,%r15), %rdx
movq %rdx, (%rcx)
movq %rdx, %rcx
decq %rax
jne 0x7367
imulq %r15, %rbx
movq $0x0, (%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsDeletePool
void hpsDeletePool(HPSpool pool){
    struct pool *data = (struct pool*) pool;
    if (data->nextPool)
	hpsDeletePool(data->nextPool);
    free(pool);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x73ed
callq 0x4290
movq %rbx, %rdi
popq %rbx
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsClearPool
void hpsClearPool(HPSpool pool){
    int i;
    struct pool *data = (struct pool*) pool;
    if (data->nextPool)
	hpsClearPool(data->nextPool);
    char *poolStart = &((char *) pool)[sizeof(struct pool)];
    const unsigned int size = data->blockSize;
    const unsigned int nBlocks = data->nBlocks;
    data->freeBlock = (void**) poolStart;
    for(i = 0; i < nBlocks - 1; i++){
	void **next = (void **) &poolStart[i * size];
	*next = &poolStart[(i+1) * size];
    }
    void **last = (void **) &poolStart[(nBlocks - 1) * size];
    *last = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x7408
callq 0x4160
leaq 0x38(%rbx), %rax
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movq %rax, 0x8(%rbx)
decl %ecx
je 0x742f
movl %ecx, %esi
xorl %edi, %edi
movl %edi, %r8d
addl %edx, %edi
leaq (%rax,%rdi), %r9
movq %r9, (%rax,%r8)
decq %rsi
jne 0x741d
imull %edx, %ecx
movq $0x0, (%rax,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsAllocateFrom
void *hpsAllocateFrom(HPSpool pool){
#ifdef DEBUG
      if (!pool){
      fprintf(stderr, "Fatal: trying to allocate to a pool that doesn't exist!\n");
      exit(EXIT_FAILURE);
      }
#endif
    struct pool *data = (struct pool*) pool;
    void **block = data->freeBlock;
    if (!block){
	growPool(pool);
	block = data->freeBlock;
    }
    data->freeBlock = *block;
    return block;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x74ac
movq %rbx, %rax
movq %rax, %r13
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x7454
movl (%rbx), %eax
cmpl $0x9, %eax
movl $0x8, %r14d
cmovael %eax, %r14d
movl 0x4(%rbx), %r15d
movq %r14, %rdi
imulq %r15, %rdi
addq $0x38, %rdi
callq 0x4260
movq %rax, %r12
leaq 0x38(%rax), %rsi
leaq 0x3c35(%rip), %r8       # 0xb0c6
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x4340
movq %r12, 0x10(%r13)
movq 0x8(%r12), %rax
movq %rax, 0x8(%rbx)
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: hpsAABBupdateNode
void hpsAABBupdateNode(Node *node){
    AABBtree *tree = (AABBtree *) node->area;
    AABBtree *t = tree;
    while (t->parent && !contains(t, node->boundingSphere)){
	t = t->parent;
    }
    t = hpsAABBfindNode(node, t);
    if (t != tree){
	hpsAABBremoveNode(node);
	addNode(node, t);
        growExtents(t, node->boundingSphere);
    } else {
	growExtents(t, node->boundingSphere);
	shrinkExtents(t, node->boundingSphere);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %rdx
movq %r12, %r14
testq %rdx, %rdx
je 0x762c
movq (%rbx), %rax
movss (%rax), %xmm0
movss 0xc(%rax), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
addss %xmm1, %xmm0
movq %r12, %rcx
movq %rcx, %r14
movq %rdx, %rcx
ucomiss 0xf8(%r14), %xmm2
jb 0x7621
movss 0x4(%rax), %xmm3
movaps %xmm3, %xmm4
subss %xmm1, %xmm4
ucomiss 0xfc(%r14), %xmm4
jb 0x7621
movss 0x8(%rax), %xmm4
movaps %xmm4, %xmm5
subss %xmm1, %xmm5
ucomiss 0x100(%r14), %xmm5
jb 0x7621
movss 0x104(%r14), %xmm5
ucomiss %xmm0, %xmm5
jb 0x7621
addss %xmm1, %xmm3
movss 0x108(%r14), %xmm5
ucomiss %xmm3, %xmm5
jb 0x7621
addss %xmm1, %xmm4
movss 0x10c(%r14), %xmm3
ucomiss %xmm4, %xmm3
jae 0x762c
movq (%rcx), %rdx
movq %rcx, %r14
testq %rdx, %rdx
jne 0x75b3
movq %r14, %r15
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x7753
movq %rax, %r14
cmpq %rax, %r15
jne 0x762c
cmpq %r12, %r15
je 0x767b
movq %rbx, %rdi
callq 0x4120
movq %r14, %rdi
addq $0x118, %rdi            # imm = 0x118
movq %rbx, %rsi
callq 0x4270
movq %r14, 0x8(%rbx)
movq (%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7915
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x7915
movq (%rbx), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x79e5
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: hpsAABBfindNode
AABBtree *hpsAABBfindNode(Node *node, AABBtree *tree){
    AABBtree *t = tree;
    AABBtree *u = NULL;
    while (u != t){
	u = t;
	t = whichBranch(t, node->boundingSphere);
    }
    return t;
}

// Assembly:
testq %rsi, %rsi
je 0x7750
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x7753
cmpq %rax, %r14
movq %rax, %r14
jne 0x7735
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: whichBranch
static AABBtree *whichBranch(AABBtree *tree, BoundingSphere *bs){
    float radius = bs->r;
    float ov = radius * radius * radius;
    float bv = (tree->max.x - tree->min.x) *
	(tree->max.y - tree->min.y) * (tree->max.z - tree->min.z);
    if (!tree->split ||
	(tree->extentsCorrect && (ov > bv/8) &&
	 (tree->nodes.size != tree->nodes.capacity)))
	return tree;
    int x = 0, y =0, z = 0;
    if (tree->split & SPLIT_X){
	if (bs->x + radius < tree->splitPoint.x)
	    x = 0;
	else if (bs->x - radius > tree->splitPoint.x)
	    x = 2;
	else x = 1;
    }
    if (tree->split & SPLIT_Y){
	if (bs->y + radius < tree->splitPoint.y)
	    y = 0;
	else if (bs->y - radius > tree->splitPoint.y)
	    y = 2;
	else y = 1;
    }
    if (tree->split & SPLIT_Z){
	if (bs->z + radius < tree->splitPoint.z)
	    z = 0;
	else if (bs->z - radius > tree->splitPoint.z)
	    z = 2;
	else z = 1;
    }
    int i = x + y*3 + z*9;
    if (tree->children[i])
	return tree->children[i];
    else
	return tree->children[i] = newTree(tree->pool, tree);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0xe8(%rdi), %eax
testw %ax, %ax
je 0x77f3
movss 0xc(%rsi), %xmm0
cmpb $0x1, 0x110(%rbx)
jne 0x77d3
movss 0x104(%rbx), %xmm1
subss 0xf8(%rbx), %xmm1
movsd 0x108(%rbx), %xmm2
movsd 0xfc(%rbx), %xmm3
subps %xmm3, %xmm2
mulss %xmm2, %xmm1
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
mulss %xmm1, %xmm2
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss 0x390a(%rip), %xmm2     # 0xb0c8
ucomiss %xmm2, %xmm1
jbe 0x77d3
movq 0x120(%rbx), %rcx
cmpq 0x128(%rbx), %rcx
jne 0x77f3
testb $0x1, %al
je 0x77ef
movss (%rsi), %xmm1
movaps %xmm0, %xmm3
addss %xmm1, %xmm3
movss 0xec(%rbx), %xmm2
ucomiss %xmm3, %xmm2
jbe 0x77fb
xorl %ecx, %ecx
jmp 0x780a
movq %rbx, %r14
jmp 0x78e1
subss %xmm0, %xmm1
xorl %ecx, %ecx
ucomiss %xmm2, %xmm1
seta %cl
incq %rcx
testb $0x2, %al
je 0x7827
movss 0x4(%rsi), %xmm1
movaps %xmm0, %xmm3
addss %xmm1, %xmm3
movss 0xf0(%rbx), %xmm2
ucomiss %xmm3, %xmm2
jbe 0x782c
xorl %r12d, %r12d
jmp 0x7840
subss %xmm0, %xmm1
xorl %edx, %edx
ucomiss %xmm2, %xmm1
seta %dl
leaq (%rdx,%rdx,2), %r12
addq $0x3, %r12
testb $0x4, %al
je 0x785d
movss 0x8(%rsi), %xmm1
movaps %xmm0, %xmm3
addss %xmm1, %xmm3
movss 0xf4(%rbx), %xmm2
ucomiss %xmm3, %xmm2
jbe 0x7861
xorl %eax, %eax
jmp 0x7875
subss %xmm0, %xmm1
xorl %eax, %eax
ucomiss %xmm2, %xmm1
seta %al
leaq (%rax,%rax,8), %rax
addq $0x9, %rax
addq %rcx, %r12
addq %rax, %r12
movq 0x8(%rbx,%r12,8), %r14
testq %r14, %r14
jne 0x78e1
movq 0xe0(%rbx), %r15
movq %r15, %rdi
callq 0x43a0
movq %rax, %r14
leaq 0x118(%rax), %rdi
leaq 0x138(%rax), %rsi
movl $0x2d, %edx
callq 0x4350
movq %rbx, (%r14)
movq %r15, 0xe0(%r14)
movl $0x0, 0xe8(%r14)
movb $0x0, 0x110(%r14)
leaq 0x8(%r14), %rdi
movl $0xd8, %edx
xorl %esi, %esi
callq 0x41a0
movq %r14, 0x8(%rbx,%r12,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: growExtents
static void growExtents(AABBtree *tree, BoundingSphere *bs){
    AABBtree *t = tree;
    do {
	t->max.x = fmax(t->max.x, bs->x + bs->r);
	t->max.y = fmax(t->max.y, bs->y + bs->r);
	t->max.z = fmax(t->max.z, bs->z + bs->r);
	t->min.x = fmin(t->min.x, bs->x - bs->r);
	t->min.y = fmin(t->min.y, bs->y - bs->r);
	t->min.z = fmin(t->min.z, bs->z - bs->r);
    } while ((t = t->parent));
   
}

// Assembly:
movss 0xc(%rsi), %xmm3
movsd (%rsi), %xmm0
movss 0x8(%rsi), %xmm1
movaps %xmm3, %xmm2
addss %xmm1, %xmm2
subss %xmm3, %xmm1
movaps %xmm3, %xmm4
shufps $0x0, %xmm3, %xmm4      # xmm4 = xmm4[0,0],xmm3[0,0]
movaps %xmm0, %xmm3
addps %xmm4, %xmm3
subps %xmm4, %xmm0
movsd 0x104(%rdi), %xmm4
movaps %xmm3, %xmm5
maxps %xmm4, %xmm5
cmpunordps %xmm4, %xmm4
movaps %xmm3, %xmm6
andps %xmm4, %xmm6
andnps %xmm5, %xmm4
orps %xmm6, %xmm4
movlps %xmm4, 0x104(%rdi)
movss 0x10c(%rdi), %xmm4
movaps %xmm2, %xmm5
maxss %xmm4, %xmm5
cmpunordss %xmm4, %xmm4
movaps %xmm4, %xmm6
andps %xmm2, %xmm6
andnps %xmm5, %xmm4
orps %xmm6, %xmm4
movss %xmm4, 0x10c(%rdi)
movsd 0xf8(%rdi), %xmm4
movaps %xmm0, %xmm5
minps %xmm4, %xmm5
cmpunordps %xmm4, %xmm4
movaps %xmm0, %xmm6
andps %xmm4, %xmm6
andnps %xmm5, %xmm4
orps %xmm6, %xmm4
movlps %xmm4, 0xf8(%rdi)
movss 0x100(%rdi), %xmm4
movaps %xmm1, %xmm5
minss %xmm4, %xmm5
cmpunordss %xmm4, %xmm4
movaps %xmm4, %xmm6
andps %xmm1, %xmm6
andnps %xmm5, %xmm4
orps %xmm6, %xmm4
movss %xmm4, 0x100(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x793e
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: shrinkExtents
static void shrinkExtents(AABBtree *tree, BoundingSphere *bs){
    AABBtree *t = tree;
    do {
	if (bs->x - bs->r <= t->min.x ||
	    bs->y - bs->r <= t->min.y ||
	    bs->z - bs->r <= t->min.z ||
	    bs->x + bs->r >= t->max.x ||
	    bs->y + bs->r >= t->max.y ||
	    bs->z + bs->r >= t->max.z)
	    t->extentsCorrect = false;
    } while ((t = t->parent));
}

// Assembly:
movss (%rsi), %xmm0
movss 0xc(%rsi), %xmm1
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
addss %xmm1, %xmm0
movss 0xf8(%rdi), %xmm3
ucomiss %xmm2, %xmm3
jae 0x7a5b
movss 0x4(%rsi), %xmm3
movaps %xmm3, %xmm4
subss %xmm1, %xmm4
movss 0xfc(%rdi), %xmm5
ucomiss %xmm4, %xmm5
jae 0x7a5b
movss 0x8(%rsi), %xmm4
movaps %xmm4, %xmm5
subss %xmm1, %xmm5
movss 0x100(%rdi), %xmm6
ucomiss %xmm5, %xmm6
jae 0x7a5b
ucomiss 0x104(%rdi), %xmm0
jae 0x7a5b
addss %xmm1, %xmm3
ucomiss 0x108(%rdi), %xmm3
jae 0x7a5b
addss %xmm1, %xmm4
ucomiss 0x10c(%rdi), %xmm4
jb 0x7a62
movb $0x0, 0x110(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x79f9
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: maybeKillTree
static void maybeKillTree(AABBtree *tree){
    int i;
    if (tree->parent && tree->nodes.size == 0){
	for (i = 0; i < 27; i++)
	    if (tree->children[i]) return;
#ifdef DEBUG
        printf("Killing tree ");
        printTree(tree);
        printf("\n");
#endif
	removeChild(tree->parent, tree);
	deleteTree(tree);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x7a81
cmpq $0x0, 0x120(%rbx)
je 0x7a83
popq %rbx
retq
movl $0x1, %eax
cmpq $0x0, (%rbx,%rax,8)
jne 0x7a81
incq %rax
cmpq $0x1c, %rax
jne 0x7a88
movb $0x1, %al
xorl %ecx, %ecx
incq %rcx
movq (%rdi,%rcx,8), %rdx
testq %rdx, %rdx
je 0x7ab5
cmpq %rbx, %rdx
jne 0x7ac0
movq $0x0, (%rdi,%rcx,8)
incq %rcx
cmpq $0x1c, %rcx
jne 0x7a9f
jmp 0x7aca
xorl %eax, %eax
cmpq $0x1b, %rcx
jne 0x7a9c
jmp 0x7ad7
testb $0x1, %al
je 0x7ad7
movw $0x0, 0xe8(%rdi)
callq 0x7a6b
leaq 0x118(%rbx), %rdi
callq 0x43e0
movq 0xe0(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x4400
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: treeMap
static void treeMap(AABBtree *tree, void (*func)(Node *)){
#ifdef DEBUG
    nTrees++;
#endif 
    int i;
    for (i = 0; i < tree->nodes.size; i++)
	func(tree->nodes.data[i]);
    for (i = 0; i < 27; i++){
	AABBtree *child = tree->children[i];
	if (child)
	    treeMap(child, func);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x120(%rdi)
je 0x816d
xorl %r15d, %r15d
movq 0x118(%r14), %rax
movq (%rax,%r15,8), %rdi
callq *%rbx
incq %r15
cmpq %r15, 0x120(%r14)
ja 0x8154
movl $0x1, %r15d
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x8184
movq %rbx, %rsi
callq 0x813c
incq %r15
cmpq $0x1c, %r15
jne 0x8173
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: setSplitLocation
static void setSplitLocation(AABBtree *tree){
    float x = 0, y = 0, z= 0;
    int i;
    for (i = 0; i < tree->nodes.size; i++){
	BoundingSphere *bs =
	    ((Node *) tree->nodes.data[i])->boundingSphere;
	x += bs->x;
	y += bs->y;
	z += bs->z;
    }
    x /= i; y /= i; z /= i;
    Point p = {x, y, z};
    tree->splitPoint = p;
}

// Assembly:
movq 0x120(%rdi), %rax
testq %rax, %rax
je 0x842d
movq 0x118(%rdi), %rcx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq (%rsi), %rsi
movsd (%rsi), %xmm2
addps %xmm2, %xmm0
addss 0x8(%rsi), %xmm1
incq %rdx
cmpq %rdx, %rax
jne 0x8409
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
jmp 0x8436
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
divss %xmm2, %xmm1
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
divps %xmm2, %xmm0
movlps %xmm0, 0xec(%rdi)
movss %xmm1, 0xf4(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsFurtherFromCamera
int hpsFurtherFromCamera(const HPScamera *camera, const float *a, const float *b){
    float m, n, mx, my, mz, nx, ny, nz;
    HPMpoint c = camera->position;
    mx = a[0] - c.x;
    my = a[1] - c.y;
    mz = a[2] - c.z;
    m =  mx*mx + my*my + mz*mz;
    nx = b[0] - c.x;
    ny = b[1] - c.y;
    nz = b[2] - c.z;
    n =  nx*nx + ny*ny + nz*nz;
    if (m > n) return -1;
    else if (m < n) return 1;
    return 0;
}

// Assembly:
movss (%rdx), %xmm1
movss 0x4(%rdx), %xmm2
movss 0x8(%rdx), %xmm3
movss (%rsi), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movss 0x4(%rsi), %xmm4
unpcklps %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
movss 0x8(%rsi), %xmm1
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movss 0xc(%rdi), %xmm2
movss 0x10(%rdi), %xmm3
movss 0x14(%rdi), %xmm5
shufps $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
subps %xmm2, %xmm0
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
subps %xmm3, %xmm4
shufps $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
subps %xmm5, %xmm1
mulps %xmm4, %xmm4
mulps %xmm0, %xmm0
addps %xmm4, %xmm0
mulps %xmm1, %xmm1
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
xorl %ecx, %ecx
ucomiss %xmm1, %xmm0
seta %cl
ucomiss %xmm0, %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsBSFurtherFromCamera
int hpsBSFurtherFromCamera(const HPScamera *camera, const float *a, const float *b){
    float m, n, mx, my, mz, nx, ny, nz, mr, nr;
    HPMpoint c = camera->position;
    mr = a[3];
    nr = b[3];
    mx = a[0] - c.x - mr;
    my = a[1] - c.y - mr;
    mz = a[2] - c.z - mr;
    m =  mx*mx + my*my + mz*mz;
    nx = b[0] - c.x - nr;
    ny = b[1] - c.y - nr;
    nz = b[2] - c.z - nr;
    n =  nx*nx + ny*ny + nz*nz;
    if (m > n) return -1;
    else if (m < n) return 1;
    return 0;
}

// Assembly:
movss (%rdx), %xmm1
movss 0x4(%rdx), %xmm3
movss 0x8(%rdx), %xmm4
movss 0xc(%rdx), %xmm5
movss (%rsi), %xmm0
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movss 0x4(%rsi), %xmm2
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movss 0x8(%rsi), %xmm1
unpcklps %xmm4, %xmm1            # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
movss 0xc(%rsi), %xmm3
unpcklps %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1]
movss 0xc(%rdi), %xmm4
movss 0x10(%rdi), %xmm5
movss 0x14(%rdi), %xmm6
shufps $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
subps %xmm4, %xmm0
subps %xmm3, %xmm0
shufps $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
subps %xmm5, %xmm2
subps %xmm3, %xmm2
shufps $0x0, %xmm6, %xmm6      # xmm6 = xmm6[0,0,0,0]
subps %xmm6, %xmm1
subps %xmm3, %xmm1
mulps %xmm2, %xmm2
mulps %xmm0, %xmm0
addps %xmm2, %xmm0
mulps %xmm1, %xmm1
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
xorl %ecx, %ecx
ucomiss %xmm1, %xmm0
seta %cl
ucomiss %xmm0, %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/camera.c
// Function: addToQueue
static void addToQueue(Node *node){
    HPSnode *n = (HPSnode *) node->data;
    if (n->pipeline){
        if (n->pipeline->isAlpha){
            hpsPush(&alphaQueue, n);
        } else {
            hpsPush(&renderQueue, n);
        }
    }
    if (n->extension){
        hpsVisibleExtensionNode(n);
    }
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rbx
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x8c46
leaq 0x6920(%rip), %rcx      # 0xf550
leaq 0x68f9(%rip), %rdi      # 0xf530
cmpb $0x0, (%rax)
cmovneq %rcx, %rdi
movq %rbx, %rsi
callq 0x4270
cmpq $0x0, 0x78(%rbx)
je 0x8c56
movq %rbx, %rdi
popq %rbx
jmp 0x41e0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsMakeCamera
HPScamera *hpsMakeCamera(HPScameraType type, HPScameraStyle style, HPSscene *scene, float width, float height){
    HPScamera *camera = malloc(sizeof(struct camera));
    camera->n = HPS_DEFAULT_NEAR_PLANE;
    camera->f = HPS_DEFAULT_FAR_PLANE;
    camera->viewAngle = HPS_DEFAULT_VIEW_ANGLE;
    camera->position.x = 0.0;
    camera->position.y = 0.0;
    camera->position.z = 0.0;
    camera->up.x = 0.0;
    camera->up.y = 1.0;
    camera->up.z = 0.0;
    camera->object.x = 0.0;
    camera->object.y = 0.0;
    camera->object.z = 0.0;
    camera->rotation.x = 0;
    camera->rotation.y = 0;
    camera->rotation.z = 0;
    camera->rotation.w = 1;
    camera->vw = width; camera->vh = height;
    camera->vwRatio = 1.0; camera->vhRatio = 1.0;
    camera->vl = -1.0; camera->vr = 1.0;
    camera->vb = -1.0; camera->vt = 1.0;
    camera->vx = 0.0; camera->vy = 0.0;
    camera->viewportIsStatic = false;
    if (type == HPS_ORTHO)
        camera->update = &hpsOrthoCamera;
    else
        camera->update = &hpsPerspectiveCamera;
    camera->style = style;
    camera->scene = scene;
    hpsPush(&cameraList, (void *) camera);
    hpsPush(&activeCameras, (void *) camera);
    camera->update(camera);
    return camera;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
movl $0x1e8, %edi            # imm = 0x1E8
callq 0x4260
movq %rax, %rbx
movsd 0x24d9(%rip), %xmm0     # 0xb160
movsd %xmm0, 0x30(%rax)
movl $0x428c0000, 0x38(%rax) # imm = 0x428C0000
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rax)
movl $0x3f800000, 0x1c(%rax) # imm = 0x3F800000
movups %xmm0, 0x20(%rax)
movaps 0x23c4(%rip), %xmm0     # 0xb070
movups %xmm0, 0x68(%rax)
movss (%rsp), %xmm0
movss %xmm0, 0x3c(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x40(%rax)
movaps 0x24a4(%rip), %xmm0     # 0xb170
movups %xmm0, 0x44(%rax)
movsd 0x24a8(%rip), %xmm0     # 0xb180
movsd %xmm0, 0x54(%rax)
testl %r15d, %r15d
movq $0x0, 0x5c(%rax)
leaq 0x51(%rip), %rax        # 0x8d40
leaq 0xe9(%rip), %rcx        # 0x8ddf
cmoveq %rax, %rcx
movb $0x0, 0x64(%rbx)
movq %rcx, 0x1d8(%rbx)
movl %ebp, 0x8(%rbx)
movq %r14, (%rbx)
leaq 0x67de(%rip), %rdi      # 0xf4f0
movq %rbx, %rsi
callq 0x4270
leaq 0x67ef(%rip), %rdi      # 0xf510
movq %rbx, %rsi
callq 0x4270
movq %rbx, %rdi
callq *0x1d8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq