LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x3, 0x8(%rdi)
jne 0x8b99
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss %xmm0, 0xc(%rsp)
cvtss2sd 0x68(%rdi), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
cvtss2sd 0x68(%rbx), %xmm0
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm1
mulss %xmm2, %xmm1
addss 0xc(%rbx), %xmm1
movss %xmm1, 0xc(%rbx)
movss 0x14(%rbx), %xmm1
mulss %xmm2, %xmm0
subss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq 0x5458(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x181b(%rip), %rdi      # 0xa3c5
pushq $0x31
popq %rsi
pushq $0x1
popq %rdx
jmp 0x44a0
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x3, 0x8(%rdi)
jne 0x8bc6
addss 0x10(%rdi), %xmm0
movss %xmm0, 0x10(%rdi)
retq
movq 0x542b(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x1820(%rip), %rdi      # 0xa3f7
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
jmp 0x44a0
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x3, 0x8(%rdi)
jne 0x8c46
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss %xmm0, 0xc(%rsp)
cvtss2sd 0x68(%rdi), %xmm0
callq 0x4260
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
cvtss2sd 0x68(%rbx), %xmm0
callq 0x43b0
cvtsd2ss %xmm0, %xmm0
movss 0xc(%rsp), %xmm1
mulss %xmm1, %xmm0
addss 0xc(%rbx), %xmm0
movss %xmm0, 0xc(%rbx)
movss 0x8(%rsp), %xmm0
mulss %xmm1, %xmm0
addss 0x14(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq 0x53ab(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x17cd(%rip), %rdi      # 0xa424
pushq $0x2b
popq %rsi
pushq $0x1
popq %rdx
jmp 0x44a0
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/camera.c
// Function: hpsInitCameras
void hpsInitCameras(){
    hpsInitVector(&cameraList, 16);
    hpsInitVector(&activeCameras, 16);
    hpsInitVector(&renderQueue, 4096);
    hpsInitVector(&alphaQueue, 1024);
}

// Assembly:
pushq %rbx
leaq 0x5870(%rip), %rdi      # 0xe560
pushq $0x10
popq %rbx
movq %rbx, %rsi
callq 0x4080
leaq 0x587e(%rip), %rdi      # 0xe580
movq %rbx, %rsi
callq 0x4080
leaq 0x588f(%rip), %rdi      # 0xe5a0
movl $0x1000, %esi           # imm = 0x1000
callq 0x4080
leaq 0x589e(%rip), %rdi      # 0xe5c0
movl $0x400, %esi            # imm = 0x400
popq %rbx
jmp 0x4080
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rsi
leaq 0x5620(%rip), %rdi      # 0xe428
leaq 0x5659(%rip), %rdx      # 0xe468
callq 0x4130
movq 0x68(%rbx), %rdi
leaq 0x5701(%rip), %rsi      # 0xe520
callq 0x44f0
movq 0x70(%rbx), %rax
movq 0x88(%rbx), %rdi
popq %rbx
jmpq *0x10(%rax)
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsInit
void hpsInit(){
    hpsInitCameras();
    hpsInitVector(&activeScenes, 16);
    hpsInitVector(&freeScenes, 16);
    hpsPartitionInterface = hpsAABBpartitionInterface;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
callq 0x41f0
leaq 0x5781(%rip), %rdi      # 0xe5e0
pushq $0x10
popq %rbx
movq %rbx, %rsi
callq 0x4080
leaq 0x578f(%rip), %rdi      # 0xe600
movq %rbx, %rsi
callq 0x4080
movq 0x5100(%rip), %rax      # 0xdf80
movq (%rax), %rax
movq 0x512e(%rip), %rcx      # 0xdfb8
movq %rax, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsAddNode
HPSnode *hpsAddNode(HPSnode *parent, void *data,
                    HPSpipeline *pipeline,
                    void (*deleteFunc)(void *)){
    HPSscene *scene = hpsGetScene(parent);
    HPSnode *node = hpsAllocateFrom(scene->nodePool);
    node->transform = hpsAllocateFrom(scene->transformPool);
    node->partitionData.data = node;
    node->partitionData.boundingSphere = hpsAllocateFrom(scene->boundingSpherePool);
    hpmIdentityMat4(node->transform);
    initBoundingSphere(node->partitionData.boundingSphere);
    node->position.x = 0.0; node->position.y = 0.0; node->position.z = 0.0;
    node->rotation.x = 0.0; node->rotation.y = 0.0; node->rotation.z = 0.0; 
    node->rotation.w = 1.0;
    node->data = data;
    node->pipeline = pipeline;
    node->extension = NULL;
    node->parent = parent;
    node->delete = deleteFunc;
    node->needsUpdate = true;
    hpsInitVector(&node->children, 0);
    scene->partitionInterface->addNode(&node->partitionData, scene->partitionStruct);
    if ((HPSscene *) parent == scene)
        hpsPush(&scene->topLevelNodes, node);
    else
        hpsPush(&parent->children, node);
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x4210
movq %rax, %r15
movq 0x38(%rax), %rdi
callq 0x4480
movq %rax, %r14
movq 0x48(%r15), %rdi
callq 0x4480
movq %rax, 0x68(%r14)
leaq 0x8(%r14), %r12
movq %r14, 0x18(%r14)
movq 0x40(%r15), %rdi
callq 0x4480
movq %rax, 0x8(%r14)
movq 0x68(%r14), %rdi
callq 0x42b0
movq 0x8(%r14), %rax
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
andq $0x0, (%rax)
movq %rcx, 0x8(%rax)
andq $0x0, 0x58(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movl $0x3f800000, 0x60(%r14) # imm = 0x3F800000
movq %rbp, 0x88(%r14)
movq %r13, 0x70(%r14)
andq $0x0, 0x78(%r14)
movq %rbx, (%r14)
movq (%rsp), %rax
movq %rax, 0x80(%r14)
movb $0x1, 0x90(%r14)
leaq 0x28(%r14), %rdi
xorl %esi, %esi
callq 0x4080
movq 0x28(%r15), %rax
movq 0x30(%r15), %rsi
movq %r12, %rdi
callq *0x10(%rax)
leaq 0x28(%rbx), %rax
leaq 0x8(%r15), %rdi
cmpq %rbx, %r15
cmovneq %rax, %rdi
movq %r14, %rsi
callq 0x42e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rax
addq $0x8, %rdi
callq *0x18(%rax)
movq 0x8(%rbx), %rdi
movq 0x40(%r14), %rsi
callq 0x44e0
movq 0x68(%rbx), %rdi
movq 0x48(%r14), %rsi
callq 0x44e0
xorl %r15d, %r15d
cmpq %r15, 0x30(%rbx)
jbe 0x8fe5
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x8f97
incq %r15
jmp 0x8fca
movq (%rbx), %rax
leaq 0x28(%rax), %rdi
leaq 0x8(%r14), %rcx
cmpq %r14, %rax
cmoveq %rcx, %rdi
movq %rbx, %rsi
callq 0x4430
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x91d3
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x5562(%rip)      # 0xe608
je 0x90b6
leaq 0x5551(%rip), %rdi      # 0xe600
callq 0x4350
jmp 0x90be
pushq $0x78
popq %rdi
callq 0x42c0
movq %rax, %rbx
movq 0x4ef0(%rip), %rax      # 0xdfb8
movq (%rax), %rax
movq %rax, 0x28(%rbx)
movq 0x4f0a(%rip), %r14      # 0xdfe0
movl (%r14), %esi
leaq 0x1370(%rip), %rdx      # 0xa450
movl $0x98, %edi
callq 0x40b0
movq %rax, 0x38(%rbx)
movl (%r14), %esi
leaq 0x1362(%rip), %rdx      # 0xa45a
pushq $0x40
popq %rdi
callq 0x40b0
movq %rax, 0x48(%rbx)
movl (%r14), %esi
leaq 0x135b(%rip), %rdx      # 0xa469
pushq $0x10
popq %rdi
callq 0x40b0
movq %rax, 0x40(%rbx)
movq 0x28(%rbx), %rcx
xorl %eax, %eax
callq *(%rcx)
movq %rax, 0x30(%rbx)
andq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x4080
leaq 0x58(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0x4080
leaq 0x5495(%rip), %rdi      # 0xe5e0
movq %rbx, %rsi
callq 0x42e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq %r14, 0x10(%rbx)
jbe 0x9180
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x91d3
incq %r14
jmp 0x9168
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x42d0
movq 0x38(%rbx), %rdi
callq 0x4190
movq 0x48(%rbx), %rdi
callq 0x4190
movq 0x40(%rbx), %rdi
callq 0x4190
leaq 0x542b(%rip), %rdi      # 0xe5e0
movq %rbx, %rsi
callq 0x4430
leaq 0x543c(%rip), %rdi      # 0xe600
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x91f0
movq 0x88(%rbx), %rdi
callq *%rax
cmpq $0x0, 0x38(%rbx)
je 0x9222
leaq 0x28(%rbx), %r14
xorl %r15d, %r15d
cmpq %r15, 0x30(%rbx)
jbe 0x9215
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x91d3
incq %r15
jmp 0x91fe
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x44c0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq %r14, 0x60(%rbx)
jbe 0x924e
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rcx
movq 0x8(%rax,%r14,8), %rdi
callq *0x28(%rcx)
addq $0x2, %r14
jmp 0x9232
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x42c0
movb %bl, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4210
movq 0x60(%rax), %rcx
pushq $-0x10
popq %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
jbe 0x9351
movq 0x58(%rax), %rdi
addq $0x2, %rsi
leaq 0x10(%rdx), %r8
cmpq %r14, 0x10(%rdi,%rdx)
movq %r8, %rdx
jne 0x9327
addq %r8, %rdi
movq %rdi, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4ca0(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x111c(%rip), %rsi      # 0xa47e
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4240
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq 0x60(%rdi), %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x93a3
movq (%r14), %rdx
leaq 0x2(%rcx), %rdi
cmpq %rsi, (%rdx,%rcx,8)
movq %rdi, %rcx
jne 0x9388
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rsi, %r15
callq 0x42e0
movq %r14, %rdi
xorl %esi, %esi
callq 0x42e0
movq 0x58(%rbx), %rax
movq 0x60(%rbx), %rcx
leaq (%rax,%rcx,8), %rdi
addq $-0x8, %rdi
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x60(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
jbe 0x93fd
movq 0x58(%rdi), %r8
cmpq %rsi, (%r8,%rdx,8)
je 0x93ef
addq $0x2, %rdx
jmp 0x93da
movl %edx, %eax
shlq $0x3, %rax
orq $0x8, %rax
movq (%r8,%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq %r14, 0x60(%rbx)
jbe 0x9424
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rcx
movq 0x8(%rax,%r14,8), %rdi
callq *0x8(%rcx)
addq $0x2, %r14
jmp 0x9408
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/scene.c
// Function: hpsPostRenderExtensions
void hpsPostRenderExtensions(HPSscene *scene){
    int i;
    for (i = 0; i < scene->extensions.size; i += 2){
        HPSextension *e = (HPSextension *) scene->extensions.data[i];
        e->postRender(scene->extensions.data[i+1]);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq %r14, 0x60(%rbx)
jbe 0x9452
movq 0x58(%rbx), %rax
movq (%rax,%r14,8), %rcx
movq 0x8(%rax,%r14,8), %rdi
callq *0x10(%rcx)
addq $0x2, %r14
jmp 0x9436
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/scene.c
// Function: updateNode
static void updateNode(HPSnode *node, HPSscene *scene){
    int i;
    if (node->needsUpdate){
        if ((HPSscene *) node->parent == scene){
            hpmQuaternionRotation((float *) &node->rotation, node->transform);
            hpmTranslate((float *) &node->position, node->transform);
        } else {
            float trans[16];
            hpmQuaternionRotation((float *) &node->rotation, trans);
            hpmTranslate((float *) &node->position, trans);
            hpmMultMat4(trans, node->parent->transform, node->transform);
        }
        BoundingSphere *bs = node->partitionData.boundingSphere;
        bs->x = 0;
        bs->y = 0;
        bs->z = 0;
        hpmMat4VecMult(node->transform, (float*) bs);
        if (node->extension){
            hpsUpdateExtensionNode(node);
        }
	scene->partitionInterface->updateNode(&node->partitionData);
        for (i = 0; i < node->children.size; i++){
            HPSnode *child = node->children.data[i];
            child->needsUpdate = true;
            updateNode(child, scene);
        }
        node->needsUpdate = false;
    } else {
        for (i = 0; i < node->children.size; i++)
            updateNode(node->children.data[i], scene);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x90(%rdi)
je 0x94d8
cmpq %r14, (%rbx)
je 0x94fa
leaq 0x54(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x4050
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x4060
movq (%rbx), %rax
movq 0x68(%rbx), %rdx
movq 0x68(%rax), %rsi
movq %r15, %rdi
callq 0x4130
jmp 0x9514
xorl %r15d, %r15d
cmpq %r15, 0x30(%rbx)
jbe 0x9579
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x948b
incq %r15
jmp 0x94db
leaq 0x54(%rbx), %rdi
movq 0x68(%rbx), %rsi
callq 0x4050
leaq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rsi
callq 0x4060
leaq 0x8(%rbx), %r15
movq 0x8(%rbx), %rsi
andq $0x0, (%rsi)
andl $0x0, 0x8(%rsi)
movq 0x68(%rbx), %rdi
callq 0x4200
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x9543
movq (%rax), %rcx
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq *0x20(%rcx)
movq 0x28(%r14), %rax
movq %r15, %rdi
callq *0x20(%rax)
xorl %r15d, %r15d
cmpq %r15, 0x30(%rbx)
jbe 0x9572
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
movb $0x1, 0x90(%rdi)
movq %r14, %rsi
callq 0x948b
incq %r15
jmp 0x9550
movb $0x0, 0x90(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/lighting.c
// Function: hpsInitLighting
void hpsInitLighting(void **data){
    if (!initialized){
        hpsInitVector(&lightQueue, 16);
        hpsCurrentLightPositions = malloc(sizeof(float) * hpsMaxLights * 3);
        hpsCurrentLightDirections = malloc(sizeof(float) * hpsMaxLights * 4);
        hpsCurrentLightColors = malloc(sizeof(float) * hpsMaxLights * 3);
        hpsCurrentLightIntensities = malloc(sizeof(float) * hpsMaxLights);
        hpsCurrentAmbientLight = malloc(sizeof(float) * 3);
        initialized = true;
    }
    SceneLighting *sLighting = malloc(sizeof(SceneLighting));
    sLighting->lightPool = hpsMakePool(sizeof(Light), hpsLightPoolSize, "Light pool");
    *data = sLighting;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x5099(%rip)      # 0xe62c
jne 0x961f
leaq 0x5090(%rip), %rdi      # 0xe630
pushq $0x10
popq %rsi
callq 0x4080
movq 0x49e9(%rip), %rax      # 0xdf98
movl (%rax), %r14d
imulq $0xc, %r14, %r15
movq %r15, %rdi
callq 0x42c0
movq 0x49a3(%rip), %rcx      # 0xdf68
movq %rax, (%rcx)
movq %r14, %rdi
shlq $0x4, %rdi
callq 0x42c0
movq 0x499d(%rip), %rcx      # 0xdf78
movq %rax, (%rcx)
movq %r15, %rdi
callq 0x42c0
movq 0x49db(%rip), %rcx      # 0xdfc8
movq %rax, (%rcx)
shlq $0x2, %r14
movq %r14, %rdi
callq 0x42c0
movq 0x49bd(%rip), %rcx      # 0xdfc0
movq %rax, (%rcx)
pushq $0xc
popq %rdi
callq 0x42c0
movq 0x497b(%rip), %rcx      # 0xdf90
movq %rax, (%rcx)
movb $0x1, 0x500d(%rip)      # 0xe62c
pushq $0x18
popq %rdi
callq 0x42c0
movq %rax, %r14
movq 0x499f(%rip), %rax      # 0xdfd0
movl (%rax), %esi
leaq 0xe7a(%rip), %rdx       # 0xa4b4
pushq $0x38
popq %rdi
callq 0x40b0
movq %rax, 0x10(%r14)
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/lighting.c
// Function: hpsLightingPreRender
void hpsLightingPreRender(void *data){
    SceneLighting *sLighting = (SceneLighting *) data;
    hpsCurrentAmbientLight[0] = sLighting->ambient.r;
    hpsCurrentAmbientLight[1] = sLighting->ambient.g;
    hpsCurrentAmbientLight[2] = sLighting->ambient.b;

    currentLights = lightQueue.size;
    currentLights = (currentLights > hpsMaxLights) ? hpsMaxLights : currentLights;
    int i;
    for (i = 0; i < currentLights; i++){
        HPSnode *node = (HPSnode *) lightQueue.data[i];
        Light *l = (Light *) hpsNodeData(node);
        float *bs = hpsNodeBoundingSphere(node);
        hpsCurrentLightIntensities[i] = l->intensity;
        hpsCurrentLightPositions[i*3]   = bs[0];
        hpsCurrentLightPositions[i*3+1] = bs[1];
        hpsCurrentLightPositions[i*3+2] = bs[2];
        hpsCurrentLightColors[i*3]   = l->color.r;
        hpsCurrentLightColors[i*3+1] = l->color.g;
        hpsCurrentLightColors[i*3+2] = l->color.b;
        hpsCurrentLightDirections[i*3]   = l->worldDirection.x;
        hpsCurrentLightDirections[i*3+1] = l->worldDirection.y;
        hpsCurrentLightDirections[i*3+2] = l->worldDirection.z;
        hpsCurrentLightDirections[i*3+3] = l->spotAngle;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss (%rdi), %xmm0
movq 0x4915(%rip), %rax      # 0xdf90
movq (%rax), %rax
movss %xmm0, (%rax)
movss 0x4(%rdi), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x8(%rdi), %xmm0
movss %xmm0, 0x8(%rax)
movl 0x4f9c(%rip), %eax      # 0xe638
movq 0x48f5(%rip), %rcx      # 0xdf98
movl (%rcx), %ecx
cmpl %eax, %ecx
cmovbl %ecx, %eax
movq 0x48ef(%rip), %rcx      # 0xdfa0
movl %eax, (%rcx)
pushq $0x2
popq %r12
xorl %r13d, %r13d
movq 0x4907(%rip), %rbp      # 0xdfc8
movq 0x48b0(%rip), %r15      # 0xdf78
movl %eax, %eax
cmpq %rax, %r13
jae 0x97a7
movq 0x4f56(%rip), %rax      # 0xe630
movq (%rax,%r13,8), %rbx
movq %rbx, %rdi
callq 0x4420
movq %rax, %r14
movq %rbx, %rdi
callq 0x41a0
movss 0x28(%r14), %xmm0
movq 0x48c2(%rip), %rcx      # 0xdfc0
movq (%rcx), %rcx
movss %xmm0, (%rcx,%r13,4)
movss (%rax), %xmm0
movq 0x4856(%rip), %rcx      # 0xdf68
movq (%rcx), %rcx
movss %xmm0, -0x8(%rcx,%r12,4)
movss 0x4(%rax), %xmm0
movss %xmm0, -0x4(%rcx,%r12,4)
movss 0x8(%rax), %xmm0
movss %xmm0, (%rcx,%r12,4)
movss (%r14), %xmm0
movq (%rbp), %rax
movss %xmm0, -0x8(%rax,%r12,4)
movss 0x4(%r14), %xmm0
movss %xmm0, -0x4(%rax,%r12,4)
movss 0x8(%r14), %xmm0
movss %xmm0, (%rax,%r12,4)
movss 0x18(%r14), %xmm0
movq (%r15), %rax
movss %xmm0, -0x8(%rax,%r12,4)
movss 0x1c(%r14), %xmm0
movss %xmm0, -0x4(%rax,%r12,4)
movss 0x20(%r14), %xmm0
movss %xmm0, (%rax,%r12,4)
movss 0x24(%r14), %xmm0
movss %xmm0, 0x4(%rax,%r12,4)
incq %r13
movq 0x4804(%rip), %rax      # 0xdfa0
movl (%rax), %eax
addq $0x3, %r12
jmp 0x96c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/lighting.c
// Function: hpsLightingUpdateNode
void hpsLightingUpdateNode(void *data, HPSnode *node){
    Light *l = (Light *) hpsNodeData(node);
    if (!l->spotAngle) return;

    HPMmat4 *trans = (HPMmat4 *) hpsNodeTransform(node);
    HPMmat4 rot;
    rot._11 = trans->_11;
    rot._12 = trans->_12;
    rot._13 = trans->_13;
    rot._21 = trans->_21;
    rot._22 = trans->_22;
    rot._23 = trans->_23;
    rot._31 = trans->_31;
    rot._32 = trans->_32;
    rot._33 = trans->_33;

    rot._14 = 0;
    rot._24 = 0;
    rot._34 = 0;
    rot._41 = 0;
    rot._42 = 0;
    rot._43 = 0;
    rot._44 = 1;

    l->worldDirection.x = l->direction.x;
    l->worldDirection.y = l->direction.y;
    l->worldDirection.z = l->direction.z;
    hpmMat4VecMult((float *) &rot, (float *) &l->worldDirection);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rsi, %rdi
callq 0x4420
movss 0x24(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x97f0
jnp 0x987a
movq %rax, %rbx
movq %r14, %rdi
callq 0x40e0
movss 0x10(%rax), %xmm0
leaq 0x8(%rsp), %rdi
movss %xmm0, 0x10(%rdi)
movss 0x20(%rax), %xmm0
movss %xmm0, 0x20(%rdi)
movsd (%rax), %xmm0
movsd %xmm0, (%rdi)
movss 0x24(%rax), %xmm0
movss %xmm0, 0x24(%rdi)
movss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rdi)
movsd 0x14(%rax), %xmm0
movsd %xmm0, 0x14(%rdi)
movss 0x28(%rax), %xmm0
movss %xmm0, 0x28(%rdi)
andl $0x0, 0xc(%rdi)
andl $0x0, 0x1c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
movq %rbx, %rsi
addq $0x18, %rsi
movsd 0xc(%rbx), %xmm0
movsd %xmm0, 0x18(%rbx)
movss 0x14(%rbx), %xmm0
movss %xmm0, 0x20(%rbx)
callq 0x4200
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/lighting.c
// Function: hpsAddLight
HPSnode *hpsAddLight(HPSnode *parent, float* color, float i, float *direction, float spotAngle){
    HPSnode *node;
    SceneLighting *sLighting =
        (SceneLighting *) hpsExtensionData(hpsGetScene(parent), &lighting);
    Light *light = hpsAllocateFrom(sLighting->lightPool);
    light->pool = sLighting->lightPool;
    light->color.r = color[0];
    light->color.g = color[1];
    light->color.b = color[2];
    light->intensity = i;
    light->direction.x = direction[0];
    light->direction.y = direction[1];
    light->direction.z = direction[2];
    light->spotAngle = spotAngle;
    node = hpsAddNode(parent, (void *) light, NULL, hpsDeleteLight);
    hpsSetNodeExtension(node, hpsLighting);
    return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movss %xmm1, 0x4(%rsp)
movq %rdx, %r14
movss %xmm0, (%rsp)
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4210
movq 0x46f5(%rip), %rsi      # 0xdfa8
movq %rax, %rdi
callq 0x43d0
movq %rax, %r12
movq 0x10(%rax), %rdi
callq 0x4480
movq 0x10(%r12), %rcx
movq %rcx, 0x30(%rax)
movss (%r15), %xmm0
movss %xmm0, (%rax)
movss 0x4(%r15), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x8(%r15), %xmm0
movss %xmm0, 0x8(%rax)
movss (%rsp), %xmm0
movss %xmm0, 0x28(%rax)
movss (%r14), %xmm0
movss %xmm0, 0xc(%rax)
movss 0x4(%r14), %xmm0
movss %xmm0, 0x10(%rax)
movss 0x8(%r14), %xmm0
movss %xmm0, 0x14(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x24(%rax)
movq 0x46bd(%rip), %rcx      # 0xdfe8
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x44d0
movq %rax, %rbx
movq 0x461e(%rip), %rax      # 0xdf60
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x42a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/lighting.c
// Function: hpsSetLightColor
void hpsSetLightColor(HPSnode *node, float* color){
    Light *l = (Light *) hpsNodeData(node);
    l->color.r = color[0];
    l->color.g = color[1];
    l->color.b = color[2];
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x4420
movss (%rbx), %xmm0
movss %xmm0, (%rax)
movss 0x4(%rbx), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/lighting.c
// Function: hpsSetLightDirection
void hpsSetLightDirection(HPSnode *node, float* dir){
    Light *l = (Light *) hpsNodeData(node);
    l->direction.x = dir[0];
    l->direction.y = dir[1];
    l->direction.z = dir[2];
    hpsNodeNeedsUpdate(node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4420
movss (%rbx), %xmm0
movss %xmm0, 0xc(%rax)
movss 0x4(%rbx), %xmm0
movss %xmm0, 0x10(%rax)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x14(%rax)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4120
// File: /workspace/github_c_makefile_star2_O2/AlexCharlton[P]Hyperscene/src/lighting.c
// Function: hpsSetAmbientLight
void hpsSetAmbientLight(HPSscene *scene, float* color){
    SceneLighting *sLighting = (SceneLighting *) hpsExtensionData(scene, &lighting);
    sLighting->ambient.r = color[0];
    sLighting->ambient.g = color[1];
    sLighting->ambient.b = color[2];
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x4582(%rip), %rsi      # 0xdfa8
callq 0x43d0
movss (%rbx), %xmm0
movss %xmm0, (%rax)
movss 0x4(%rbx), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/scheduler.c
// Function: newNode
node* newNode(int id, pid_t pid, char* name) {
  node* Node = (node*) malloc(sizeof(node));
  Node->id = id;
  Node->pid = pid;
  Node->name = strdup(name);
  return Node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x20
popq %rdi
callq 0x1160
movq %rax, %r15
movl %r14d, (%rax)
movl %ebp, 0x4(%rax)
movq %rbx, %rdi
callq 0x11d0
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/scheduler.c
// Function: addNode
node* addNode(node* list, int id, pid_t pid, char* name) {
  node* head = list;
  if (head == NULL) {
    head = newNode(id, pid, name);
    head->next = head;
    head->prev = head;
  } else {
    while (list->next != head) {
      list = list->next;
    }
    list->next = newNode(id, pid, name);
    list->next->next = head;
    list->next->prev = list;
    head->prev = list->next;
  }
  return head;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x137b
movq %rdi, %rbx
movq %rdi, %rax
movq %rax, %r14
movq 0x10(%rax), %rax
cmpq %rbx, %rax
jne 0x1355
movl %esi, %edi
movl %edx, %esi
movq %rcx, %rdx
callq 0x130c
movq %rax, 0x10(%r14)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
jmp 0x138e
movl %esi, %edi
movl %edx, %esi
movq %rcx, %rdx
callq 0x130c
movq %rax, %rbx
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/scheduler.c
// Function: deleteNode
node* deleteNode(node* list, pid_t pid) {
  node* head = list;
  if (list->pid == pid) {
    list->next->prev = head->prev;
    head->prev->next = list->next;
    head = list->next;
    free(list);
    return head;
  }
  list = list->next;
  while (list != head) {
    if (list->pid == pid) {
      list->prev->next = list->next;
      list->next->prev = list->prev;
      free(list);
      break;
    }
    list = list->next;
  }
  return head;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0x4(%rdi)
jne 0x13f0
movq 0x18(%rbx), %rax
movq %rbx, %rdi
movq 0x10(%rbx), %rbx
movq %rax, 0x18(%rbx)
movq %rbx, 0x10(%rax)
jmp 0x1411
movq %rbx, %rdi
movq 0x10(%rdi), %rdi
cmpq %rbx, %rdi
je 0x1416
cmpl %esi, 0x4(%rdi)
jne 0x13f3
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq %rcx, 0x18(%rax)
callq 0x1050
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/scheduler.c
// Function: accessNode
node* accessNode(node* list, pid_t pid) {
  node* head = list;
  do {
    if (list->pid == pid) {
      return list;
    }
    list = list->next;
  } while (list != head);
  printf("Error: The node with id: %d, doesn't exist!\n", pid);
  return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0x4(%rbx)
je 0x143d
movq 0x10(%rbx), %rbx
cmpq %rdi, %rbx
jne 0x141f
leaq 0xbd4(%rip), %rdi       # 0x2008
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10c0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/aparrish[P]rwet-examples-c/randomize_words.c
// Function: main
int main() {

	UT_array* line_words;
	char* line, * randomized_line;
	int len;

	srand(time(NULL));

	while (!feof(stdin)) {
		len = ap_getline(&line, stdin);

		utarray_new(line_words, &ut_str_icd);

		/* tokenize line, pushing into array */
		char* word;
		word = strtok(line, " \n");
		while (word != NULL) {
			utarray_push_back(line_words, &word);
			word = strtok(NULL, " \n");
		}

		/* shuffle */
		utarray_sort(line_words, shuffle);

		join_new(&randomized_line, line_words, " ");
		printf("%s\n", randomized_line);

		utarray_free(line_words);
		free(randomized_line);
		free(line);

	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %edi, %edi
callq 0x10c0
movl %eax, %edi
callq 0x1080
movq 0x2d61(%rip), %r13      # 0x3fe0
leaq 0xd7e(%rip), %r12       # 0x2004
pushq $0x8
popq %rbp
leaq 0x10(%rsp), %r14
movq (%r13), %rdi
callq 0x10a0
testl %eax, %eax
jne 0x13da
movq (%r13), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1418
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x1090
movq %rax, %r15
movups 0x2afe(%rip), %xmm0     # 0x3dc0
movups %xmm0, 0x18(%rax)
movups 0x2ae3(%rip), %xmm0     # 0x3db0
movups %xmm0, 0x8(%rax)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x10f0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1352
movl (%r15), %eax
movl 0x4(%r15), %ecx
incl %eax
cmpl %ecx, %eax
jbe 0x1324
cmpl %ecx, %eax
jbe 0x1307
testl %ecx, %ecx
leal (%rcx,%rcx), %ecx
cmovel %ebp, %ecx
movl %ecx, 0x4(%r15)
jmp 0x12f5
movq 0x28(%r15), %rdi
movl %ecx, %esi
imulq 0x8(%r15), %rsi
callq 0x10e0
movq %rax, 0x28(%r15)
testq %rax, %rax
je 0x13eb
movq 0x18(%r15), %rax
movq 0x8(%r15), %rdx
movl (%r15), %edi
leal 0x1(%rdi), %ecx
imulq %rdx, %rdi
addq 0x28(%r15), %rdi
movl %ecx, (%r15)
movq %r14, %rsi
testq %rax, %rax
je 0x1349
callq *%rax
jmp 0x134e
callq 0x10b0
xorl %edi, %edi
jmp 0x12d6
movq 0x28(%r15), %rdi
movl (%r15), %esi
movq 0x8(%r15), %rdx
leaq -0x118(%rip), %rcx      # 0x124c
callq 0x1060
movq %rsp, %rdi
movq %r15, %rsi
leaq 0xc91(%rip), %rdx       # 0x2007
callq 0x1784
movq (%rsp), %rdi
callq 0x1050
cmpl $0x0, 0x4(%r15)
je 0x13ba
cmpq $0x0, 0x20(%r15)
je 0x13b1
xorl %ebx, %ebx
movl (%r15), %eax
cmpq %rax, %rbx
jae 0x13b1
movq 0x8(%r15), %rdi
imulq %rbx, %rdi
addq 0x28(%r15), %rdi
callq *0x20(%r15)
incq %rbx
jmp 0x1394
movq 0x28(%r15), %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
jmp 0x128e
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rdi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/labyrinthe.c
// Function: afficher_stats
void afficher_stats(t_lab lab[X][Y], t_fourmi fourmi[]) {
	int nb_ins=nb_insecte();
	int i;
	char male[10] = "male";
	char femelle[10] = "femelle";
	char sexe[10];
	printf("\nIl y a actuellement %i insecte dans le labyrinthe\n", nb_ins);
	for(i=0;i<nb_ins;i++){
		if(fourmi[i].sexe==0){
			strcpy(sexe, male);
		}
		else {
			strcpy(sexe, femelle);
		}
		int nourriture=fourmi[i].nourriture;
		int age = fourmi[i].age;
		int x=fourmi[i].x;
		int y=fourmi[i].y;
		printf("La fourmi %i est de sexe %s à encore pour %i tours de nourriture et %i tours de vie, elle est en x=%i et y=%i.\n", i, sexe, nourriture+1, age+1, x, y);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x2dcc
movl %eax, %r14d
leaq 0x3d5d(%rip), %rdi      # 0x500e
movl %eax, %esi
xorl %eax, %eax
callq 0x10a0
testl %r14d, %r14d
cmovlel %r15d, %r14d
addq $0x10, %rbx
leaq 0x3d76(%rip), %r15      # 0x5042
leaq 0x8(%rsp), %r12
movabsq $0x656c6c656d6566, %rbp # imm = 0x656C6C656D6566
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x132b
cmpl $0x0, -0x10(%rbx)
je 0x12f0
movq %rbp, 0x8(%rsp)
jmp 0x12fd
movb $0x0, 0xc(%rsp)
movl $0x656c616d, 0x8(%rsp)  # imm = 0x656C616D
movl -0xc(%rbx), %ecx
movl -0x8(%rbx), %r8d
movl -0x4(%rbx), %r9d
movl (%rbx), %eax
incl %ecx
incl %r8d
movl %eax, (%rsp)
movq %r15, %rdi
movl %r13d, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10a0
incq %r13
addq $0x14, %rbx
jmp 0x12de
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/labyrinthe.c
// Function: init_lab
void init_lab(t_lab lab[X][Y]){
	int tmp;
	int i,j;
	FILE * fic1;
	fic1 = fopen("../doc/lab_test.txt", "r");

	while(!feof(fic1))
	{
		for(i =0; i<X; i++){
			for(j =0; j<Y; j++){
				fscanf(fic1, "%d ", &tmp);
				lab[i][j].etat = tmp;
				lab[i][j].decouvert = unseen;
			}
		}
	}
	fclose(fic1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x3d3a(%rip), %rdi      # 0x50b3
leaq 0x43d8(%rip), %rsi      # 0x5758
callq 0x1120
movq %rax, %r14
leaq 0x3d38(%rip), %r15      # 0x50c7
leaq 0xc(%rsp), %r12
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
jne 0x13eb
movq 0x10(%rsp), %rbp
xorl %ebx, %ebx
cmpq $0x1e, %rbx
je 0x1394
pushq $0x4
popq %r13
cmpq $0x2d4, %r13            # imm = 0x2D4
je 0x13df
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1060
movl 0xc(%rsp), %eax
movl %eax, (%rbp,%r13)
andl $0x0, -0x4(%rbp,%r13)
addq $0xc, %r13
jmp 0x13b1
incq %rbx
addq $0x2d0, %rbp            # imm = 0x2D0
jmp 0x13a7
movq %r14, %rdi
callq 0x1080
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/labyrinthe.c
// Function: nbr_cases_vide
int nbr_cases_vide(t_lab lab[X][Y]){
	int i, j;
	int nbr_cases_vide = 0;
	for (i=0; i<X; i++){
		for (j=0; j<Y; j++){
			if(lab[i][j].etat == vide){
				nbr_cases_vide++;
			}
		}
	}
	return nbr_cases_vide;
}

// Assembly:
xorl %ecx, %ecx
pushq $0x4
popq %rdx
xorl %eax, %eax
cmpq $0x1e, %rcx
je 0x143b
movq %rdx, %rsi
cmpq $0x2d4, %rsi            # imm = 0x2D4
je 0x142f
xorl %r8d, %r8d
cmpl $0x20, (%rdi,%rsi)
sete %r8b
addl %r8d, %eax
addq $0xc, %rsi
jmp 0x1412
incq %rcx
addq $0x2d0, %rdi            # imm = 0x2D0
jmp 0x1409
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/labyrinthe.c
// Function: lissage_lab
int lissage_lab(t_lab lab[X][Y]){
	int i, j;
	int mur_adj=0;
	int a_lisse=0;
	for (i=0; i<X; i++){
		for (j=0; j<Y; j++){
			if(lab[i][j].etat == mur){
				mur_adj=0;

				if(lab[i][j-1].etat == vide){
					mur_adj++;
				}
				if(lab[i][j+1].etat == vide){
					mur_adj++;
				}
				if(lab[i-1][j].etat == vide){
					mur_adj++;
				}
				if(lab[i+1][j].etat == vide){
					mur_adj++;
				}
				if(mur_adj >= 3 ){
					lab[i][j].etat = vide;
					a_lisse=1;
				}

			}
		}
	}
	return a_lisse;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %ecx, %ecx
leaq 0x2d0(%rdi), %rdx
movl $0x1, %esi
xorl %eax, %eax
cmpq $0x1e, %rcx
je 0x14ed
imulq $0x2d0, %rcx, %r8       # imm = 0x2D0
leaq (%rdi,%r8), %r9
addq $-0x2d0, %r9            # imm = 0xFD30
leaq (%rdx,%r8), %r10
addq %rdi, %r8
xorl %r11d, %r11d
cmpq $0x3c, %r11
je 0x14e5
imulq $0xc, %r11, %rbx
cmpl $0x23, 0x4(%rbx,%r8)
jne 0x14e0
xorl %r14d, %r14d
cmpl $0x20, -0x8(%rbx,%r8)
sete %r14b
incq %r11
leal 0x1(%r14), %ebp
cmpl $0x20, 0x10(%rbx,%r8)
cmovnel %r14d, %ebp
xorl %r14d, %r14d
cmpl $0x20, 0x4(%r9,%rbx)
sete %r14b
xorl %r15d, %r15d
cmpl $0x20, 0x4(%r10,%rbx)
sete %r15b
addl %r14d, %r15d
addl %ebp, %r15d
cmpl $0x3, %r15d
jb 0x1478
leaq (%rbx,%r8), %rax
addq $0x4, %rax
movl $0x20, (%rax)
movl %esi, %eax
jmp 0x1478
incq %r11
jmp 0x1478
incq %rcx
jmp 0x1452
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/labyrinthe.c
// Function: gene_nour
void gene_nour(t_lab lab[X][Y]) {
	int nombrex, nombrey;
	srand(time(NULL));
	int i, nb_nourr=10;
	for(i=0; i<nb_nourr; i++) {
		nombrex = rand()%X;
		nombrey = rand()%Y;
		while(lab[nombrex][nombrey].etat!=vide || !coord_correctes(nombrex, nombrey)){
			nombrex = rand()%X;
			nombrey = rand()%Y;
		}
		lab[nombrex][nombrey].etat=food;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10d0
pushq $0x1e
popq %r15
pushq $0x3c
popq %r12
cmpl $0xa, %r14d
je 0x1a48
callq 0x1170
movl %eax, %ebp
callq 0x1170
movl %eax, %esi
movl %ebp, %eax
cltd
idivl %r15d
movl %edx, %ecx
movl %esi, %eax
cltd
idivl %r12d
movslq %ecx, %rax
movslq %edx, %rsi
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %rbx, %rax
imulq $0xc, %rsi, %rsi
cmpl $0x20, 0x4(%rsi,%rax)
jne 0x19e9
addl $-0x1d, %ecx
cmpl $-0x1c, %ecx
setb %cl
addl $-0x3b, %edx
cmpl $-0x3a, %edx
setb %dl
orb %cl, %dl
jne 0x19e9
addq %rsi, %rax
addq $0x4, %rax
movl $0x2a, (%rax)
incl %r14d
jmp 0x19e3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/labyrinthe.c
// Function: decouvrir_lab
void decouvrir_lab(t_lab lab[X][Y]) {
	int i, j;
	for(i=0; i<X; i++) {
		for(j=0; j<Y; j++) {
			lab[i][j].decouvert=seen;
		}
	}
}

// Assembly:
xorl %eax, %eax
cmpq $0x1e, %rax
je 0x1a7d
xorl %ecx, %ecx
cmpq $0x2d0, %rcx            # imm = 0x2D0
je 0x1a71
movl $0x1, (%rdi,%rcx)
addq $0xc, %rcx
jmp 0x1a5b
incq %rax
addq $0x2d0, %rdi            # imm = 0x2D0
jmp 0x1a53
retq
nop
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/./main.c
// Function: verif_victoire
int verif_victoire (t_lab lab[X][Y]) {
	int i, j;
	int victoire = 1;
	int defaite = 1;
	for(i=0;i<X;i++) {
	for(j=0;j<Y;j++) {
	  if(victoire && lab[i][j].decouvert==unseen && lab[i][j].etat!=mur){
		victoire=0;
	  }
	  if(defaite && lab[i][j].etat==insecte){
		defaite=0;
	  }
	  if(!defaite && !victoire)
		return 0;
	}
	}
	if(victoire)
	return 1;
	else if(defaite)
	return 2;
	else
	return 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl $0x1, %eax
xorl %ecx, %ecx
movabsq $0x4, %rdx
movl %eax, %esi
movl %eax, %r8d
cmpq $0x1e, %rcx
je 0x1b0d
movq %rdx, %r10
leaq 0xc(%r10), %r9
cmpq $0x2e0, %r9             # imm = 0x2E0
je 0x1afc
xorl %r11d, %r11d
testl %esi, %esi
je 0x1ad2
movb $0x1, %bl
cmpl $0x0, -0x4(%rdi,%r10)
movl %eax, %esi
jne 0x1ad6
xorl %ebx, %ebx
cmpl $0x23, (%rdi,%r10)
sete %bl
movl %ebx, %esi
jmp 0x1ad6
xorl %ebx, %ebx
xorl %esi, %esi
testl %r8d, %r8d
je 0x1aec
xorl %r8d, %r8d
cmpl $0x25, (%rdi,%r10)
setne %r8b
movl %r8d, %r11d
jmp 0x1aef
xorl %r8d, %r8d
orb %r8b, %bl
movq %r9, %r10
movl %r11d, %r8d
jne 0x1aa4
jmp 0x1b08
incq %rcx
addq $0x2d0, %rdi            # imm = 0x2D0
jmp 0x1a9b
xorl %eax, %eax
popq %rbx
popq %rbp
retq
testl %esi, %esi
je 0x1b18
movl $0x1, %eax
jmp 0x1b0a
xorl %eax, %eax
testl %r8d, %r8d
sete %al
leal 0x2(,%rax,2), %eax
jmp 0x1b0a
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/./main.c
// Function: regles
int regles() {
	printf("\n Les règles sont les suivantes :\n\n");
	printf("A chaque tour vous pouvez choisir de :\n");
	printf("- Placer soit 0 ou 1 insecte (géré aléatoirement)\n");
	printf("- Placer entre 1 et 3 de nourriture (géré aléatoirement)\n\n");
	printf("Vous gagnez si vous découvrez tout le labyrinthe.\n");
	printf("Vous perdez si tout vos insectes sont morts.\n");
	printf("Vous avez un certain nombre de tour de réserve de nourriture, il en va de même pour la durée de vie.\n");
	printf("Deux insectes sur des cases adjacentes se battent ou se reproduisent.\n");
	printf("Lorsqu'ils vont mourrir de faim, les insectes devienent vert.\n");
	printf("Ils deviennent rouge lorsqu'ils vont mourir de vieillesse\n");
	printf("Ils devienent noirs lorsqu'ils meurent au prochain tour.\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x369c(%rip), %rdi      # 0x51d0
callq 0x1070
leaq 0x36b4(%rip), %rdi      # 0x51f4
callq 0x1070
leaq 0x36cf(%rip), %rdi      # 0x521b
callq 0x1070
leaq 0x36f8(%rip), %rdi      # 0x5250
callq 0x1070
leaq 0x3729(%rip), %rdi      # 0x528d
callq 0x1070
leaq 0x3750(%rip), %rdi      # 0x52c0
callq 0x1070
leaq 0x3771(%rip), %rdi      # 0x52ed
callq 0x1070
leaq 0x37cd(%rip), %rdi      # 0x5355
callq 0x1070
leaq 0x3807(%rip), %rdi      # 0x539b
callq 0x1070
leaq 0x3839(%rip), %rdi      # 0x53d9
callq 0x1070
leaq 0x3867(%rip), %rdi      # 0x5413
callq 0x1070
xorl %eax, %eax
popq %rbp
retq