LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmNormalize
void hpmNormalize(float *point){
    HPMpoint *p = (HPMpoint *) point;
    float len = hpmMagnitude(point);
    p->x = p->x / len;
    p->y = p->y / len;
    p->z = p->z / len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4230
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
divss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
divss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
divss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmMat4VecMult
void hpmMat4VecMult(const float *mat, float *point){
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMpoint *p = (HPMpoint *) point;
    float x, y, z, w;
    x = p->x; y = p->y; z = p->z;
    w = m->_41*x + m->_42*y + m->_43*z + m->_44;

    p->x = m->_11*x + m->_12*y + m->_13*z + m->_14;
    p->y = m->_21*x + m->_22*y + m->_23*z + m->_24;
    p->z = m->_31*x + m->_32*y + m->_33*z + m->_34;

    if (w != 1.0){
        w = 1.0/w;
        p->x *= w;
        p->y *= w;
        p->z *= w;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm1
movss -0x24(%rbp), %xmm2
movq -0x18(%rbp), %rax
movss 0x1c(%rax), %xmm0
mulss -0x28(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0x2c(%rax), %xmm0
movss -0x2c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
addss 0x3c(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movss -0x24(%rbp), %xmm2
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
mulss -0x28(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0x20(%rax), %xmm0
movss -0x2c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
addss 0x30(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movss -0x24(%rbp), %xmm2
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm0
mulss -0x28(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0x24(%rax), %xmm0
movss -0x2c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
addss 0x34(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm1
movss -0x24(%rbp), %xmm2
movq -0x18(%rbp), %rax
movss 0x18(%rax), %xmm0
mulss -0x28(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0x28(%rax), %xmm0
movss -0x2c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
addss 0x38(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xa3d0(%rip), %xmm1     # 0xf010
ucomisd %xmm1, %xmm0
jne 0x4c4a
jp 0x4c4a
jmp 0x4c9f
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xa3b5(%rip), %xmm0     # 0xf010
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
mulss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmMat4VecArrayMult
void hpmMat4VecArrayMult(const float *mat, float *vec, size_t length, size_t stride){
    int i;
    stride = (stride) ? stride : 3 * sizeof(float);
    for (i = 0; i < length; i++){
        hpmMat4VecMult(mat, vec);
        vec = ((float *) ((char *) vec + stride));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4cd9
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x4ce4
movl $0xc, %eax
movq %rax, -0x30(%rbp)
jmp 0x4ce4
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x4d21
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4220
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4cf3
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmLerp
void hpmLerp(const float *pointA, const float *pointB, float t, float *result){
    HPMpoint *a = (HPMpoint *) pointA;
    HPMpoint *b = (HPMpoint *) pointB;
    HPMpoint *r = (HPMpoint *) result;
    float t0 = 1 - t;
    r->x = a->x*t0 + b->x*t;
    r->y = a->y*t0 + b->y*t;
    r->z = a->z*t0 + b->z*t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movss 0xa2cb(%rip), %xmm0     # 0xf030
subss -0x14(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movss -0x3c(%rbp), %xmm2
movq -0x30(%rbp), %rax
movss (%rax), %xmm1
mulss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movss -0x3c(%rbp), %xmm2
movq -0x30(%rbp), %rax
movss 0x4(%rax), %xmm1
mulss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x3c(%rbp), %xmm2
movq -0x30(%rbp), %rax
movss 0x8(%rax), %xmm1
mulss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmQuatNormalize
void hpmQuatNormalize(float *quat){
    HPMquat *q = (HPMquat *) quat;
    float mag = sqrt(q->x*q->x + q->y*q->y + q->z*q->z + q->w*q->w);
    q->x = q->x / mag;
    q->y = q->y / mag;
    q->z = q->z / mag;
    q->w = q->w / mag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss (%rax), %xmm2
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x10(%rbp), %rax
mulss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x44c0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
divss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
divss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
divss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
divss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmQuatInverse
void hpmQuatInverse(const float *quat, float *inv){
    HPMquat *q = (HPMquat *) quat;
    HPMquat *i = (HPMquat *) inv;
    i->x = -q->x;
    i->y = -q->y;
    i->z = -q->z;
    i->w = q->w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0xc(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmQuatVecRotate
void hpmQuatVecRotate(const float *quat, float *point){
    float r[4], i[4];
    HPMpoint *pt = (HPMpoint *) point;
    HPMquat p;
    p.x = pt->x;
    p.y = pt->y;
    p.z = pt->z;
    p.w = 0;
    hpmQuatInverse(quat, i);
    hpmQuatCross(i, (float *) &p, r);
    hpmQuatCross(r, quat, i);
    pt->x = i[0];
    pt->y = i[1];
    pt->z = i[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movq -0x38(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x38(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x43d0
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0x4160
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4160
movss -0x30(%rbp), %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, (%rax)
movss -0x2c(%rbp), %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x28(%rbp), %xmm0
movq -0x38(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmAxisAngleQuatRotation
void hpmAxisAngleQuatRotation(float *axis, float angle, float *quat){
    HPMquat *q = (HPMquat *) quat;
    HPMpoint *a = (HPMpoint *) axis;
    float s = sin(angle/2.0);
    q->x = s*a->x;
    q->y = s*a->y;
    q->z = s*a->z;
    q->w = cos(angle/2.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x9d62(%rip), %xmm1     # 0xf018
divsd %xmm1, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
mulss (%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
mulss 0x4(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
mulss 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x9cfc(%rip), %xmm1     # 0xf018
divsd %xmm1, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuatAxisAngle
void hpmRotateQuatAxisAngle(float *axis, float angle, float *quat){
    float rot[4], r[4];
    hpmAxisAngleQuatRotation(axis, angle, rot);
    hpmQuatCross(rot, quat, r);
    hpmCopyQuat(r, quat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movss -0xc(%rbp), %xmm0
leaq -0x30(%rbp), %rsi
callq 0x4180
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4160
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuatX
void hpmRotateQuatX(float angle, float *quat){
    if (angle == 0.0) return;
    float rot[4], r[4];
    hpmXQuatRotation(angle, rot);
    hpmQuatCross(rot, quat, r);
    hpmCopyQuat(r, quat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5407
jp 0x5407
jmp 0x5433
movss -0x4(%rbp), %xmm0
leaq -0x20(%rbp), %rdi
callq 0x44f0
leaq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4160
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuatY
void hpmRotateQuatY(float angle, float *quat){
    if (angle == 0.0) return;
    float rot[4], r[4];
    hpmYQuatRotation(angle, rot);
    hpmQuatCross(rot, quat, r);
    hpmCopyQuat(r, quat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x54b7
jp 0x54b7
jmp 0x54e3
movss -0x4(%rbp), %xmm0
leaq -0x20(%rbp), %rdi
callq 0x42d0
leaq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4160
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuatZ
void hpmRotateQuatZ(float angle, float *quat){
    if (angle == 0.0) return;
    float rot[4], r[4];
    hpmZQuatRotation(angle, rot);
    hpmQuatCross(rot, quat, r);
    hpmCopyQuat(r, quat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5567
jp 0x5567
jmp 0x5593
movss -0x4(%rbp), %xmm0
leaq -0x20(%rbp), %rdi
callq 0x4350
leaq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4160
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuatYPR
void hpmRotateQuatYPR(float yaw, float pitch, float roll, float *quat){
    float rot[4], r[4];
    hpmYPRQuatRotation(yaw, pitch, roll, rot);
    hpmQuatCross(rot, quat, r);
    hpmCopyQuat(r, quat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
leaq -0x30(%rbp), %rdi
callq 0x4370
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4160
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmPrintMat4
void hpmPrintMat4(const float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    printf("[%f, %f, %f, %f,\n",   m->_11, m->_12, m->_13, m->_14);
    printf(" %f, %f, %f, %f,\n",   m->_21, m->_22, m->_23, m->_24);
    printf(" %f, %f, %f, %f,\n",   m->_31, m->_32, m->_33, m->_34);
    printf(" %f, %f, %f, %f]\n\n", m->_41, m->_42, m->_43, m->_44);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss 0x10(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x10(%rbp), %rax
movss 0x20(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
movq -0x10(%rbp), %rax
movss 0x30(%rax), %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0x9682(%rip), %rdi      # 0xf040
movb $0x4, %al
callq 0x41b0
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss 0x14(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x10(%rbp), %rax
movss 0x24(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
movq -0x10(%rbp), %rax
movss 0x34(%rax), %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0x9652(%rip), %rdi      # 0xf052
movb $0x4, %al
callq 0x41b0
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss 0x18(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x10(%rbp), %rax
movss 0x28(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
movq -0x10(%rbp), %rax
movss 0x38(%rax), %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0x9610(%rip), %rdi      # 0xf052
movb $0x4, %al
callq 0x41b0
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss 0x1c(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x10(%rbp), %rax
movss 0x2c(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
movq -0x10(%rbp), %rax
movss 0x3c(%rax), %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0x95e0(%rip), %rdi      # 0xf064
movb $0x4, %al
callq 0x41b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmIdentityMat4
void hpmIdentityMat4(float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    memset(m, 0, sizeof(HPMmat4));
    m->_11 = 1.0;
    m->_22 = 1.0;
    m->_33 = 1.0;
    m->_44 = 1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x4200
movq -0x10(%rbp), %rax
movss 0x9560(%rip), %xmm0     # 0xf030
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x9550(%rip), %xmm0     # 0xf030
movss %xmm0, 0x14(%rax)
movq -0x10(%rbp), %rax
movss 0x953f(%rip), %xmm0     # 0xf030
movss %xmm0, 0x28(%rax)
movq -0x10(%rbp), %rax
movss 0x952e(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmTranslation
void hpmTranslation(float *vector, float *mat){
    hpmIdentityMat4(mat);
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMpoint *p = (HPMpoint *) vector;
    m->_14 += p->x;
    m->_24 += p->y;
    m->_34 += p->z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42f0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
addss 0x30(%rax), %xmm0
movss %xmm0, 0x30(%rax)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
addss 0x34(%rax), %xmm0
movss %xmm0, 0x34(%rax)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
addss 0x38(%rax), %xmm0
movss %xmm0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmTranslate
void hpmTranslate(float *vector, float *mat){
    float trans[16], r[16];
    hpmTranslation(vector, trans);
    hpmMultMat4(trans, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4240
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x4140
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4030
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmXRotation
void hpmXRotation(float rotation, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    float c = cos(rotation);
    float s = sin(rotation);
    m->_11 = 1.0;
    m->_22 = c;
    m->_33 = c;
    m->_23 = -s;
    m->_32 = s;
    m->_44 = 1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x8d34(%rip), %xmm0     # 0xf030
movss %xmm0, (%rax)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x28(%rax)
movss -0x20(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x24(%rax)
movss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movss 0x8cdf(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateX
void hpmRotateX(float rotation, float *mat){
    if (rotation == 0.0) return;
    float rot[16], r[16];
    hpmXRotation(rotation, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x63ba
jp 0x63ba
jmp 0x63ec
movss -0x4(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x41a0
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x4140
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4030
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmYRotation
void hpmYRotation(float rotation, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    float c = cos(rotation);
    float s = sin(rotation);
    m->_11 = c;
    m->_22 = 1.0;
    m->_33 = c;
    m->_13 = s;
    m->_31 = -s;
    m->_44 = 1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss 0x8bc7(%rip), %xmm0     # 0xf030
movss %xmm0, 0x14(%rax)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x28(%rax)
movss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x20(%rax)
movss -0x20(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movss 0x8b7f(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateY
void hpmRotateY(float rotation, float *mat){
    if (rotation == 0.0) return;
    float rot[16], r[16];
    hpmYRotation(rotation, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x64ea
jp 0x64ea
jmp 0x651c
movss -0x4(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x4560
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x4140
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4030
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmZRotation
void hpmZRotation(float rotation, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    float c = cos(rotation);
    float s = sin(rotation);
    m->_11 = c;
    m->_22 = c;
    m->_12 = -s;
    m->_21 = s;
    m->_33 = 1.0;
    m->_44 = 1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x20(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x8a60(%rip), %xmm0     # 0xf030
movss %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
movss 0x8a4f(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateZ
void hpmRotateZ(float rotation, float *mat){
    if (rotation == 0.0) return;
    float rot[16], r[16];
    hpmZRotation(rotation, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x661a
jp 0x661a
jmp 0x664c
movss -0x4(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x4590
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x4140
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4030
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x692e
jp 0x692e
jmp 0x6964
movq -0x8(%rbp), %rdi
movss -0xc(%rbp), %xmm0
leaq -0x60(%rbp), %rsi
callq 0x4540
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x4140
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4030
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateQuaternion
void hpmRotateQuaternion(float *quat, float *mat){
    float rot[16], r[16];
    hpmQuaternionRotation(quat, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4060
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x4140
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4030
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmYPRRotation
void hpmYPRRotation(float yaw, float pitch, float roll, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    initMat4(m);
    float sy, cy, sp, cp, sr, cr;
    sy = sin(yaw); cy = cos(yaw);
    sp = sin(pitch); cp = cos(pitch);
    sr = sin(roll); cr = cos(roll);

    m->_11 = sp*sy*sr + cy*cr;
    m->_12 = sp*sy*cr - cy*sr;
    m->_13 = cp*sy;

    m->_21 = cp*sr;
    m->_22 = cp*cr;
    m->_23 = -sp;

    m->_31 = sp*cy*sr - sy*cr;
    m->_32 = sp*cy*cr + sy*sr;
    m->_33 = cp*cy;

    m->_44 = 1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6360
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x2c(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movss -0x34(%rbp), %xmm2
movss -0x28(%rbp), %xmm1
mulss -0x38(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x2c(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movss -0x38(%rbp), %xmm2
movss -0x28(%rbp), %xmm1
mulss -0x34(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x30(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x20(%rax)
movss -0x30(%rbp), %xmm0
mulss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x30(%rbp), %xmm0
mulss -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x2c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x24(%rax)
movss -0x2c(%rbp), %xmm0
mulss -0x28(%rbp), %xmm0
movss -0x34(%rbp), %xmm2
movss -0x24(%rbp), %xmm1
mulss -0x38(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x2c(%rbp), %xmm0
mulss -0x28(%rbp), %xmm0
movss -0x38(%rbp), %xmm2
movss -0x24(%rbp), %xmm1
mulss -0x34(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x18(%rax)
movss -0x30(%rbp), %xmm0
mulss -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x20(%rbp), %rax
movss 0x8206(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmRotateYPR
void hpmRotateYPR(float yaw, float pitch, float roll, float *mat){
    float rot[16], r[16];
    hpmYPRRotation(yaw, pitch, roll, rot);
    hpmMultMat4(rot, mat, r);
    hpmCopyMat4(r, mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
leaq -0x60(%rbp), %rdi
callq 0x4170
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x4140
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4030
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x18(%rbp), %rax
movss 0x8132(%rip), %xmm0     # 0xf030
movss %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
movss 0x8121(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
leaq -0x50(%rbp), %rdi
callq 0x4470
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x4140
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4030
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6360
movss -0x4(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x8(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0xc(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x20(%rbp), %rax
movss 0x804f(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
leaq -0x60(%rbp), %rdi
callq 0x4190
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x4140
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4030
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6360
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
movss 0x7f79(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movss %xmm0, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x4530
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x4140
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4030
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6360
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x2c(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x30(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x20(%rbp), %rax
movss 0x7d7b(%rip), %xmm0     # 0xf030
movss %xmm0, 0x28(%rax)
movq -0x20(%rbp), %rax
movss 0x7d6a(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x30(%rax)
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x34(%rax)
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x38(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmTranspose
void hpmTranspose(const float *mat, float *result){
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMmat4 *r = (HPMmat4 *) result;
    r->_11 = m->_11;
    r->_12 = m->_21;
    r->_13 = m->_31;
    r->_14 = m->_41;

    r->_21 = m->_12;
    r->_22 = m->_22;
    r->_23 = m->_32;
    r->_24 = m->_42;

    r->_31 = m->_13;
    r->_32 = m->_23;
    r->_33 = m->_33;
    r->_34 = m->_43;

    r->_41 = m->_14;
    r->_42 = m->_24;
    r->_43 = m->_34;
    r->_44 = m->_44;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x20(%rax)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x30(%rax)
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x18(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x24(%rax)
movq -0x18(%rbp), %rax
movss 0x1c(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x34(%rax)
movq -0x18(%rbp), %rax
movss 0x20(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movss 0x24(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movss 0x28(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
movss 0x2c(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x38(%rax)
movq -0x18(%rbp), %rax
movss 0x30(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x18(%rbp), %rax
movss 0x34(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movq -0x18(%rbp), %rax
movss 0x38(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x2c(%rax)
movq -0x18(%rbp), %rax
movss 0x3c(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x3c(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss 0x18(%rbp), %xmm8
movss 0x10(%rbp), %xmm8
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss %xmm4, -0x14(%rbp)
movss %xmm5, -0x18(%rbp)
movss %xmm6, -0x1c(%rbp)
movss %xmm7, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6360
movss -0x20(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
subss -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movss -0x8(%rbp), %xmm0
movss -0x1c(%rbp), %xmm2
movss -0x20(%rbp), %xmm1
mulss -0x4(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
subss -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x30(%rax)
movss 0x18(%rbp), %xmm0
subss 0x10(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x10(%rbp), %xmm0
movss 0x10(%rbp), %xmm2
movss 0x18(%rbp), %xmm1
mulss -0xc(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x10(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x34(%rax)
movss -0x18(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
movss 0x6860(%rip), %xmm0     # 0xf034
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x28(%rax)
movss -0x18(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss -0x18(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x38(%rax)
movq -0x30(%rbp), %rax
movss 0x6815(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm0
movss 0x67e3(%rip), %xmm1     # 0xf03c
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x20(%rbp)
cvtsi2ssl -0x8(%rbp), %xmm0
movss 0x67b6(%rip), %xmm1     # 0xf03c
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
movss -0xc(%rbp), %xmm4
movss -0x10(%rbp), %xmm5
movq -0x18(%rbp), %rdi
movss 0x6767(%rip), %xmm8     # 0xf038
movss 0x6756(%rip), %xmm9     # 0xf030
movaps %xmm8, %xmm6
movaps %xmm9, %xmm7
movss %xmm9, (%rsp)
movss %xmm8, 0x8(%rsp)
callq 0x4100
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss 0x18(%rbp), %xmm8
movss 0x10(%rbp), %xmm8
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss %xmm4, -0x14(%rbp)
movss %xmm5, -0x18(%rbp)
movss %xmm6, -0x1c(%rbp)
movss %xmm7, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6360
movss -0x14(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
subss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
subss -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
movss -0x20(%rbp), %xmm0
movss -0x4(%rbp), %xmm2
movss -0x8(%rbp), %xmm1
mulss -0x1c(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
subss -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x20(%rax)
movss -0x14(%rbp), %xmm0
movss 0x18(%rbp), %xmm1
subss 0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
movss -0x10(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss 0x18(%rbp), %xmm0
movss -0xc(%rbp), %xmm2
movss -0x10(%rbp), %xmm1
mulss 0x10(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x10(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x24(%rax)
movss -0x18(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss -0x18(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x28(%rax)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x65b5(%rip), %xmm0     # 0xf018
mulsd %xmm1, %xmm0
movss -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movss -0x18(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x38(%rax)
movq -0x30(%rbp), %rax
movss 0x6582(%rip), %xmm0     # 0xf038
movss %xmm0, 0x2c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)