LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: addToQueue
static void addToQueue(Node *node){
    HPSnode *n = (HPSnode *) node->data;
    if (n->pipeline){
        if (n->pipeline->isAlpha){
            hpsPush(&alphaQueue, n);
        } else {
            hpsPush(&renderQueue, n);
        }
    }
    if (n->extension){
        hpsVisibleExtensionNode(n);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0xbdc4
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
testb $0x1, (%rax)
je 0xbdb2
movq -0x10(%rbp), %rsi
leaq 0x7865(%rip), %rdi      # 0x13610
callq 0x4320
jmp 0xbdc2
movq -0x10(%rbp), %rsi
leaq 0x7833(%rip), %rdi      # 0x135f0
callq 0x4320
jmp 0xbdc4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0xbdd8
movq -0x10(%rbp), %rdi
callq 0x4260
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: setCameraSort
static void setCameraSort(HPScamera *camera){
    Plane *plane = &camera->planes[NEAR];
    float aa, ab, ac;
    aa = abs(plane->a); 
    ab = abs(plane->b); 
    ac = abs(plane->c); 

    if ((aa > ab) && (aa > ac)){
        if (plane->a > 0.0) { camera->sort = &xPositive; }
        else                { camera->sort = &xNegative; }
    } else if ((ab > ac)){
        if (plane->b > 0.0) { camera->sort = &yPositive; }
        else                { camera->sort = &yNegative; }
    } else {
        if (plane->c > 0.0) { camera->sort = &zPositive; }
        else                { camera->sort = &zNegative; }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x178, %rax            # imm = 0x178
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cvttss2si (%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cvttss2si 0x4(%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cvttss2si 0x8(%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x14(%rbp), %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0xbe9a
movss -0x14(%rbp), %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0xbe9a
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xbe83
movq -0x8(%rbp), %rax
leaq 0x1556(%rip), %rcx      # 0xd3d0
movq %rcx, 0x1e0(%rax)
jmp 0xbe95
movq -0x8(%rbp), %rax
leaq 0x1582(%rip), %rcx      # 0xd410
movq %rcx, 0x1e0(%rax)
jmp 0xbf23
movss -0x18(%rbp), %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0xbee3
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xbecf
movq -0x8(%rbp), %rax
leaq 0x159a(%rip), %rcx      # 0xd460
movq %rcx, 0x1e0(%rax)
jmp 0xbee1
movq -0x8(%rbp), %rax
leaq 0x15c6(%rip), %rcx      # 0xd4a0
movq %rcx, 0x1e0(%rax)
jmp 0xbf21
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xbf0d
movq -0x8(%rbp), %rax
leaq 0x15fc(%rip), %rcx      # 0xd500
movq %rcx, 0x1e0(%rax)
jmp 0xbf1f
movq -0x8(%rbp), %rax
leaq 0x1628(%rip), %rcx      # 0xd540
movq %rcx, 0x1e0(%rax)
jmp 0xbf21
jmp 0xbf23
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsOrthoCamera
static void hpsOrthoCamera(HPScamera *camera){
    float width = camera->vw * camera->vwRatio;
    float height = camera->vh * camera->vhRatio;
    float r = width * (0.5 + camera->vx);
    float l = r - width;
    float t = height * (0.5 + camera->vy);
    float b = t - height;
    hpmOrthoViewport(l, r, b, t, camera->n, camera->f, 
                     camera->vl, camera->vr, camera->vb, camera->vt,
                     camera->projection);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x3c(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x44(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x40(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x48(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss 0x5c(%rax), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x2c30(%rip), %xmm1     # 0xf028
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
subss -0xc(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss 0x60(%rax), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x2bf2(%rip), %xmm1     # 0xf028
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
movss -0x20(%rbp), %xmm2
movss -0x1c(%rbp), %xmm3
movq -0x8(%rbp), %rax
movss 0x30(%rax), %xmm4
movq -0x8(%rbp), %rax
movss 0x34(%rax), %xmm5
movq -0x8(%rbp), %rax
movss 0x4c(%rax), %xmm6
movq -0x8(%rbp), %rax
movss 0x50(%rax), %xmm7
movq -0x8(%rbp), %rax
movss 0x54(%rax), %xmm9
movq -0x8(%rbp), %rax
movss 0x58(%rax), %xmm8
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
movss %xmm9, (%rsp)
movss %xmm8, 0x8(%rsp)
callq 0x4100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsPerspectiveCamera
static void hpsPerspectiveCamera(HPScamera *camera){
    float width = camera->vw * camera->vwRatio;
    float height = camera->vh * camera->vhRatio;
    float scale = tan(hpmDegreesToRadians(camera->viewAngle * 0.5)) 
        * camera->n * 2.0;
    width = ((float) width / (float) height) * scale;
    height = scale;
    float r = width * (0.5 + camera->vx);
    float l = r - width;
    float t = height * (0.5 + camera->vy);
    float b = t - height;
    hpmFrustumViewport(l, r, b, t, camera->n, camera->f,
                       camera->vl, camera->vr, camera->vb, camera->vt,
                       camera->projection);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x3c(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x44(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x40(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x48(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x38(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2b09(%rip), %xmm1     # 0xf028
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x42b0
cvtss2sd %xmm0, %xmm0
callq 0x43a0
movq -0x8(%rbp), %rax
movss 0x30(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movsd 0x2aca(%rip), %xmm1     # 0xf018
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
divss -0x10(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss 0x5c(%rax), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x2a91(%rip), %xmm1     # 0xf028
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
subss -0xc(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss 0x60(%rax), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x2a53(%rip), %xmm1     # 0xf028
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x1c(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x20(%rbp), %xmm3
movq -0x8(%rbp), %rax
movss 0x30(%rax), %xmm4
movq -0x8(%rbp), %rax
movss 0x34(%rax), %xmm5
movq -0x8(%rbp), %rax
movss 0x4c(%rax), %xmm6
movq -0x8(%rbp), %rax
movss 0x50(%rax), %xmm7
movq -0x8(%rbp), %rax
movss 0x54(%rax), %xmm9
movq -0x8(%rbp), %rax
movss 0x58(%rax), %xmm8
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
movss %xmm9, (%rsp)
movss %xmm8, 0x8(%rsp)
callq 0x4500
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsSetCameraViewportDimensions
void hpsSetCameraViewportDimensions(HPScamera *camera, float width, float height){
    camera->vw = width;
    camera->vh = height;
    camera->viewportIsStatic = true;
    camera->update(camera);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x3c(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x40(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x64(%rax)
movq -0x8(%rbp), %rax
movq 0x1d8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsSetCameraViewportScreenPosition
void hpsSetCameraViewportScreenPosition(HPScamera *camera, float left, float right, float bottom, float top){
    if ((left < -1.0) || ( left > 1.0) ||
        (right < -1.0) || ( right > 1.0) ||
        (bottom < -1.0) || ( bottom > 1.0) ||
        (top < -1.0) ||( top > 1.0)){
        fprintf(stderr, "Camera viewport screen position values should be between -1.0 and 1.0.\n");
        return;
    }
    camera->vl = left; camera->vr = right;
    camera->vb = bottom; camera->vt = top;
    camera->update(camera);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x2937(%rip), %xmm0     # 0xf118
ucomisd %xmm1, %xmm0
ja 0xc890
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2814(%rip), %xmm1     # 0xf010
ucomisd %xmm1, %xmm0
ja 0xc890
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x2901(%rip), %xmm0     # 0xf118
ucomisd %xmm1, %xmm0
ja 0xc890
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x27e2(%rip), %xmm1     # 0xf010
ucomisd %xmm1, %xmm0
ja 0xc890
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x28d3(%rip), %xmm0     # 0xf118
ucomisd %xmm1, %xmm0
ja 0xc890
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x27b4(%rip), %xmm1     # 0xf010
ucomisd %xmm1, %xmm0
ja 0xc890
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x28a5(%rip), %xmm0     # 0xf118
ucomisd %xmm1, %xmm0
ja 0xc890
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2786(%rip), %xmm1     # 0xf010
ucomisd %xmm1, %xmm0
jbe 0xc8aa
movq 0x6761(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x28b3(%rip), %rsi      # 0xf154
movb $0x0, %al
callq 0x4280
jmp 0xc8f3
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4c(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x50(%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x54(%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x1d8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsMoveCamera
void hpsMoveCamera(HPScamera *camera, float *vec){
    if (camera->style == HPS_ORBIT){
        fprintf(stderr, "Can't move an HPS_ORBIT camera\n");
        return;
    }
    camera->position.x += vec[0];
    camera->position.y += vec[1];
    camera->position.z += vec[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0xc9f4
movq 0x6617(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x27b1(%rip), %rsi      # 0xf19c
movb $0x0, %al
callq 0x4280
jmp 0xca38
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0xc(%rax), %xmm0
movss %xmm0, 0xc(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x14(%rax), %xmm0
movss %xmm0, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsSetCameraPosition
void hpsSetCameraPosition(HPScamera *camera, float *vec){
    if (camera->style == HPS_ORBIT){
        fprintf(stderr, "Can't move an HPS_ORBIT camera\n");
        return;
    }
    camera->position.x = vec[0];
    camera->position.y = vec[1];
    camera->position.z = vec[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0xca74
movq 0x6597(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2731(%rip), %rsi      # 0xf19c
movb $0x0, %al
callq 0x4280
jmp 0xcaa9
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsCameraRotation
float *hpsCameraRotation(HPScamera *camera){
    if (camera->style != HPS_POSITION){
        fprintf(stderr, "Can't rotation a non HPS_POSITION camera\n");
        return NULL;
    }
    return (float *) &camera->rotation;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xcb08
movq 0x650b(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x26c5(%rip), %rsi      # 0xf1bc
movb $0x0, %al
callq 0x4280
movq $0x0, -0x8(%rbp)
jmp 0xcb14
movq -0x10(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsSetCameraUp
void hpsSetCameraUp(HPScamera *camera, float *up){
    if (camera->style != HPS_LOOK_AT){
        fprintf(stderr, "Can't set up on a non HPS_LOOK_AT camera\n");
        return;
    }
    camera->up.x = up[0];
    camera->up.y = up[1];
    camera->up.z = up[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0xcb54
movq 0x64b7(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x269b(%rip), %rsi      # 0xf1e6
movb $0x0, %al
callq 0x4280
jmp 0xcb89
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsCameraLookAt
void hpsCameraLookAt(HPScamera *camera, float *p){
    if ((camera->style != HPS_ORBIT) && (camera->style != HPS_LOOK_AT)) {
        fprintf(stderr, "Can't set object to look at for a non HPS_LOOK_AT or HPS_ORBIT camera\n");
        return;
    }
    camera->object.x = p[0];
    camera->object.y = p[1];
    camera->object.z = p[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xcbce
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0xcbce
movq 0x643d(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x264b(%rip), %rsi      # 0xf210
movb $0x0, %al
callq 0x4280
jmp 0xcc03
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x24(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x2c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsYawCamera
void hpsYawCamera(HPScamera *camera, float angle){
    if ((camera->style != HPS_ORBIT) && (camera->style != HPS_FIRST_PERSON)) {
        fprintf(stderr, "Can't yaw a non HPS_ORBIT or HPS_FIRST_PERSON camera\n");
        return;
    }
    camera->rotation.x += angle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xcc4f
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xcc4f
movq 0x63bc(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2611(%rip), %rsi      # 0xf257
movb $0x0, %al
callq 0x4280
jmp 0xcc62
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x68(%rax), %xmm0
movss %xmm0, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsSetCameraYaw
void hpsSetCameraYaw(HPScamera *camera, float angle){
    if ((camera->style != HPS_ORBIT) && (camera->style != HPS_FIRST_PERSON)) {
        fprintf(stderr, "Can't yaw a non HPS_ORBIT or HPS_FIRST_PERSON camera\n");
        return;
    }
    camera->style = HPS_ORBIT;
    camera->rotation.x = angle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xccaf
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xccaf
movq 0x635c(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x25b1(%rip), %rsi      # 0xf257
movb $0x0, %al
callq 0x4280
jmp 0xccc8
movq -0x8(%rbp), %rax
movl $0x2, 0x8(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsPitchCamera
void hpsPitchCamera(HPScamera *camera, float angle){
    if ((camera->style != HPS_ORBIT) && (camera->style != HPS_FIRST_PERSON)) {
        fprintf(stderr, "Can't pitch a non HPS_ORBIT or HPS_FIRST_PERSON camera\n");
        return;
    }
    camera->rotation.y += angle;
    camera->rotation.y = fmin(HALF_PI, fmax(-HALF_PI, camera->rotation.y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xcd0f
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xcd0f
movq 0x62fc(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2587(%rip), %rsi      # 0xf28d
movb $0x0, %al
callq 0x4280
jmp 0xcd54
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x6c(%rax), %xmm0
movss %xmm0, 0x6c(%rax)
movq -0x8(%rbp), %rax
movss 0x6c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x23f1(%rip), %xmm1     # 0xf128
maxsd %xmm1, %xmm0
movsd 0x23dd(%rip), %xmm1     # 0xf120
minsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x6c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsSetCameraPitch
void hpsSetCameraPitch(HPScamera *camera, float angle){
    if ((camera->style != HPS_ORBIT) && (camera->style != HPS_FIRST_PERSON)) {
        fprintf(stderr, "Can't pitch a non HPS_ORBIT or HPS_FIRST_PERSON camera\n");
        return;
    }
    camera->rotation.y = fmin(HALF_PI, fmax(-HALF_PI, angle));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xcd9f
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xcd9f
movq 0x626c(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x24f7(%rip), %rsi      # 0xf28d
movb $0x0, %al
callq 0x4280
jmp 0xcdcd
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2378(%rip), %xmm1     # 0xf128
maxsd %xmm1, %xmm0
movsd 0x2364(%rip), %xmm1     # 0xf120
minsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x6c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsZoomCamera
void hpsZoomCamera(HPScamera *camera, float distance){
    if (camera->style != HPS_ORBIT){
        fprintf(stderr, "Can't zoom a non HPS_ORBIT camera\n");
        return;
    }
    camera->rotation.w += distance;
    camera->rotation.w = (camera->rotation.w < FLT_MIN) ? FLT_MIN : camera->rotation.w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xce15
movq 0x61f6(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x24b9(%rip), %rsi      # 0xf2c5
movb $0x0, %al
callq 0x4280
jmp 0xce65
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x74(%rax), %xmm0
movss %xmm0, 0x74(%rax)
movq -0x8(%rbp), %rax
movss 0x22dc(%rip), %xmm0     # 0xf110
ucomiss 0x74(%rax), %xmm0
jbe 0xce49
movss 0x22ce(%rip), %xmm0     # 0xf110
movss %xmm0, -0x10(%rbp)
jmp 0xce57
movq -0x8(%rbp), %rax
movss 0x74(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x74(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsSetCameraZoom
void hpsSetCameraZoom(HPScamera *camera, float distance){
    if (camera->style != HPS_ORBIT){
        fprintf(stderr, "Can't zoom a non HPS_ORBIT camera\n");
        return;
    }
    camera->rotation.w = (distance < 0.0) ? 0.0 : distance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xcea5
movq 0x6166(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2429(%rip), %rsi      # 0xf2c5
movb $0x0, %al
callq 0x4280
jmp 0xcee1
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcec1
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xcecf
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x74(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsRollCamera
void hpsRollCamera(HPScamera *camera, float angle){
    if ((camera->style != HPS_ORBIT) && (camera->style != HPS_FIRST_PERSON)) {
        fprintf(stderr, "Can't roll a non HPS_ORBIT or HPS_FIRST_PERSON camera\n");
        return;
    }
    camera->rotation.z += angle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xcf2f
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xcf2f
movq 0x60dc(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x23c2(%rip), %rsi      # 0xf2e8
movb $0x0, %al
callq 0x4280
jmp 0xcf42
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x70(%rax), %xmm0
movss %xmm0, 0x70(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsSetCameraRoll
void hpsSetCameraRoll(HPScamera *camera, float angle){
    if ((camera->style != HPS_ORBIT) && (camera->style != HPS_LOOK_AT)) {
        fprintf(stderr, "Can't roll a non HPS_ORBIT or HPS_LOOK_AT camera\n");
        return;
    }
    camera->rotation.z = angle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0xcf8f
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0xcf8f
movq 0x607c(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2399(%rip), %rsi      # 0xf31f
movb $0x0, %al
callq 0x4280
jmp 0xcf9d
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x70(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsResizeCameras
void hpsResizeCameras(float width, float height){
    int i;
    for (i = 0; i < cameraList.size; i++){
	HPScamera *camera = (HPScamera *) cameraList.data[i];
        if (!camera->viewportIsStatic){
            camera->vw = width;
            camera->vh = height;
            camera->update(camera);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq 0x65e4(%rip), %rax      # 0x135b8
jae 0xd02d
movq 0x65d3(%rip), %rax      # 0x135b0
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x64(%rax)
jne 0xd020
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x3c(%rax)
movss -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x1d8(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0xd022
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcfc9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsMoveCameraForward
void hpsMoveCameraForward(HPScamera *camera, float dist){
    if ((camera->style != HPS_FIRST_PERSON)) {
        fprintf(stderr, "Can't move a non HPS_FIRST_PERSON camera forward\n");
        return;
    }
    float sinYaw = sin(camera->rotation.x);
    float cosYaw = cos(camera->rotation.x);
    camera->position.x += dist * sinYaw;
    camera->position.z -= dist * cosYaw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xd078
movq 0x5f96(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x22e5(%rip), %rsi      # 0xf351
movb $0x0, %al
callq 0x4280
jmp 0xd0fc
movq -0x8(%rbp), %rax
movss 0x68(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x68(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm2
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rax)
movss -0xc(%rbp), %xmm0
movss -0x14(%rbp), %xmm2
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm1
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsMoveCameraUp
void hpsMoveCameraUp(HPScamera *camera, float dist){
    if ((camera->style != HPS_FIRST_PERSON)) {
        fprintf(stderr, "Can't move a non HPS_FIRST_PERSON camera up\n");
        return;
    }
    camera->position.y += dist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xd145
movq 0x5ec6(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2247(%rip), %rsi      # 0xf383
movb $0x0, %al
callq 0x4280
jmp 0xd158
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsStrafeCamera
void hpsStrafeCamera(HPScamera *camera, float dist){
    if ((camera->style != HPS_FIRST_PERSON)) {
        fprintf(stderr, "Can't strafe a non HPS_FIRST_PERSON camera\n");
        return;
    }
    float sinYaw = sin(camera->rotation.x);
    float cosYaw = cos(camera->rotation.x);
    camera->position.x += dist * cosYaw;
    camera->position.z += dist * sinYaw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
je 0xd195
movq 0x5e76(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2224(%rip), %rsi      # 0xf3b0
movb $0x0, %al
callq 0x4280
jmp 0xd20b
movq -0x8(%rbp), %rax
movss 0x68(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4290
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x68(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x4400
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x14(%rbp), %xmm2
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rax)
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm2
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsInitCameras
void hpsInitCameras(){
    hpsInitVector(&cameraList, 16);
    hpsInitVector(&activeCameras, 16);
    hpsInitVector(&renderQueue, 4096);
    hpsInitVector(&alphaQueue, 1024);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6245(%rip), %rdi      # 0x135b0
movl $0x10, %esi
callq 0x4090
leaq 0x6254(%rip), %rdi      # 0x135d0
movl $0x10, %esi
callq 0x4090
leaq 0x6263(%rip), %rdi      # 0x135f0
movl $0x1000, %esi           # imm = 0x1000
callq 0x4090
leaq 0x6272(%rip), %rdi      # 0x13610
movl $0x400, %esi            # imm = 0x400
callq 0x4090
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: programSort
static int programSort(const void *a, const void *b){
    HPSpipeline *pa = (*((HPSnode **) a))->pipeline;
    HPSpipeline *pb = (*((HPSnode **) b))->pipeline;
    if (pa < pb) return -1;
    else if (pa > pb) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xd5dd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd5f9
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0xd5f0
movl $0x1, -0x4(%rbp)
jmp 0xd5f9
jmp 0xd5f2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: renderNode
static void renderNode(HPSnode *node, HPScamera *camera){
    hpmMultMat4(camera->viewProjection, node->transform, 
                camera->modelViewProjection);
#ifndef NO_INVERSE_TRANSPOSE
    hpmFastInverseTranspose(node->transform, currentInverseTransposeModel);
#endif
    node->pipeline->render(node->data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x138, %rdx            # imm = 0x138
callq 0x4140
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
leaq 0x5ede(%rip), %rsi      # 0x13570
callq 0x45a0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x88(%rcx), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/camera.c
// Function: alphaSort
static int alphaSort(const void *a, const void *b){
    BoundingSphere *ba = (*((HPSnode **) a))->partitionData.boundingSphere;
    BoundingSphere *bb = (*((HPSnode **) b))->partitionData.boundingSphere;

#ifdef ROUGH_ALPHA

#ifdef VOLUMETRIC_ALPHA
    return hpsBSFurtherFromCameraRough(&currentCamera, ba, bb);
#else
    return hpsFurtherFromCameraRough(&currentCamera, (float *) ba, (float *) bb);
#endif

#else // not ROUGH_ALPHA

#ifdef VOLUMETRIC_ALPHA
    return hpsBSFurtherFromCamera(&currentCamera, ba, bb);
#else
    return hpsFurtherFromCamera(&currentCamera, (float *) ba, (float *) bb);
#endif

#endif // ROUGH_ALPHA
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x5c83(%rip), %rdi      # 0x13380
callq 0x4050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsInit
void hpsInit(){
    hpsInitCameras();
    hpsInitVector(&activeScenes, 16);
    hpsInitVector(&freeScenes, 16);
    hpsPartitionInterface = hpsAABBpartitionInterface;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, %al
callq 0x4210
leaq 0x5f0e(%rip), %rdi      # 0x13630
movl $0x10, %esi
callq 0x4090
leaq 0x5f1d(%rip), %rdi      # 0x13650
movl $0x10, %esi
callq 0x4090
movq 0x583c(%rip), %rax      # 0x12f80
movq (%rax), %rcx
movq 0x586a(%rip), %rax      # 0x12fb8
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: deleteNode
static void deleteNode(HPSnode *node, HPSscene *scene){
    int i;
    scene->partitionInterface->removeNode(&node->partitionData);
    hpsDeleteFrom(node->partitionData.boundingSphere, scene->boundingSpherePool);
    hpsDeleteFrom(node->transform, scene->transformPool);
    for (i = 0; i < node->children.size; i++)
        deleteNode(node->children.data[i], scene);
    if ((HPSscene *) node->parent == scene)
        hpsRemove(&scene->topLevelNodes, node);
    else
        hpsRemove(&node->parent->children, node);
    freeNode(node, scene);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x4580
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x4580
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0xda39
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0xd9b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xda07
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xda59
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
callq 0x44b0
jmp 0xda6d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
callq 0x44b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xde10
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsMoveNode
void hpsMoveNode(HPSnode *node, float *vec){
    node->position.x += vec[0];
    node->position.y += vec[1];
    node->position.z += vec[2];
    node->needsUpdate = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x48(%rax), %xmm0
movss %xmm0, 0x48(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x4c(%rax), %xmm0
movss %xmm0, 0x4c(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x50(%rax), %xmm0
movss %xmm0, 0x50(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x90(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsSetNodePosition
void hpsSetNodePosition(HPSnode *node, float *p){
    node->position.x = p[0];
    node->position.y = p[1];
    node->position.z = p[2];
    node->needsUpdate = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x48(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4c(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x50(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x90(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsMakeScene
HPSscene *hpsMakeScene(){
    HPSscene *scene = (freeScenes.size) ?
	hpsPop(&freeScenes) : malloc(sizeof(HPSscene));
    scene->partitionInterface = hpsPartitionInterface;
    scene->nodePool = hpsMakePool(sizeof(HPSnode), hpsNodePoolSize, "Node pool");
    scene->transformPool = hpsMakePool(sizeof(float) * 16, hpsNodePoolSize,
				       "Transform pool");
    scene->boundingSpherePool = hpsMakePool(sizeof(BoundingSphere),
					    hpsNodePoolSize,
					    "Bounding sphere pool");
    scene->partitionStruct = scene->partitionInterface->new();
    scene->null = NULL;
    hpsInitVector(&scene->topLevelNodes, 1024);
    hpsInitVector(&scene->extensions, 4);
    hpsPush(&activeScenes, (void *) scene);
    return scene;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x5a28(%rip)      # 0x13658
je 0xdc44
leaq 0x5a17(%rip), %rdi      # 0x13650
callq 0x4390
movq %rax, -0x10(%rbp)
jmp 0xdc52
movl $0x78, %edi
callq 0x4300
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x5357(%rip), %rax      # 0x12fb8
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq 0x536d(%rip), %rax      # 0x12fe0
movl (%rax), %eax
movl %eax, %esi
movl $0x98, %edi
leaq 0x1759(%rip), %rdx      # 0xf3dc
callq 0x40c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x5346(%rip), %rax      # 0x12fe0
movl (%rax), %eax
movl %eax, %esi
movl $0x40, %edi
leaq 0x173c(%rip), %rdx      # 0xf3e6
callq 0x40c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq 0x531f(%rip), %rax      # 0x12fe0
movl (%rax), %eax
movl %eax, %esi
movl $0x10, %edi
leaq 0x1724(%rip), %rdx      # 0xf3f5
callq 0x40c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movb $0x0, %al
callq *(%rcx)
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x4090
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
movl $0x4, %esi
callq 0x4090
movq -0x8(%rbp), %rsi
leaq 0x58fe(%rip), %rdi      # 0x13630
callq 0x4320
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsDeleteScene
void hpsDeleteScene(HPSscene *scene){
    int i;
    for (i = 0; i < scene->topLevelNodes.size; i++)
        freeNode(scene->topLevelNodes.data[i], scene);
    scene->partitionInterface->delete(scene->partitionStruct);
    hpsDeleteExtensions(scene);
    hpsClearPool(scene->nodePool);
    hpsClearPool(scene->transformPool);
    hpsClearPool(scene->boundingSpherePool);
    hpsRemove(&activeScenes, (void *) scene);
    hpsPush(&freeScenes, (void *) scene);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xdd95
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
callq 0xde10
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdd63
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x4310
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x41c0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x41c0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x41c0
movq -0x8(%rbp), %rsi
leaq 0x584a(%rip), %rdi      # 0x13630
callq 0x44b0
movq -0x8(%rbp), %rsi
leaq 0x585a(%rip), %rdi      # 0x13650
callq 0x4320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: freeNode
static void freeNode(HPSnode *node, HPSscene *scene){
    int i;
    if (node->delete) node->delete(node->data);
    if (node->children.capacity){
	HPSvector *v = &node->children;
	for (i = 0; i < v->size; i++)
	    freeNode(v->data[i], scene);
	hpsDeleteVector(v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0xde46
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x88(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xde9e
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xde95
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0xde10
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xde64
movq -0x20(%rbp), %rdi
callq 0x4550
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsDeleteExtensions
void hpsDeleteExtensions(HPSscene *scene){
    int i;
    for (i = 0; i < scene->extensions.size; i += 2){
        HPSextension *e = (HPSextension *) scene->extensions.data[i];
        e->delete(scene->extensions.data[i+1]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jae 0xdf0f
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0xdec3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsAddPipeline
HPSpipeline *hpsAddPipeline(void (*preRender)(void *),
			    void (*render)(void *),
			    void (*postRender)(),
                            bool isAlpha){
    HPSpipeline *pipeline = malloc(sizeof(HPSpipeline));
    pipeline->isAlpha = isAlpha;
    pipeline->preRender = preRender;
    pipeline->render = render;
    pipeline->postRender = postRender;
    return pipeline;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl $0x20, %edi
callq 0x4300
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsSetNodeExtension
void hpsSetNodeExtension(HPSnode *node, HPSextension *extension){
    HPSscene *scene = hpsGetScene(node);
    int i;
    for (i = 0; i < scene->extensions.size; i += 2){
        HPSextension *e = (HPSextension *) scene->extensions.data[i];
        if ((void*) extension == (void*) e){
            node->extension = &scene->extensions.data[i];
            return;
        }
    }
    fprintf(stderr, "Node's %p scene does not have extension %p activated\n", node, extension);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4250
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jae 0xe13a
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0xe12d
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
jmp 0xe15a
jmp 0xe12f
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe0e4
movq 0x4eb7(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x12b7(%rip), %rsi      # 0xf40a
movb $0x0, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsActivateExtension
void hpsActivateExtension(HPSscene *scene, HPSextension *extension){
    int i;
    for (i = 0; i < scene->extensions.size; i += 2){
        HPSextension *e = (HPSextension *) scene->extensions.data[i];
        if (e == extension) return;
    }
    hpsPush(&scene->extensions, (void *) extension);
    hpsPush(&scene->extensions, NULL);
    extension->init(&scene->extensions.data[scene->extensions.size-1]);
}

// 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 0x60(%rcx), %rax
jae 0xe1b2
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xe1a5
jmp 0xe1f8
jmp 0xe1a7
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0xe177
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
callq 0x4320
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4320
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x60(%rcx), %rcx
subq $0x1, %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsExtensionData
void *hpsExtensionData(HPSscene *scene, HPSextension *extension){
    int i;
    for (i = 0; i < scene->extensions.size; i += 2){
        HPSextension *e = (HPSextension *) scene->extensions.data[i];
        if (e == extension) return scene->extensions.data[i+1];
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jae 0xe267
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xe25a
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xe26f
jmp 0xe25c
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe213
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsPreRenderExtensions
void hpsPreRenderExtensions(HPSscene *scene){
    int i;
    for (i = 0; i < scene->extensions.size; i += 2){
        HPSextension *e = (HPSextension *) scene->extensions.data[i];
        e->preRender(scene->extensions.data[i+1]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jae 0xe2df
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0xe293
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)