LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmPerspective
void hpmPerspective(int width, int height, float near, float far, float angle,
		    float *mat){
    float scale = tan(hpmDegreesToRadians(angle * 0.5)) * near;
    float r = ((float) width / (float) height) * scale;
    float l = -r;
    float t = scale;
    float b = -t;
    hpmFrustum(l, r, b, t, near, far, mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x64a6(%rip), %xmm1     # 0xf028
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x42b0
cvtss2sd %xmm0, %xmm0
callq 0x43a0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm0
cvtsi2ssl -0x8(%rbp), %xmm1
divss %xmm1, %xmm0
mulss -0x24(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
movss -0x30(%rbp), %xmm3
movss -0xc(%rbp), %xmm4
movss -0x10(%rbp), %xmm5
movq -0x20(%rbp), %rdi
callq 0x43b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/hypermath/src/hypermath.c
// Function: hpmLookAt
void hpmLookAt(float *eye, float *obj, float *up, float *mat){
    HPMmat4 *m = (HPMmat4 *) mat;
    HPMpoint f, r, u;
    initMat4(m);
    hpmSubVec(eye, obj, (float *) &f);
    hpmNormalize((float *) &f);
    hpmCross(up, (float *) &f, (float *) &r);
    hpmNormalize((float *) &r);
    hpmCross((float *) &f, (float *) &r, (float *) &u);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6360
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x4490
leaq -0x34(%rbp), %rdi
callq 0x4460
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x44d0
leaq -0x40(%rbp), %rdi
callq 0x4460
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x44d0
movss -0x40(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movss -0x3c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x20(%rax)
movss -0x4c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x48(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x44(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x24(%rax)
movss -0x34(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x18(%rax)
movss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x4360
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rsi
leaq -0x4c(%rbp), %rdi
callq 0x4360
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x34(%rax)
movq -0x8(%rbp), %rsi
leaq -0x34(%rbp), %rdi
callq 0x4360
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x38(%rax)
movq -0x28(%rbp), %rax
movss 0x62a0(%rip), %xmm0     # 0xf030
movss %xmm0, 0x3c(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsInitVector
void hpsInitVector(HPSvector *vector, size_t initialCapacity){
    if (initialCapacity > 0){
	vector->data = malloc(initialCapacity * sizeof(void *));
    } else {
	vector->data = NULL;
    }
    vector->capacity = initialCapacity;
    vector->isStatic = false;
    vector->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x8fe0
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x4300
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8feb
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsInitStaticVector
void hpsInitStaticVector(HPSvector *vector, void *data, size_t capacity){
    vector->data = data;
    vector->capacity = capacity;
    vector->isStatic = true;
    vector->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsPush
void hpsPush(HPSvector *vector, void *value){
    if (vector->size == vector->capacity){
	if (vector->isStatic){
	    void * new = malloc(2 * vector->capacity * sizeof(void *));
	    memcpy(new, vector->data,
		   sizeof(void*) * vector->capacity);
	    vector->data = new;
	    vector->capacity *= 2;
	    vector->isStatic = false;
	} else if (vector->capacity != 0){
	    vector->data = realloc(vector->data,
				   2 * vector->capacity * sizeof(void *));
	    vector->capacity *= 2;
	} else {
	    vector->data = malloc(DEFAULT_VECTOR_SIZE * sizeof(void *));
	    vector->capacity = DEFAULT_VECTOR_SIZE;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x91bd
movq -0x8(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x9158
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
shlq %rdi
shlq $0x3, %rdi
callq 0x4300
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x42a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x18(%rax)
jmp 0x91bb
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x9199
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq %rsi
shlq $0x3, %rsi
callq 0x43c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
jmp 0x91b9
movl $0x20, %edi
callq 0x4300
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x4, 0x10(%rax)
jmp 0x91bb
jmp 0x91bd
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsRemove
bool hpsRemove(HPSvector *vector, void *el){
    int i;
    for (i = 0; i < vector->size; i++){
	if (vector->data[i] == el){
	    hpsRemoveNth(vector, i);
	    return true;
	}
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x933a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x932d
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x40b0
movb $0x1, -0x1(%rbp)
jmp 0x933e
jmp 0x932f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x92f7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/vector.c
// Function: hpsRemoveNth
bool hpsRemoveNth(HPSvector *vector, size_t index){
    if (vector->size == 0 || index >= vector->size) return false;
    if (index <= (vector->size - 1))
	memmove(&vector->data[index], &vector->data[index + 1],
                sizeof(void*) * (vector->size - index - 1));
    --vector->size;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9379
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x937f
movb $0x0, -0x1(%rbp)
jmp 0x93e9
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
ja 0x93d5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
addq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
subq -0x18(%rbp), %rdx
subq $0x1, %rdx
shlq $0x3, %rdx
callq 0x43e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsInitPool
void hpsInitPool(HPSpool pool, void *data, size_t blockSize, size_t nBlocks, char name[32]){
    int i;
    char *poolStart = (char *) data;
    struct pool *p = (struct pool*) pool;
    p->blockSize = blockSize;
    p->nBlocks = nBlocks;
    p->nextPool = NULL;
    p->freeBlock = (void**) data;
    strcpy(p->name, name);
    for(i = 0; i < nBlocks - 1; i++){
	void **next = (void **) &poolStart[i * blockSize];
	*next = &poolStart[(i+1) * blockSize];
    }
    void **last = (void **) &poolStart[(nBlocks - 1) * blockSize];
    *last = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
callq 0x4080
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x94c0
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
addl $0x1, %eax
cltq
imulq -0x18(%rbp), %rax
addq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9475
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
imulq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsMakePool
HPSpool hpsMakePool(size_t blockSize, size_t nBlocks, char name[32]){
    size_t size = (blockSize < sizeof(void *)) ? sizeof(void *) : blockSize;
    char *pool = (char *) malloc(size * nBlocks + sizeof(struct pool));
    char *poolStart = &pool[sizeof(struct pool)];
    hpsInitPool((struct pool*) pool, poolStart, size, nBlocks, name);
    return (void *) pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x8, -0x8(%rbp)
jae 0x9516
movl $0x8, %eax
movq %rax, -0x38(%rbp)
jmp 0x951e
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
imulq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x4300
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x4440
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsDeletePool
void hpsDeletePool(HPSpool pool){
    struct pool *data = (struct pool*) pool;
    if (data->nextPool)
	hpsDeletePool(data->nextPool);
    free(pool);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x959c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4340
movq -0x8(%rbp), %rdi
callq 0x4040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsClearPool
void hpsClearPool(HPSpool pool){
    int i;
    struct pool *data = (struct pool*) pool;
    if (data->nextPool)
	hpsClearPool(data->nextPool);
    char *poolStart = &((char *) pool)[sizeof(struct pool)];
    const unsigned int size = data->blockSize;
    const unsigned int nBlocks = data->nBlocks;
    data->freeBlock = (void**) poolStart;
    for(i = 0; i < nBlocks - 1; i++){
	void **next = (void **) &poolStart[i * size];
	*next = &poolStart[(i+1) * size];
    }
    void **last = (void **) &poolStart[(nBlocks - 1) * size];
    *last = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x95dc
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x41c0
movq -0x8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x9654
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
imull -0x24(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
addl $0x1, %eax
imull -0x24(%rbp), %eax
movl %eax, %eax
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x960e
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
imull -0x24(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsAllocateFrom
void *hpsAllocateFrom(HPSpool pool){
#ifdef DEBUG
      if (!pool){
      fprintf(stderr, "Fatal: trying to allocate to a pool that doesn't exist!\n");
      exit(EXIT_FAILURE);
      }
#endif
    struct pool *data = (struct pool*) pool;
    void **block = data->freeBlock;
    if (!block){
	growPool(pool);
	block = data->freeBlock;
    }
    data->freeBlock = *block;
    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x96bc
movq -0x8(%rbp), %rdi
callq 0x96e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/pools.c
// Function: growPool
static void growPool(HPSpool pool){
    struct pool *data = (struct pool*) pool;
#ifdef DEBUG
    fprintf(stderr, "Warning: had to grow pool: %s\n", data->name);
#endif
    HPSpool newest = newestPool(pool);
    struct pool *newestData = (struct pool*) newest;
    newestData->nextPool = hpsMakePool(data->blockSize, data->nBlocks, "");
    struct pool *newData = (struct pool*) newestData->nextPool;
    data->freeBlock = newData->freeBlock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
leaq 0x5955(%rip), %rdx      # 0xf076
callq 0x40c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/pools.c
// Function: hpsDeleteFrom
void hpsDeleteFrom(void *block, HPSpool pool){
    struct pool *data = (struct pool*) pool;
    void **b = (void **)block;
    *b = data->freeBlock;
    data->freeBlock = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/pools.c
// Function: newestPool
static HPSpool newestPool(HPSpool pool){
    struct pool *data = (struct pool*) pool;
    if (data->nextPool)
	return newestPool(data->nextPool);
    else
	return pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x97d2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x97a0
movq %rax, -0x8(%rbp)
jmp 0x97da
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: hpsAABBremoveNode
void hpsAABBremoveNode(Node *node){
    AABBtree *tree = (AABBtree *) node->area;
    if (hpsRemove(&tree->nodes, (void *) node)){
	shrinkExtents(tree, node->boundingSphere);
	maybeKillTree(tree);
    } else {
	fprintf(stderr, "Warning, tried to remove node %p from an AABB tree that it did not belong to\n", node->data);
#ifdef DEBUG
        int i;
        printTree(tree);
        printf("\nNodes: ");
        for (i = 0; i < tree->nodes.size; i++)
            printf("%p ", ((Node *) tree->nodes.data[i])->data);
        printf("\n");
        AABBtree *topLevel = tree;
        while (topLevel->parent){
            topLevel = topLevel->parent;
        }
        printf("Maybe child of: ");
        AABBtree *parent = hpsAABBfindNode(node, topLevel);
        printTree(parent);
        printf("\nNodes: ");
        for (i = 0; i < parent->nodes.size; i++)
            printf("%p ", ((Node *) tree->nodes.data[i])->data);
        printf("\n");
        exit(EXIT_FAILURE);
#endif
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
movq -0x8(%rbp), %rsi
callq 0x44b0
testb $0x1, %al
jne 0x98a2
jmp 0x98bd
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xa040
movq -0x10(%rbp), %rdi
callq 0xa140
jmp 0x98dd
movq 0x9734(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x57b9(%rip), %rsi      # 0xf08f
movb $0x0, %al
callq 0x4280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: hpsAABBupdateNode
void hpsAABBupdateNode(Node *node){
    AABBtree *tree = (AABBtree *) node->area;
    AABBtree *t = tree;
    while (t->parent && !contains(t, node->boundingSphere)){
	t = t->parent;
    }
    t = hpsAABBfindNode(node, t);
    if (t != tree){
	hpsAABBremoveNode(node);
	addNode(node, t);
        growExtents(t, node->boundingSphere);
    } else {
	growExtents(t, node->boundingSphere);
	shrinkExtents(t, node->boundingSphere);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x9934
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xa1b0
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x993d
jmp 0x994a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9910
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4450
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x998d
movq -0x8(%rbp), %rdi
callq 0x4150
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43f0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x9e10
jmp 0x99ad
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x9e10
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xa040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: newTree
static AABBtree *newTree(HPSpool pool, AABBtree *parent){
    AABBtree *tree = hpsAllocateFrom(pool);
    hpsInitStaticVector(&tree->nodes, tree->nodesData, TREE_NODES);
    tree->parent = parent;
    tree->pool = pool;
    tree->split = 0;
    tree->lastChecked = 0;
    tree->extentsCorrect = false;
    memset(tree->children, 0, 27 * sizeof(void *));
    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4510
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
movq -0x18(%rbp), %rsi
addq $0x138, %rsi            # imm = 0x138
movl $0x2d, %edx
callq 0x4480
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x18(%rbp), %rax
movw $0x0, 0xe8(%rax)
movq -0x18(%rbp), %rax
movw $0x0, 0xea(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x110(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0xd8, %edx
callq 0x4200
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: hpsAABBfindNode
AABBtree *hpsAABBfindNode(Node *node, AABBtree *tree){
    AABBtree *t = tree;
    AABBtree *u = NULL;
    while (u != t){
	u = t;
	t = whichBranch(t, node->boundingSphere);
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x9b18
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x9b30
movq %rax, -0x18(%rbp)
jmp 0x9af0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: shrinkExtents
static void shrinkExtents(AABBtree *tree, BoundingSphere *bs){
    AABBtree *t = tree;
    do {
	if (bs->x - bs->r <= t->min.x ||
	    bs->y - bs->r <= t->min.y ||
	    bs->z - bs->r <= t->min.z ||
	    bs->x + bs->r >= t->max.x ||
	    bs->y + bs->r >= t->max.y ||
	    bs->z + bs->r >= t->max.z)
	    t->extentsCorrect = false;
    } while ((t = t->parent));
}

// Assembly:
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
movss (%rax), %xmm1
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0xf8(%rax), %xmm0
ucomiss %xmm1, %xmm0
jae 0xa11c
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0xfc(%rax), %xmm0
ucomiss %xmm1, %xmm0
jae 0xa11c
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x100(%rax), %xmm0
ucomiss %xmm1, %xmm0
jae 0xa11c
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0x104(%rax), %xmm0
jae 0xa11c
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0x108(%rax), %xmm0
jae 0xa11c
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0x10c(%rax), %xmm0
jb 0xa127
movq -0x18(%rbp), %rax
movb $0x0, 0x110(%rax)
jmp 0xa129
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xa054
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: maybeKillTree
static void maybeKillTree(AABBtree *tree){
    int i;
    if (tree->parent && tree->nodes.size == 0){
	for (i = 0; i < 27; i++)
	    if (tree->children[i]) return;
#ifdef DEBUG
        printf("Killing tree ");
        printTree(tree);
        printf("\n");
#endif
	removeChild(tree->parent, tree);
	deleteTree(tree);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa1a9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x120(%rax)
jne 0xa1a9
movl $0x0, -0xc(%rbp)
cmpl $0x1b, -0xc(%rbp)
jge 0xa190
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0xa183
jmp 0xa1a9
jmp 0xa185
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa16b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xa3a0
movq -0x8(%rbp), %rdi
callq 0xa430
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: contains
static bool contains(AABBtree *t, BoundingSphere *bs){
    return (bs->x - bs->r >= t->min.x &&
	    bs->y - bs->r >= t->min.y &&
	    bs->z - bs->r >= t->min.z &&
	    bs->x + bs->r <= t->max.x &&
	    bs->y + bs->r <= t->max.y &&
	    bs->z + bs->r <= t->max.z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
ucomiss 0xf8(%rcx), %xmm0
movb %al, -0x11(%rbp)
jb 0xa2a5
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
ucomiss 0xfc(%rcx), %xmm0
movb %al, -0x11(%rbp)
jb 0xa2a5
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
ucomiss 0x100(%rcx), %xmm0
movb %al, -0x11(%rbp)
jb 0xa2a5
movq -0x10(%rbp), %rax
movss (%rax), %xmm1
movq -0x10(%rbp), %rax
addss 0xc(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x104(%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rbp)
jb 0xa2a5
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x10(%rbp), %rax
addss 0xc(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x108(%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rbp)
jb 0xa2a5
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
addss 0xc(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x10c(%rax), %xmm0
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: doVisible
static void doVisible(AABBtree *tree, Plane *planes, void (*func)(Node *), int planeMask){
    int nextMask = 0;
    int inView = inPlanes(tree, planes, planeMask, &nextMask);
    int i;
    if (inView == INSIDE)
	treeMap(tree, func);
    else if (inView == INTERSECT){
#ifdef DEBUG
        nTrees++;
#endif 
	for (i = 0; i < tree->nodes.size; i++)
	    func(tree->nodes.data[i]);
	for (i = 0; i < 27; i++){
	    AABBtree *child = tree->children[i];
	    if (child)
		doVisible(child, planes, func, nextMask);
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x20(%rbp), %rcx
callq 0xa470
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xa2fd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa700
jmp 0xa38d
cmpl $0x2, -0x24(%rbp)
jne 0xa38b
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x120(%rcx), %rax
jae 0xa343
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x118(%rcx), %rcx
movslq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xa30e
movl $0x0, -0x28(%rbp)
cmpl $0x1b, -0x28(%rbp)
jge 0xa389
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa37c
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x20(%rbp), %ecx
callq 0xa2b0
jmp 0xa37e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xa34a
jmp 0xa38b
jmp 0xa38d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: removeChild
static void removeChild(AABBtree *tree, AABBtree *c){
    bool unsplit = true;
    int i;
    for (i = 0; i < 27; i++){
	AABBtree *child = tree->children[i];
	if (child){
	    if (child == c)
		tree->children[i] = NULL;
	    else
		unsplit = false;
	}
    }
    if (unsplit) tree->split = 0;
    maybeKillTree(tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1b, -0x18(%rbp)
jge 0xa409
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa3fc
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xa3f6
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
jmp 0xa3fa
movb $0x0, -0x11(%rbp)
jmp 0xa3fc
jmp 0xa3fe
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa3bb
testb $0x1, -0x11(%rbp)
je 0xa41c
movq -0x8(%rbp), %rax
movw $0x0, 0xe8(%rax)
movq -0x8(%rbp), %rdi
callq 0xa140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: treeMap
static void treeMap(AABBtree *tree, void (*func)(Node *)){
#ifdef DEBUG
    nTrees++;
#endif 
    int i;
    for (i = 0; i < tree->nodes.size; i++)
	func(tree->nodes.data[i]);
    for (i = 0; i < 27; i++){
	AABBtree *child = tree->children[i];
	if (child)
	    treeMap(child, func);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x120(%rcx), %rax
jae 0xa74c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x118(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa717
movl $0x0, -0x14(%rbp)
cmpl $0x1b, -0x14(%rbp)
jge 0xa78b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa77e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa700
jmp 0xa780
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa753
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: getAABBtreeExtents
static void getAABBtreeExtents(AABBtree *tree, Point *min, Point *max){
    if (!tree->extentsCorrect)
	updateExtents(tree);
    if (!tree->split && (tree->nodes.size >= SPLIT_THRESHOLD))
	splitTree(tree);
    *min = tree->min;
    *max = tree->max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x110(%rax)
jne 0xa7ca
movq -0x8(%rbp), %rdi
callq 0xa970
movq -0x8(%rbp), %rax
cmpw $0x0, 0xe8(%rax)
jne 0xa7ef
movq -0x8(%rbp), %rax
cmpq $0x1e, 0x120(%rax)
jb 0xa7ef
movq -0x8(%rbp), %rdi
callq 0xadc0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rdx
movq %rdx, (%rax)
movl 0x100(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x104(%rcx), %rdx
movq %rdx, (%rax)
movl 0x10c(%rcx), %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: setPNvectors
static void setPNvectors(Plane *plane, Point *p, Point *n, Point *min, Point *max){
    if (plane->a < 0.0) { p->x = min->x; n->x = max->x; }
    else                { p->x = max->x; n->x = min->x; }
    if (plane->b < 0.0) { p->y = min->y; n->y = max->y; }
    else                { p->y = max->y; n->y = min->y; }
    if (plane->c < 0.0) { p->z = min->z; n->z = max->z; }
    else                { p->z = max->z; n->z = min->z; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa87f
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
jmp 0xa89f
movq -0x28(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa8db
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
jmp 0xa8ff
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa93b
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
jmp 0xa95f
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: setSplitLocation
static void setSplitLocation(AABBtree *tree){
    float x = 0, y = 0, z= 0;
    int i;
    for (i = 0; i < tree->nodes.size; i++){
	BoundingSphere *bs =
	    ((Node *) tree->nodes.data[i])->boundingSphere;
	x += bs->x;
	y += bs->y;
	z += bs->z;
    }
    x /= i; y /= i; z /= i;
    Point p = {x, y, z};
    tree->splitPoint = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x120(%rcx), %rax
jae 0xb035
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
addss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xafc7
cvtsi2ssl -0x18(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
cvtsi2ssl -0x18(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
cvtsi2ssl -0x18(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x2c(%rbp), %rcx
movq %rcx, 0xec(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0xf4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/aabb-tree.c
// Function: setSplitDirection
static void setSplitDirection(AABBtree *tree){
    float x = tree->max.x - tree->min.x;
    float y = tree->max.y - tree->min.y;
    float z = tree->max.z - tree->min.z;
    unsigned int dir = SPLIT_X | SPLIT_Y | SPLIT_Z;
    if ((x < y/SPLIT_DIR_THRESHOLD) || (x < z/SPLIT_DIR_THRESHOLD))
	dir &= ~SPLIT_X;
    if ((y < x/SPLIT_DIR_THRESHOLD) || (y < z/SPLIT_DIR_THRESHOLD))
	dir &= ~SPLIT_Y;
    if ((z < x/SPLIT_DIR_THRESHOLD) || (z < y/SPLIT_DIR_THRESHOLD))
	dir &= ~SPLIT_Z;
    tree->split = dir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x104(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xf8(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x108(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xfc(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x10c(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x100(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x7, -0x18(%rbp)
movss -0xc(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
movss 0x3f54(%rip), %xmm2     # 0xf07c
divss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
ja 0xb14c
movss -0xc(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
movss 0x3f39(%rip), %xmm2     # 0xf07c
divss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb155
movl -0x18(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x18(%rbp)
movss -0x10(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
movss 0x3f15(%rip), %xmm2     # 0xf07c
divss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
ja 0xb18b
movss -0x10(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
movss 0x3efa(%rip), %xmm2     # 0xf07c
divss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb194
movl -0x18(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x18(%rbp)
movss -0x14(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
movss 0x3ed6(%rip), %xmm2     # 0xf07c
divss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
ja 0xb1ca
movss -0x14(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
movss 0x3ebb(%rip), %xmm2     # 0xf07c
divss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb1d3
movl -0x18(%rbp), %eax
andl $-0x5, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xe8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsCloserToCamera
int hpsCloserToCamera(const HPScamera *camera, const float *a, const float *b){
    float m, n;
    camera->sort((HPMpoint *) a, (HPMpoint *) b, &m, &n);
    if (m < n) return -1;
    else if (m > n) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq *%rax
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb2f9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb316
movss -0x24(%rbp), %xmm0
ucomiss -0x28(%rbp), %xmm0
jbe 0xb30d
movl $0x1, -0x4(%rbp)
jmp 0xb316
jmp 0xb30f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsFurtherFromCamera
int hpsFurtherFromCamera(const HPScamera *camera, const float *a, const float *b){
    float m, n, mx, my, mz, nx, ny, nz;
    HPMpoint c = camera->position;
    mx = a[0] - c.x;
    my = a[1] - c.y;
    mz = a[2] - c.z;
    m =  mx*mx + my*my + mz*mz;
    nx = b[0] - c.x;
    ny = b[1] - c.y;
    nz = b[2] - c.z;
    n =  nx*nx + ny*ny + nz*nz;
    if (m > n) return -1;
    else if (m < n) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xc(%rax), %rcx
movq %rcx, -0x4c(%rbp)
movl 0x14(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
subss -0x4c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
subss -0x48(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
subss -0x44(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x2c(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movss -0x30(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x34(%rbp), %xmm0
movss -0x34(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
subss -0x4c(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
subss -0x48(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
subss -0x44(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x38(%rbp), %xmm1
movss -0x38(%rbp), %xmm2
movss -0x3c(%rbp), %xmm0
mulss -0x3c(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x40(%rbp), %xmm0
movss -0x40(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
ucomiss -0x28(%rbp), %xmm0
jbe 0xb49c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb4bd
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb4b4
movl $0x1, -0x4(%rbp)
jmp 0xb4bd
jmp 0xb4b6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsBSCloserToCamera
int hpsBSCloserToCamera(const HPScamera *camera, const float *a, const float *b){
    float m, n;
    camera->sort((HPMpoint *) a, (HPMpoint *) b, &m, &n);
    float mr = m - a[3];
    float nr = n - b[3];
    if (mr < nr) return -1;
    else if (mr > nr) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1e0(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq *%rax
movss -0x24(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0xc(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
subss 0xc(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm1
movss -0x30(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb53f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb55c
movss -0x2c(%rbp), %xmm0
ucomiss -0x30(%rbp), %xmm0
jbe 0xb553
movl $0x1, -0x4(%rbp)
jmp 0xb55c
jmp 0xb555
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsBSFurtherFromCamera
int hpsBSFurtherFromCamera(const HPScamera *camera, const float *a, const float *b){
    float m, n, mx, my, mz, nx, ny, nz, mr, nr;
    HPMpoint c = camera->position;
    mr = a[3];
    nr = b[3];
    mx = a[0] - c.x - mr;
    my = a[1] - c.y - mr;
    mz = a[2] - c.z - mr;
    m =  mx*mx + my*my + mz*mz;
    nx = b[0] - c.x - nr;
    ny = b[1] - c.y - nr;
    nz = b[2] - c.z - nr;
    n =  nx*nx + ny*ny + nz*nz;
    if (m > n) return -1;
    else if (m < n) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xc(%rax), %rcx
movq %rcx, -0x54(%rbp)
movl 0x14(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
subss -0x54(%rbp), %xmm0
subss -0x44(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
subss -0x50(%rbp), %xmm0
subss -0x44(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
subss -0x4c(%rbp), %xmm0
subss -0x44(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x2c(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movss -0x30(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x34(%rbp), %xmm0
movss -0x34(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
subss -0x54(%rbp), %xmm0
subss -0x48(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
subss -0x50(%rbp), %xmm0
subss -0x48(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
subss -0x4c(%rbp), %xmm0
subss -0x48(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x38(%rbp), %xmm1
movss -0x38(%rbp), %xmm2
movss -0x3c(%rbp), %xmm0
mulss -0x3c(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss -0x40(%rbp), %xmm0
movss -0x40(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
ucomiss -0x28(%rbp), %xmm0
jbe 0xb756
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb777
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb76e
movl $0x1, -0x4(%rbp)
jmp 0xb777
jmp 0xb770
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsRenderCamera
void hpsRenderCamera(HPScamera *camera){
    currentCamera = *camera; // Set current camera to this one
    HPScamera *c = &currentCamera;
    clearQueues();
    computePlanes(c);
    c->scene->partitionInterface->doVisible(c->scene->partitionStruct,
                                            c->planes, &addToQueue);
    setCameraSort(c);
    hpsPreRenderExtensions(c->scene);
    renderQueues(c);
    hpsPostRenderExtensions(c->scene);
    *camera = currentCamera; // Copy currentCamera back into camera
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x7959(%rip), %rdi      # 0x13380
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x42a0
leaq 0x7948(%rip), %rax      # 0x13380
movq %rax, -0x10(%rbp)
callq 0xd3b0
movq -0x10(%rbp), %rdi
callq 0xbac0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x30(%rcx), %rdi
movq -0x10(%rbp), %rsi
addq $0x178, %rsi            # imm = 0x178
leaq 0x2fa(%rip), %rdx       # 0xbd70
callq *%rax
movq -0x10(%rbp), %rdi
callq 0xbde0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4410
movq -0x10(%rbp), %rdi
callq 0xbf30
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x44e0
movq -0x8(%rbp), %rdi
leaq 0x78d3(%rip), %rsi      # 0x13380
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x42a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)