LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/CSerxzm[P]WindowstoLinuxInterface/src/XCOPY.c
// Function: mycp
int mycp(char *dir1, char *dir2)
{
    int fd1;
    int fd2;
    int ret;
    int sts;
    char buf[1024];
    fd1=open(dir1, O_RDONLY);
    fd2=open(dir2, O_WRONLY|O_CREAT|O_TRUNC, 0666);
    while(1)
    {
        bzero(buf, sizeof(buf));
        ret= read(fd1, buf, sizeof(buf)-1 );
        if(ret<=0)
            break;
        sts=write(fd2, buf, ret);
        while(sts<ret)
        {
            sts+=write(fd2, buf+sts, ret-sts);
         }
    }
    close(fd1);
    close(fd2);
    struct stat info;
    ret=stat(dir1, &info);
    if(ret!=0)
    {
        perror("stat");
        return 1;
    }
    chmod(dir2, info.st_mode);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
xorl %eax, %eax
callq 0x1110
movl %eax, %r15d
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x1110
movl %eax, %r12d
leaq -0x4d0(%rbp), %r13
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movl $0x3ff, %edx            # imm = 0x3FF
movl %r15d, %edi
movq %r13, %rsi
callq 0x10c0
movq %rax, %rbx
testl %ebx, %ebx
jle 0x143c
movl %ebx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl %r12d, %edi
movq %r13, %rsi
callq 0x1050
cmpl %ebx, %eax
jge 0x13dc
movslq %eax, %r14
leaq (%r14,%rbp), %rsi
addq $-0x4d0, %rsi           # imm = 0xFB30
movl %ebx, %eax
subl %r14d, %eax
movslq %eax, %rdx
movl %r12d, %edi
callq 0x1050
addq %r14, %rax
jmp 0x1415
movl %r15d, %edi
callq 0x10a0
movl %r12d, %edi
callq 0x10a0
leaq -0xc8(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x10e0
testl %eax, %eax
jne 0x1483
movl -0xb0(%rbp), %esi
movq -0x30(%rbp), %rdi
callq 0x1100
xorl %eax, %eax
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb7a(%rip), %rdi       # 0x2004
callq 0x1120
pushq $0x1
popq %rax
jmp 0x1471
// File: /workspace/github_c_makefile_star2_O2/CSerxzm[P]WindowstoLinuxInterface/src/XCOPY.c
// Function: mycpdir
int mycpdir(char *name1, char *name2)
{
    int ret;
    DIR *dir1;
    DIR *dir2;
    struct dirent *drr;
    struct stat info;
    struct stat dirinfo;
    char buf1[1024];
    char buf2[1024];
    lstat(name1, &info);
    dir1=opendir(name1);
    if(dir1==NULL)
    {
        perror("opendir1");
        return 1;
    }
    dir2=opendir(name2); 
    if(dir2==NULL)
    {
        mkdir(name2, info.st_mode);
        dir2=opendir(name2);
    }

    while(1)
    {
        bzero(buf2, sizeof(buf2));
        bzero(buf2, sizeof(buf2));
        drr=readdir(dir1);
        if(drr==NULL)break;
        if(*drr->d_name=='.')
            continue;
        sprintf(buf1, "%s/%s", name1, drr->d_name);
        sprintf(buf2, "%s/%s", name2, drr->d_name);
        ret=lstat(buf1, &dirinfo);
        if(ret<0)
        {
            perror("lstat\n");
            break;
        }
        if(S_ISDIR(dirinfo.st_mode))
        {
            mycpdir(buf1 , buf2);
        }
        else if(S_ISREG(dirinfo.st_mode))
        {
            mycp(buf1, buf2);
        }
        else if(S_ISLNK(dirinfo.st_mode))
        {
            mycplink(buf1, buf2);
        }
    }
	closedir(dir1);
    closedir(dir2);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x938, %rsp            # imm = 0x938
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x160(%rbp), %rsi
callq 0x10d0
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x1060
testq %rax, %rax
je 0x15cf
movq %rax, %r15
movq %rbx, %rdi
callq 0x1060
testq %rax, %rax
jne 0x14f5
movl -0x148(%rbp), %esi
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1060
movq %rax, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
leaq -0x560(%rbp), %r13
leaq 0xb07(%rip), %r12       # 0x2012
leaq -0x960(%rbp), %rbx
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movq %r15, %rdi
callq 0x10f0
testq %rax, %rax
je 0x15ec
movq %rax, %r14
cmpb $0x2e, 0x13(%rax)
je 0x1512
addq $0x13, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq -0x40(%rbp), %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1130
movq %r13, %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1130
movq %rbx, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x10d0
testl %eax, %eax
js 0x15e0
movl -0xb8(%rbp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
cmpw $0xa000, %ax            # imm = 0xA000
je 0x15bf
cmpl $0x8000, %eax           # imm = 0x8000
je 0x15af
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x1512
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1494
jmp 0x1512
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1393
jmp 0x1512
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1334
jmp 0x1512
leaq 0xa33(%rip), %rdi       # 0x2009
callq 0x1120
pushq $0x1
popq %rax
jmp 0x15ff
leaq 0xa31(%rip), %rdi       # 0x2018
callq 0x1120
movq %r15, %rdi
callq 0x10b0
movq -0x30(%rbp), %rdi
callq 0x10b0
xorl %eax, %eax
addq $0x938, %rsp            # imm = 0x938
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movss (%rsi), %xmm2
movss 0x4(%rsi), %xmm3
movss 0x8(%rsi), %xmm0
movss 0x1c(%rdi), %xmm1
mulss %xmm3, %xmm1
movss 0xc(%rdi), %xmm4
mulss %xmm2, %xmm4
addss %xmm1, %xmm4
movss 0x2c(%rdi), %xmm1
mulss %xmm0, %xmm1
addss %xmm4, %xmm1
addss 0x3c(%rdi), %xmm1
movaps %xmm3, %xmm4
shufps $0x0, %xmm3, %xmm4      # xmm4 = xmm4[0,0],xmm3[0,0]
movsd (%rdi), %xmm5
movsd 0x10(%rdi), %xmm6
mulps %xmm4, %xmm6
movsd 0x20(%rdi), %xmm7
movsd 0x30(%rdi), %xmm8
movaps %xmm2, %xmm9
shufps $0x0, %xmm2, %xmm9      # xmm9 = xmm9[0,0],xmm2[0,0]
mulps %xmm5, %xmm9
addps %xmm6, %xmm9
movaps %xmm0, %xmm4
shufps $0x0, %xmm0, %xmm4      # xmm4 = xmm4[0,0],xmm0[0,0]
mulps %xmm7, %xmm4
addps %xmm9, %xmm4
addps %xmm8, %xmm4
movlps %xmm4, (%rsi)
mulss 0x18(%rdi), %xmm3
mulss 0x8(%rdi), %xmm2
mulss 0x28(%rdi), %xmm0
addss %xmm3, %xmm2
addss %xmm2, %xmm0
addss 0x38(%rdi), %xmm0
movss %xmm0, 0x8(%rsi)
ucomiss 0x585f(%rip), %xmm1     # 0xa030
jne 0x47d5
jnp 0x47f6
movss 0x5853(%rip), %xmm2     # 0xa030
divss %xmm1, %xmm2
movaps %xmm2, %xmm1
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
mulps %xmm4, %xmm1
movlps %xmm1, (%rsi)
mulss %xmm0, %xmm2
movss %xmm2, 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
pushq $0xc
popq %r12
cmovneq %rcx, %r12
subq $0x1, %rbx
jb 0x4829
movq %r15, %rdi
movq %r14, %rsi
callq 0x4200
addq %r12, %r14
jmp 0x4813
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movss 0x57f3(%rip), %xmm1     # 0xa030
subss %xmm0, %xmm1
movsd (%rdi), %xmm2
movsd (%rsi), %xmm3
movaps %xmm0, %xmm4
unpcklps %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1]
mulps %xmm3, %xmm4
movaps %xmm1, %xmm3
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
mulps %xmm2, %xmm3
addps %xmm4, %xmm3
movlps %xmm3, (%rdx)
mulss 0x8(%rsi), %xmm0
mulss 0x8(%rdi), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movsd (%rsi), %xmm0
leaq 0x28(%rsp), %rsi
movsd %xmm0, (%rsi)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x8(%rsi)
andl $0x0, 0xc(%rsi)
movq %rdi, %r14
movsd (%rdi), %xmm0
movaps 0x5651(%rip), %xmm1     # 0xa040
xorps %xmm1, %xmm0
movq %rsp, %r15
movlps %xmm0, (%r15)
movss 0x8(%rdi), %xmm0
xorps %xmm1, %xmm0
movss %xmm0, 0x8(%r15)
movss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%r15)
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x4150
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4150
movsd (%r15), %xmm0
movsd %xmm0, (%rbx)
movss 0x8(%r15), %xmm0
movss %xmm0, 0x8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
mulsd 0x55aa(%rip), %xmm0     # 0xa010
movsd %xmm0, (%rsp)
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movsd (%r14), %xmm1
movaps %xmm0, %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
mulps %xmm1, %xmm2
movlps %xmm2, (%rbx)
mulss 0x8(%r14), %xmm0
movss %xmm0, 0x8(%rbx)
movsd (%rsp), %xmm0
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x4170
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4150
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4b16
jp 0x4b16
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4460
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4150
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4b82
jp 0x4b82
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4290
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4150
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4be9
jp 0x4be9
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4320
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4150
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4330
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4150
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmSlerp
void hpmSlerp(const float *quatA, const float *quatB, float t, float *result){
    HPMquat *a = (HPMquat *) quatA;
    HPMquat *b = (HPMquat *) quatB;
    HPMquat *r = (HPMquat *) result;
    float cosOmega = a->x*b->x + a->y*b->y + a->z*b->z + a->w*b->w;
    if (cosOmega < 0){
        b->x = -b->x;
        b->y = -b->y;
        b->z = -b->z;
        b->w = -b->w;
        cosOmega = -cosOmega;
    }
    float ka, kb;
    if (cosOmega > 0.9999){ // Linear interpolation when close
        ka = 1-t;
        kb = t;
    } else {
        float sinOmega = sqrt(1 - cosOmega*cosOmega);
        float omega = atan2(sinOmega, cosOmega);
        float oneOverSinOmega = 1/sinOmega;
        ka = sin((1-t) * omega) *oneOverSinOmega;
        kb = sin(t * omega) *oneOverSinOmega;
    }
    r->x = a->x*ka + b->x*kb;
    r->y = a->y*ka + b->y*kb;
    r->z = a->z*ka + b->z*kb;
    r->w = a->w*ka + b->w*kb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movups (%rsi), %xmm4
movaps %xmm4, %xmm1
shufps $0x55, %xmm4, %xmm1     # xmm1 = xmm1[1,1],xmm4[1,1]
mulss 0x4(%rdi), %xmm1
movss (%rdi), %xmm2
mulss %xmm4, %xmm2
addss %xmm1, %xmm2
movaps %xmm4, %xmm3
unpckhpd %xmm4, %xmm3            # xmm3 = xmm3[1],xmm4[1]
mulss 0x8(%rdi), %xmm3
addss %xmm2, %xmm3
movaps %xmm4, %xmm5
shufps $0xff, %xmm4, %xmm5     # xmm5 = xmm5[3,3],xmm4[3,3]
mulss 0xc(%rdi), %xmm5
addss %xmm3, %xmm5
xorps %xmm2, %xmm2
ucomiss %xmm5, %xmm2
jbe 0x4d02
movaps 0x5348(%rip), %xmm2     # 0xa040
xorps %xmm2, %xmm4
movups %xmm4, (%r15)
xorps %xmm2, %xmm5
cvtss2sd %xmm5, %xmm1
ucomisd 0x530a(%rip), %xmm1     # 0xa018
jbe 0x4d24
movss 0x5318(%rip), %xmm1     # 0xa030
subss %xmm0, %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
jmp 0x4dd6
movaps %xmm0, 0x20(%rsp)
mulss %xmm5, %xmm5
movss 0x52fb(%rip), %xmm0     # 0xa030
subss %xmm5, %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jb 0x4d47
sqrtss %xmm0, %xmm0
jmp 0x4d56
movsd %xmm1, (%rsp)
callq 0x4310
movsd (%rsp), %xmm1
movss %xmm0, (%rsp)
cvtss2sd %xmm0, %xmm0
callq 0x4100
cvtsd2ss %xmm0, %xmm1
movss %xmm1, 0x1c(%rsp)
movss 0x52ba(%rip), %xmm0     # 0xa030
movaps %xmm0, %xmm2
divss (%rsp), %xmm2
movss %xmm2, (%rsp)
subss 0x20(%rsp), %xmm0
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4260
movaps %xmm0, 0x30(%rsp)
cvtss2sd (%rsp), %xmm0
movaps %xmm0, (%rsp)
movss 0x1c(%rsp), %xmm0
mulss 0x20(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4260
movaps 0x30(%rsp), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd (%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
cvtpd2ps %xmm0, %xmm1
movups (%r15), %xmm4
movapd %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
mulps %xmm4, %xmm2
movups (%r14), %xmm0
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
mulps %xmm0, %xmm1
addps %xmm2, %xmm1
movups %xmm1, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtss2sd (%rdi), %xmm0
cvtss2sd 0x10(%rdi), %xmm1
cvtss2sd 0x20(%rdi), %xmm2
cvtss2sd 0x30(%rdi), %xmm3
leaq 0x5234(%rip), %rdi      # 0xa070
movb $0x4, %al
callq 0x4180
cvtss2sd 0x4(%rbx), %xmm0
cvtss2sd 0x14(%rbx), %xmm1
cvtss2sd 0x24(%rbx), %xmm2
cvtss2sd 0x34(%rbx), %xmm3
leaq 0x5224(%rip), %r14      # 0xa082
movq %r14, %rdi
movb $0x4, %al
callq 0x4180
cvtss2sd 0x8(%rbx), %xmm0
cvtss2sd 0x18(%rbx), %xmm1
cvtss2sd 0x28(%rbx), %xmm2
cvtss2sd 0x38(%rbx), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x4180
cvtss2sd 0xc(%rbx), %xmm0
cvtss2sd 0x1c(%rbx), %xmm1
cvtss2sd 0x2c(%rbx), %xmm2
cvtss2sd 0x3c(%rbx), %xmm3
leaq 0x51f3(%rip), %rdi      # 0xa094
movb $0x4, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4180
// File: /workspace/github_c_makefile_star2_O2/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:
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rdi)
movups %xmm0, 0x24(%rdi)
movups %xmm0, 0x4(%rdi)
andq $0x0, 0x34(%rdi)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%rdi)
movl %eax, 0x14(%rdi)
movl %eax, 0x28(%rdi)
movl %eax, 0x3c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
movups %xmm0, 0x14(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x4(%rax)
movl $0x3f800000, %ecx       # imm = 0x3F800000
movl %ecx, (%rax)
movl %ecx, 0x14(%rax)
movl %ecx, 0x28(%rax)
movl %ecx, 0x3c(%rax)
movsd (%rdi), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, 0x30(%rax)
xorps %xmm0, %xmm0
addss 0x8(%rdi), %xmm0
movss %xmm0, 0x38(%rax)
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x4130
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_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x24(%rdi)
movups %xmm1, 0x14(%rdi)
movups %xmm1, 0x4(%rdi)
andq $0x0, 0x34(%rdi)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%rbx)
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x14(%rbx)
movss %xmm1, 0x28(%rbx)
movaps 0x4c23(%rip), %xmm1     # 0xa040
xorps %xmm0, %xmm1
movss %xmm1, 0x24(%rbx)
movss %xmm0, 0x18(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x543e
jp 0x543e
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
leaq 0x50(%rsp), %r14
movups %xmm1, 0x4(%r14)
movups %xmm1, 0x14(%r14)
movups %xmm1, 0x24(%r14)
andq $0x0, 0x34(%r14)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%r14)
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x14(%r14)
movss %xmm1, 0x28(%r14)
movaps 0x4b8e(%rip), %xmm1     # 0xa040
xorps %xmm0, %xmm1
movss %xmm1, 0x24(%r14)
movss %xmm0, 0x18(%r14)
movl %eax, 0x3c(%r14)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4130
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 $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x24(%rdi)
movups %xmm1, 0x14(%rdi)
movups %xmm1, 0x4(%rdi)
andq $0x0, 0x34(%rdi)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movss %xmm1, (%rbx)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x14(%rbx)
movss %xmm1, 0x28(%rbx)
movss %xmm0, 0x20(%rbx)
xorps 0x4ad2(%rip), %xmm0     # 0xa040
movss %xmm0, 0x8(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x5587
jp 0x5587
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
leaq 0x50(%rsp), %r14
movups %xmm1, 0x4(%r14)
movups %xmm1, 0x14(%r14)
movups %xmm1, 0x24(%r14)
andq $0x0, 0x34(%r14)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movss %xmm1, (%r14)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x14(%r14)
movss %xmm1, 0x28(%r14)
movss %xmm0, 0x20(%r14)
xorps 0x4a3f(%rip), %xmm0     # 0xa040
movss %xmm0, 0x8(%r14)
movl %eax, 0x3c(%r14)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4130
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 $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, 0x28(%rdi)
movups %xmm1, 0x18(%rdi)
movups %xmm1, 0x8(%rdi)
andl $0x0, 0x38(%rdi)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movss %xmm1, (%rbx)
movss %xmm1, 0x14(%rbx)
movaps 0x499a(%rip), %xmm1     # 0xa040
xorps %xmm0, %xmm1
movss %xmm1, 0x10(%rbx)
movss %xmm0, 0x4(%rbx)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x28(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x56cf
jp 0x56cf
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorps %xmm1, %xmm1
leaq 0x50(%rsp), %r14
movups %xmm1, 0x8(%r14)
movups %xmm1, 0x18(%r14)
movups %xmm1, 0x28(%r14)
andl $0x0, 0x38(%r14)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movss %xmm1, (%r14)
movss %xmm1, 0x14(%r14)
movaps 0x4906(%rip), %xmm1     # 0xa040
xorps %xmm0, %xmm1
movss %xmm1, 0x10(%r14)
movss %xmm0, 0x4(%r14)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x28(%r14)
movl %eax, 0x3c(%r14)
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4130
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 $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x38, %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, 0x10(%rsp)
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x4844(%rip), %xmm0     # 0xa030
subss 0x20(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x4400
movss 0x8(%r14), %xmm1
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
movaps %xmm1, %xmm4
movss 0xc(%rsp), %xmm8
mulss %xmm8, %xmm4
movaps 0x481e(%rip), %xmm3     # 0xa040
movsd (%r14), %xmm6
movaps %xmm6, %xmm5
shufps $0x0, %xmm6, %xmm5      # xmm5 = xmm5[0,0],xmm6[0,0]
mulps %xmm6, %xmm5
movaps %xmm6, %xmm2
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
mulps %xmm6, %xmm1
shufps $0x55, %xmm6, %xmm6     # xmm6 = xmm6[1,1,1,1]
movaps %xmm6, %xmm7
mulss %xmm6, %xmm7
mulss %xmm8, %xmm2
mulss %xmm8, %xmm6
movaps 0x10(%rsp), %xmm11
movaps %xmm11, %xmm8
shufps $0x0, %xmm11, %xmm8     # xmm8 = xmm8[0,0],xmm11[0,0]
movaps 0x20(%rsp), %xmm10
movaps %xmm10, %xmm9
unpcklps %xmm4, %xmm9            # xmm9 = xmm9[0],xmm4[0],xmm9[1],xmm4[1]
xorps %xmm3, %xmm4
shufps $0xd4, %xmm5, %xmm7     # xmm7 = xmm7[0,1],xmm5[1,3]
shufps $0x52, %xmm5, %xmm7     # xmm7 = xmm7[2,0],xmm5[1,1]
mulps %xmm8, %xmm5
addps %xmm9, %xmm5
movlps %xmm5, (%rbx)
unpcklps %xmm10, %xmm4           # xmm4 = xmm4[0],xmm10[0],xmm4[1],xmm10[1]
mulps %xmm8, %xmm7
addps %xmm4, %xmm7
movlps %xmm7, 0x10(%rbx)
xorps %xmm2, %xmm3
movaps %xmm1, %xmm4
mulss %xmm11, %xmm4
subss %xmm6, %xmm4
unpcklps %xmm3, %xmm6            # xmm6 = xmm6[0],xmm3[0],xmm6[1],xmm3[1]
mulps %xmm1, %xmm8
addps %xmm6, %xmm8
movlps %xmm8, 0x20(%rbx)
movss %xmm4, 0x8(%rbx)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm11, %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0x18(%rbx)
mulss %xmm11, %xmm0
addss %xmm10, %xmm0
movss %xmm0, 0x28(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x58f1
jp 0x58f1
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rsi
callq 0x44b0
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4130
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_O2/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmQuaternionRotation
void hpmQuaternionRotation(float* quat, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMquat *q = (HPMquat *) quat;
    initMat4(m);
    float xx, xy, xz, xw, yy, yz, yw, zz, zw;
    xx = q->x * q->x;
    xy = q->x * q->y;
    xz = q->x * q->z;
    xw = q->x * q->w;
    yy = q->y * q->y;
    yz = q->y * q->z;
    yw = q->y * q->w;
    zz = q->z * q->z;
    zw = q->z * q->w;
    m->_11 = 1.0 - (2.0 * (zz + yy));
    m->_12 = 2.0 * (xy - zw);
    m->_13 = 2.0 * (xz + yw);

    m->_21 = 2.0 * (xy + zw);
    m->_22 = 1.0 - (2.0 * (xx + zz));
    m->_23 = 2.0 * (yz - xw);

    m->_31 = 2.0 * (xz - yw);
    m->_32 = 2.0 * (yz + xw);
    m->_33 = 1.0 - (2.0 * (xx + yy));
    
    m->_44 = 1.0;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsi)
movups %xmm0, 0x20(%rsi)
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
movss (%rdi), %xmm1
movss 0x4(%rdi), %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
movaps %xmm1, %xmm8
mulss %xmm2, %xmm8
movss 0x8(%rdi), %xmm7
movaps %xmm1, %xmm4
mulss %xmm7, %xmm4
movss 0xc(%rdi), %xmm6
mulss %xmm6, %xmm1
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
movaps %xmm2, %xmm5
mulss %xmm7, %xmm5
mulss %xmm6, %xmm2
movaps %xmm7, %xmm9
mulss %xmm7, %xmm9
mulss %xmm6, %xmm7
movaps %xmm3, %xmm6
addss %xmm9, %xmm6
cvtss2sd %xmm6, %xmm10
addsd %xmm10, %xmm10
movsd 0x465a(%rip), %xmm6     # 0xa020
movapd %xmm6, %xmm11
subsd %xmm10, %xmm11
cvtsd2ss %xmm11, %xmm10
movss %xmm10, (%rsi)
movaps %xmm8, %xmm10
subss %xmm7, %xmm10
addss %xmm10, %xmm10
movss %xmm10, 0x10(%rsi)
movaps %xmm4, %xmm10
addss %xmm2, %xmm10
addss %xmm10, %xmm10
movss %xmm10, 0x20(%rsi)
addss %xmm8, %xmm7
addss %xmm7, %xmm7
addss %xmm0, %xmm9
cvtss2sd %xmm9, %xmm8
addsd %xmm8, %xmm8
movapd %xmm6, %xmm9
subsd %xmm8, %xmm9
cvtsd2ss %xmm9, %xmm8
movss %xmm7, 0x4(%rsi)
movss %xmm8, 0x14(%rsi)
movaps %xmm5, %xmm7
subss %xmm1, %xmm7
addss %xmm7, %xmm7
movss %xmm7, 0x24(%rsi)
subss %xmm2, %xmm4
addss %xmm4, %xmm4
movss %xmm4, 0x8(%rsi)
addss %xmm1, %xmm5
addss %xmm5, %xmm5
movss %xmm5, 0x18(%rsi)
addss %xmm0, %xmm3
cvtss2sd %xmm3, %xmm0
addsd %xmm0, %xmm0
subsd %xmm0, %xmm6
cvtsd2ss %xmm6, %xmm0
movss %xmm0, 0x28(%rsi)
movl $0x3f800000, 0x3c(%rsi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movss %xmm2, 0xc(%rsp)
movss %xmm1, 0x10(%rsp)
xorps %xmm1, %xmm1
movups %xmm1, 0x2c(%rdi)
movups %xmm1, 0x1c(%rdi)
movups %xmm1, 0xc(%rdi)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
cvtss2sd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
cvtss2sd 0xc(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss 0x24(%rsp), %xmm5
movaps %xmm5, %xmm1
movaps 0x30(%rsp), %xmm8
mulss %xmm8, %xmm1
movss 0x18(%rsp), %xmm4
movaps %xmm4, %xmm2
mulss %xmm0, %xmm2
movaps %xmm1, %xmm3
movss 0xc(%rsp), %xmm6
mulss %xmm6, %xmm3
addss %xmm2, %xmm3
movss %xmm3, (%rbx)
movaps %xmm4, %xmm2
mulss %xmm6, %xmm2
movaps %xmm6, %xmm7
mulss %xmm0, %xmm1
subss %xmm2, %xmm1
movss %xmm1, 0x10(%rbx)
movaps %xmm5, %xmm1
movss 0x10(%rsp), %xmm2
mulss %xmm2, %xmm1
movss %xmm1, 0x20(%rbx)
movaps %xmm2, %xmm1
mulss %xmm6, %xmm1
movss %xmm1, 0x4(%rbx)
movaps %xmm2, %xmm1
movaps %xmm2, %xmm6
mulss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
movaps %xmm4, %xmm1
movaps %xmm8, %xmm2
mulss %xmm8, %xmm1
xorps 0x442e(%rip), %xmm2     # 0xa040
movss %xmm2, 0x24(%rbx)
movaps %xmm5, %xmm2
mulss %xmm0, %xmm2
movaps %xmm1, %xmm3
mulss %xmm7, %xmm3
subss %xmm2, %xmm3
movss %xmm3, 0x8(%rbx)
movaps %xmm5, %xmm2
mulss %xmm7, %xmm2
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0x18(%rbx)
mulss %xmm6, %xmm4
movss %xmm4, 0x28(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x4160
movq %rsp, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4130
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_O2/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)
andq $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_O2/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)
andq $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 0x4130
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_O2/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)
andq $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_O2/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)
andq $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 0x4130
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_O2/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)
andq $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_O2/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)
andq $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 0x4130
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_O2/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)
andl $0x0, 0x38(%rsi)
movups %xmm2, 0x18(%rsi)
movups %xmm2, 0x8(%rsi)
cvtss2sd %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x43b0
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4260
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 0x4102(%rip), %xmm1     # 0xa040
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_O2/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmFastInverseTranspose
void hpmFastInverseTranspose(const float *mat, float *result){
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMmat4 *r = (HPMmat4 *) result;
    // Rotation component
    r->_11 = m->_11;
    r->_12 = m->_12;
    r->_13 = m->_13;

    r->_21 = m->_21;
    r->_22 = m->_22;
    r->_23 = m->_23;

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

// Assembly:
movss 0x10(%rdi), %xmm2
movss %xmm2, 0x10(%rsi)
movss 0x20(%rdi), %xmm0
movss %xmm0, 0x20(%rsi)
movsd (%rdi), %xmm8
movsd %xmm8, (%rsi)
movss 0x24(%rdi), %xmm3
movss %xmm3, 0x24(%rsi)
movss 0x8(%rdi), %xmm9
movss %xmm9, 0x8(%rsi)
movsd 0x14(%rdi), %xmm4
movsd %xmm4, 0x14(%rsi)
movss 0x28(%rdi), %xmm1
movss %xmm1, 0x28(%rsi)
movss 0x30(%rdi), %xmm6
movss 0x34(%rdi), %xmm5
movaps %xmm8, %xmm7
shufps $0x55, %xmm8, %xmm7     # xmm7 = xmm7[1,1],xmm8[1,1]
mulss %xmm5, %xmm7
mulss %xmm6, %xmm8
addss %xmm7, %xmm8
movss 0x38(%rdi), %xmm7
mulss %xmm7, %xmm9
addss %xmm8, %xmm9
movaps 0x395c(%rip), %xmm8     # 0xa040
xorps %xmm8, %xmm9
movss %xmm9, 0xc(%rsi)
movaps %xmm4, %xmm9
mulss %xmm5, %xmm9
mulss %xmm6, %xmm2
addss %xmm9, %xmm2
shufps $0x55, %xmm4, %xmm4     # xmm4 = xmm4[1,1,1,1]
mulss %xmm7, %xmm4
addss %xmm2, %xmm4
xorps %xmm8, %xmm4
movss %xmm4, 0x1c(%rsi)
mulss %xmm3, %xmm5
mulss %xmm6, %xmm0
addss %xmm5, %xmm0
mulss %xmm7, %xmm1
addss %xmm0, %xmm1
xorps %xmm8, %xmm1
movss %xmm1, 0x2c(%rsi)
movaps 0x3927(%rip), %xmm0     # 0xa060
movups %xmm0, 0x30(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x387e(%rip), %xmm1     # 0xa034
divss %xmm0, %xmm1
addss %xmm5, %xmm4
xorps 0x387b(%rip), %xmm4     # 0xa040
movss %xmm1, 0x28(%rdi)
divss %xmm0, %xmm4
movss %xmm4, 0x38(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movaps %xmm1, %xmm5
cvtsi2ss %edi, %xmm1
movaps %xmm0, %xmm4
movss 0x384a(%rip), %xmm6     # 0xa038
mulss %xmm6, %xmm1
movaps 0x3847(%rip), %xmm3     # 0xa040
cvtsi2ss %esi, %xmm2
movaps %xmm1, %xmm0
xorps %xmm3, %xmm0
mulss %xmm6, %xmm2
xorps %xmm2, %xmm3
movss 0x382a(%rip), %xmm6     # 0xa03c
movss 0x3816(%rip), %xmm7     # 0xa030
movq %rdx, %rdi
pushq $-0x40800000            # imm = 0xBF800000
pushq $0x3f800000             # imm = 0x3F800000
callq 0x40f0
popq %rax
popq %rcx
popq %rax
retq