LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0x50c9(%rip)      # 0x1367c
jne 0xe674
leaq 0x50c0(%rip), %rdi      # 0x13680
movl $0x10, %esi
callq 0x4090
movq 0x49c7(%rip), %rax      # 0x12f98
movl (%rax), %eax
shlq $0x2, %rax
imulq $0x3, %rax, %rdi
callq 0x4300
movq %rax, %rcx
movq 0x497e(%rip), %rax      # 0x12f68
movq %rcx, (%rax)
movq 0x49a4(%rip), %rax      # 0x12f98
movl (%rax), %eax
movl %eax, %edi
shlq $0x2, %rdi
shlq $0x2, %rdi
callq 0x4300
movq %rax, %rcx
movq 0x4969(%rip), %rax      # 0x12f78
movq %rcx, (%rax)
movq 0x497f(%rip), %rax      # 0x12f98
movl (%rax), %eax
shlq $0x2, %rax
imulq $0x3, %rax, %rdi
callq 0x4300
movq %rax, %rcx
movq 0x4996(%rip), %rax      # 0x12fc8
movq %rcx, (%rax)
movq 0x495c(%rip), %rax      # 0x12f98
movl (%rax), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x4300
movq %rax, %rcx
movq 0x496d(%rip), %rax      # 0x12fc0
movq %rcx, (%rax)
movl $0xc, %edi
callq 0x4300
movq %rax, %rcx
movq 0x4926(%rip), %rax      # 0x12f90
movq %rcx, (%rax)
movb $0x1, 0x5008(%rip)      # 0x1367c
movl $0x18, %edi
callq 0x4300
movq %rax, -0x10(%rbp)
movq 0x4947(%rip), %rax      # 0x12fd0
movl (%rax), %eax
movl %eax, %esi
movl $0x38, %edi
leaq 0xda7(%rip), %rdx       # 0xf440
callq 0x40c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movss 0x24(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xe9e5
jp 0xe9e5
jmp 0xeaf3
movq -0x10(%rbp), %rdi
callq 0x40f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x60(%rbp)
movq -0x20(%rbp), %rax
movss 0x10(%rax), %xmm0
movss %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x5c(%rbp)
movq -0x20(%rbp), %rax
movss 0x14(%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movss 0x24(%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x58(%rbp)
movq -0x20(%rbp), %rax
movss 0x18(%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movss 0x28(%rax), %xmm0
movss %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x54(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movss 0x589(%rip), %xmm0      # 0xf030
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x20(%rax)
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x60(%rbp), %rdi
callq 0x4220
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movss %xmm1, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4250
movq %rax, %rdi
movq 0x4447(%rip), %rsi      # 0x12fa8
callq 0x4420
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4510
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x14(%rbp), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x24(%rbp), %xmm0
movq -0x40(%rbp), %rax
movss %xmm0, 0x24(%rax)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq 0x43c5(%rip), %rcx      # 0x12fe8
callq 0x4570
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq 0x4329(%rip), %rax      # 0x12f60
movq (%rax), %rsi
callq 0x42e0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rdi
callq 0x4130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x412d(%rip), %rsi      # 0x12fa8
callq 0x4420
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x20, %edi
callq 0x1160
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x11c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13b2
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1300
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x141a
jmp 0x13b4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
je 0x13d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13b4
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1300
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/scheduler.c
// Function: printList
void printList(node* list) {
  node* head = list;
  printf("%d ", list->id);
  while (list->next != head) {
    list = list->next;
    printf("%d ", list->id);
  }
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0xbb3(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x1488
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0xb85(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x10a0
jmp 0x1458
leaq 0xba4(%rip), %rdi       # 0x2033
movb $0x0, %al
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x150a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1575
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x156d
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x155f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x1050
jmp 0x156d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1516
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x15ad
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15dc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x1597
movl -0x14(%rbp), %esi
leaq 0xa3b(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x10a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/scheduler.c
// Function: install_signal_handlers
static void install_signal_handlers(void) {
  sigset_t sigset;
  struct sigaction sa;

  sa.sa_handler = sigchld_handler;
  sa.sa_flags = SA_RESTART;
  sigemptyset(&sigset);
  sigaddset(&sigset, SIGCHLD);
  sigaddset(&sigset, SIGALRM);
  sa.sa_mask = sigset;
  if (sigaction(SIGCHLD, &sa, NULL) < 0) {
    perror("sigaction: sigchld");
    exit(1);
  }

  sa.sa_handler = sigalrm_handler;
  if (sigaction(SIGALRM, &sa, NULL) < 0) {
    perror("sigaction: sigalrm");
    exit(1);
  }

  /*
  * Ignore SIGPIPE, so that write()s to pipes
  * with no reader do not result in us being killed,
  * and write() returns EPIPE instead.
  */
  if (signal(SIGPIPE, SIG_IGN) < 0) {
    perror("signal: sigpipe");
    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
leaq 0xfe(%rip), %rax        # 0x18b0
movq %rax, -0x118(%rbp)
movl $0x10000000, -0x90(%rbp) # imm = 0x10000000
leaq -0x80(%rbp), %rdi
callq 0x1110
leaq -0x80(%rbp), %rdi
movl $0x11, %esi
callq 0x11e0
leaq -0x80(%rbp), %rdi
movl $0xe, %esi
callq 0x11e0
leaq -0x118(%rbp), %rdi
addq $0x8, %rdi
leaq -0x80(%rbp), %rsi
movl $0x80, %edx
callq 0x1120
movl $0x11, %edi
leaq -0x118(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1060
cmpl $0x0, %eax
jge 0x1831
leaq 0x866(%rip), %rdi       # 0x2088
callq 0x1190
movl $0x1, %edi
callq 0x11b0
leaq 0x2a8(%rip), %rax       # 0x1ae0
movq %rax, -0x118(%rbp)
movl $0xe, %edi
leaq -0x118(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1060
cmpl $0x0, %eax
jge 0x186f
leaq 0x83b(%rip), %rdi       # 0x209b
callq 0x1190
movl $0x1, %edi
callq 0x11b0
movl $0xd, %edi
movl $0x1, %esi
callq 0x10f0
cmpq $0x0, %rax
jae 0x189a
leaq 0x823(%rip), %rdi       # 0x20ae
callq 0x1190
movl $0x1, %edi
callq 0x11b0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x4590
movl %eax, -0x14(%rbp)
movq 0x7d73(%rip), %rax      # 0x9004
movq %rax, -0x22(%rbp)
movw 0x7d70(%rip), %ax       # 0x900c
movw %ax, -0x1a(%rbp)
movq 0x7d67(%rip), %rax      # 0x900e
movq %rax, -0x2c(%rbp)
movw 0x7d64(%rip), %ax       # 0x9016
movw %ax, -0x24(%rbp)
movl -0x14(%rbp), %esi
leaq 0x7d58(%rip), %rdi      # 0x9018
movb $0x0, %al
callq 0x1080
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1399
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x12fd
leaq -0x36(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x1040
jmp 0x130a
leaq -0x36(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x1040
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x18(%rbp), %esi
leaq -0x36(%rbp), %rdx
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movl -0x40(%rbp), %r8d
addl $0x1, %r8d
movl -0x44(%rbp), %r9d
movl -0x48(%rbp), %eax
leaq 0x7ccb(%rip), %rdi      # 0x904c
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1080
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x12ce
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7caa(%rip), %rdi      # 0x90bd
leaq 0x8374(%rip), %rsi      # 0x978e
callq 0x1100
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x143d
jmp 0x14d7
movl $0x0, -0x10(%rbp)
cmpl $0x1e, -0x10(%rbp)
jge 0x14d2
movl $0x0, -0x14(%rbp)
cmpl $0x3c, -0x14(%rbp)
jge 0x14c2
movq -0x20(%rbp), %rdi
leaq 0x7c6b(%rip), %rsi      # 0x90d1
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rdx
imulq $0x2d0, %rdx, %rdx      # imm = 0x2D0
addq %rdx, %rax
movslq -0x14(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1455
jmp 0x14c4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1444
jmp 0x1423
movq -0x20(%rbp), %rdi
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
jge 0x155f
movl $0x0, -0x10(%rbp)
cmpl $0x3c, -0x10(%rbp)
jge 0x1552
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x20, 0x4(%rax)
jne 0x1545
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1547
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1513
jmp 0x1554
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1506
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
jge 0x16ed
movl $0x0, -0x10(%rbp)
cmpl $0x3c, -0x10(%rbp)
jge 0x16dd
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x23, 0x4(%rax)
jne 0x16cd
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x20, 0x4(%rax)
jne 0x1607
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x20, 0x4(%rax)
jne 0x1638
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x20, 0x4(%rax)
jne 0x1669
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x20, 0x4(%rax)
jne 0x169a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jl 0x16cb
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x20, 0x4(%rax)
movl $0x1, -0x18(%rbp)
jmp 0x16cd
jmp 0x16cf
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x159e
jmp 0x16df
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x158d
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10a0
movl $0xa, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2181
callq 0x1150
movl $0x1e, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
callq 0x1150
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %rax, %rcx
movslq -0x10(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x20, 0x4(%rcx)
movb %al, -0x19(%rbp)
jne 0x2124
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x13c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x212d
jmp 0x214f
callq 0x1150
movl $0x1e, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
callq 0x1150
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
jmp 0x20e6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x2a, 0x4(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x20ba
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
jge 0x21ed
movl $0x0, -0x10(%rbp)
cmpl $0x3c, -0x10(%rbp)
jge 0x21e0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x21ac
jmp 0x21e2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x219f
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1e, -0x14(%rbp)
jge 0x22df
movl $0x0, -0x18(%rbp)
cmpl $0x3c, -0x18(%rbp)
jge 0x22cf
cmpl $0x0, -0x1c(%rbp)
je 0x227a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x227a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x23, 0x4(%rax)
je 0x227a
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x22aa
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x25, 0x4(%rax)
jne 0x22aa
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x22bf
cmpl $0x0, -0x1c(%rbp)
jne 0x22bf
movl $0x0, -0x4(%rbp)
jmp 0x2304
jmp 0x22c1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x221e
jmp 0x22d1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x220d
cmpl $0x0, -0x1c(%rbp)
je 0x22ee
movl $0x1, -0x4(%rbp)
jmp 0x2304
cmpl $0x0, -0x20(%rbp)
je 0x22fd
movl $0x2, -0x4(%rbp)
jmp 0x2304
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x6eb1(%rip), %rdi      # 0x91cc
movb $0x0, %al
callq 0x1080
leaq 0x6ec8(%rip), %rdi      # 0x91f1
movb $0x0, %al
callq 0x1080
leaq 0x6ee2(%rip), %rdi      # 0x9219
movb $0x0, %al
callq 0x1080
leaq 0x6f0a(%rip), %rdi      # 0x924f
movb $0x0, %al
callq 0x1080
leaq 0x6f3a(%rip), %rdi      # 0x928d
movb $0x0, %al
callq 0x1080
leaq 0x6f60(%rip), %rdi      # 0x92c1
movb $0x0, %al
callq 0x1080
leaq 0x6f80(%rip), %rdi      # 0x92ef
movb $0x0, %al
callq 0x1080
leaq 0x6fdb(%rip), %rdi      # 0x9358
movb $0x0, %al
callq 0x1080
leaq 0x7014(%rip), %rdi      # 0x939f
movb $0x0, %al
callq 0x1080
leaq 0x7045(%rip), %rdi      # 0x93de
movb $0x0, %al
callq 0x1080
leaq 0x7072(%rip), %rdi      # 0x9419
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/./main.c
// Function: main
int main() {
	int choix;
	// Affichage du menu
	do {
	printf("\nMenu : \n");
	printf(" 1 - Voir les règles du jeu\n");
	printf(" 2 - Lancer la partie\n");
	printf(" 3 - Quitter\n");
	printf("Votre choix : ");
	scanf("%d", &choix);

	switch(choix) {
	  case 1 : regles() ; break;
	  case 2 : { 	lancement();
								//Réinitialisation des paramètres
								chang_nb_ins(0);
								break;
							}
	  case 3 : break;
	  default : printf("\nErreur de saisie\n\n"); break;

	}
	}
	while(choix!=3);
	printf("Au revoir !\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x6e9f(%rip), %rdi      # 0x9495
xorl %eax, %eax
movb %al, -0xd(%rbp)
callq 0x1080
movb -0xd(%rbp), %al
leaq 0x6e95(%rip), %rdi      # 0x949f
callq 0x1080
movb -0xd(%rbp), %al
leaq 0x6ea4(%rip), %rdi      # 0x94bd
callq 0x1080
movb -0xd(%rbp), %al
leaq 0x6eac(%rip), %rdi      # 0x94d4
callq 0x1080
movb -0xd(%rbp), %al
leaq 0x6eab(%rip), %rdi      # 0x94e2
callq 0x1080
movb -0xd(%rbp), %al
leaq 0x6eab(%rip), %rdi      # 0x94f1
leaq -0x8(%rbp), %rsi
callq 0x1110
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x2670
jmp 0x265c
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x2677
jmp 0x2666
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x2685
jmp 0x2687
callq 0x2310
jmp 0x2695
callq 0x23c0
xorl %edi, %edi
callq 0x45a0
jmp 0x2695
jmp 0x2695
leaq 0x6e66(%rip), %rdi      # 0x94f4
movb $0x0, %al
callq 0x1080
jmp 0x2697
cmpl $0x3, -0x8(%rbp)
jne 0x25ef
leaq 0x6e60(%rip), %rdi      # 0x9508
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/fonctions/utilisateur.c
// Function: ajout_nourriture
int ajout_nourriture (t_lab lab[X][Y]) {
  int a, b, i;
  srand(time(NULL));
  int nombre = rand()%3 + 1;
  printf("Vous avez le droit à %i cases de nourriture\n", nombre);
  for(i=0;i<nombre;i++) {
    printf("Entrez les coordonnées x et y de la nourriture %i séparées par un espace (doit être découvert) : ", i+1);
    scanf("%i%i", &a, &b);
    while(a<=0 || a>=X || b<=0 || b>=Y || lab[a][b].etat!=vide || lab[a][b].decouvert!=seen){
      printf("Erreur, shame, recommencez\n");
      printf("Entrez les coordonnées x et y de la nourriture %i séparées par un espace : ", i+1);
      scanf("%i%i", &a, &b);
    }
    lab[a][b].etat=food;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10a0
callq 0x1150
movl $0x3, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %esi
leaq 0x6e1c(%rip), %rdi      # 0x9515
movb $0x0, %al
callq 0x1080
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x282f
movl -0x14(%rbp), %esi
addl $0x1, %esi
leaq 0x6e23(%rip), %rdi      # 0x9543
movb $0x0, %al
callq 0x1080
leaq 0x6e7c(%rip), %rdi      # 0x95aa
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x1110
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
jle 0x27b7
movb $0x1, %al
cmpl $0x1e, -0xc(%rbp)
movb %al, -0x19(%rbp)
jge 0x27b7
movb $0x1, %al
cmpl $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
jle 0x27b7
movb $0x1, %al
cmpl $0x3c, -0x10(%rbp)
movb %al, -0x19(%rbp)
jge 0x27b7
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %rax, %rcx
movslq -0x10(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x20, 0x4(%rcx)
movb %al, -0x19(%rbp)
jne 0x27b7
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x27c0
jmp 0x27fd
leaq 0x6de8(%rip), %rdi      # 0x95af
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %esi
addl $0x1, %esi
leaq 0x6df0(%rip), %rdi      # 0x95cb
movb $0x0, %al
callq 0x1080
leaq 0x6dc1(%rip), %rdi      # 0x95aa
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x1110
jmp 0x273d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x2a, 0x4(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2707
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/fonctions/utilisateur.c
// Function: sauver_lab
void sauver_lab(t_lab lab[X][Y], t_fourmi fourmi[]){
	FILE * fic1;
	int tmp;
	int seen;
	int i,j;
	fic1 = fopen("SAVED_GAME", "w");
	for(i =0; i<X; i++){
		for(j =0; j<Y; j++){
			tmp = lab[i][j].etat;
			seen = lab[i][j].decouvert;
			fprintf(fic1, "%c", tmp);
			fprintf(fic1, "%d", seen);
		}
	}
	int nb_ins = nb_insecte();
	fprintf(fic1, "%d ", nb_ins);
	/*for(i=0; i<nb_ins; i++){
		fprintf(fic1, "%d ", fourmi[i].sexe);
		fprintf(fic1, "%d ", fourmi[i].nourriture);
		fprintf(fic1, "%d ", fourmi[i].age);
		fprintf(fic1, "%d ", fourmi[i].x);
		fprintf(fic1, "%d ", fourmi[i].y);
	}*/

	fclose(fic1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x6dc3(%rip), %rdi      # 0x961a
leaq 0x6dc7(%rip), %rsi      # 0x9625
callq 0x1100
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x1e, -0x24(%rbp)
jge 0x290f
movl $0x0, -0x28(%rbp)
cmpl $0x3c, -0x28(%rbp)
jge 0x28ff
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x6e6e(%rip), %rsi      # 0x9746
movb $0x0, %al
callq 0x10b0
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %edx
leaq 0x6c04(%rip), %rsi      # 0x94f1
movb $0x0, %al
callq 0x10b0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x287f
jmp 0x2901
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x286e
movb $0x0, %al
callq 0x4590
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0x67aa(%rip), %rsi      # 0x90d1
movb $0x0, %al
callq 0x10b0
movq -0x18(%rbp), %rdi
callq 0x1060
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/fonctions/deplacement.c
// Function: insecte_adjacent
int insecte_adjacent(int px, int py, t_lab lab[X][Y], int bouffe, int dureevie, t_fourmi fourmi[]) {
	if (lab[px-1][py].etat == insecte) {
		combat(px, py, px-1, py, bouffe, dureevie, lab, fourmi);
	} else if (lab[px][py-1].etat == insecte) {
	   combat(px, py, px, py-1, bouffe, dureevie, lab, fourmi);
	} else if (lab[px][py+1].etat == insecte) {
	   combat(px, py, px, py+1, bouffe, dureevie, lab, fourmi);
	} else if (lab[px+1][py].etat == insecte){
		combat(px, py, px+1, py, bouffe, dureevie, lab, fourmi);
	}
	else {
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x25, 0x4(%rax)
jne 0x34d7
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
subl $0x1, %edx
movl -0xc(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
movq -0x18(%rbp), %r10
movq -0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2db0
jmp 0x35ee
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x25, 0x4(%rax)
jne 0x3531
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
movq -0x18(%rbp), %r10
movq -0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2db0
jmp 0x35ec
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x25, 0x4(%rax)
jne 0x3588
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
movq -0x18(%rbp), %r10
movq -0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2db0
jmp 0x35ea
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x25, 0x4(%rax)
jne 0x35df
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
addl $0x1, %edx
movl -0xc(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
movq -0x18(%rbp), %r10
movq -0x28(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2db0
jmp 0x35e8
movl $0x0, -0x4(%rbp)
jmp 0x35f5
jmp 0x35ea
jmp 0x35ec
jmp 0x35ee
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/fonctions/deplacement.c
// Function: nourriture_pres
int nourriture_pres(t_lab lab[X][Y]){
	int i, j;
	for(i=0; i<X; i++) {
		for(j=0; j<Y; j++) {
			if(lab[i][j].etat==food)
				return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1e, -0x14(%rbp)
jge 0x3a28
movl $0x0, -0x18(%rbp)
cmpl $0x3c, -0x18(%rbp)
jge 0x3a1b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2a, 0x4(%rax)
jne 0x3a0e
movl $0x1, -0x4(%rbp)
jmp 0x3a2f
jmp 0x3a10
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x39dc
jmp 0x3a1d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x39cf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/fonctions/deplacement.c
// Function: matrice
void matrice (int matr_dist[X][Y]){
	int i,j;
	for(i = 0; i<X; i++){			//affichage de la matrice de distance
		for(j = 0; j<Y; j++){
			if(matr_dist[i][j] >9 || matr_dist[i][j] <0){
				printf(" %c", (matr_dist[i][j])+48);
			}
			else{
				printf(" %c", (matr_dist[i][j])+48);
			}
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
jge 0x4588
movl $0x0, -0x10(%rbp)
cmpl $0x3c, -0x10(%rbp)
jge 0x456c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpl $0x9, (%rax,%rcx,4)
jg 0x4506
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0x4532
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
addl $0x30, %esi
leaq 0x521c(%rip), %rdi      # 0x9745
movb $0x0, %al
callq 0x1080
jmp 0x455c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xf0, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
addl $0x30, %esi
leaq 0x51f0(%rip), %rdi      # 0x9745
movb $0x0, %al
callq 0x1080
jmp 0x455e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x44c4
leaq 0x4d18(%rip), %rdi      # 0x928b
movb $0x0, %al
callq 0x1080
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44b3
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/fonctions/insecte.c
// Function: gene_ins_deb
void gene_ins_deb(int bouffe, int dureevie, t_lab lab[X][Y], t_fourmi fourmi[]) {
	int i;
	int nbr_ins_deb = 5;
	srand(time(NULL));
	int sexemaj = rand()%2+1;
	int sexe;
	for(i=0;i<nbr_ins_deb;i++) {
		int nombrex, nombrey, sexe;
		nombrex = rand()%X;
		nombrey = rand()%Y;
		while(lab[nombrex][nombrey].etat!=vide){
			nombrex = rand()%X;
			nombrey = rand()%Y;
		}
		if(i%2==1){ //Sexe des insectes impairs (donc sexe minoritaire)
			if(sexemaj==1)
				sexe=2;
			else if(sexemaj==2)
				sexe=1;
		}
		else { // Sexe des insectes pairs (donc sexe majoritaire)
			sexe=sexemaj;
		}
		gene_ins(bouffe, dureevie, lab, nombrex, nombrey, fourmi, sexe);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x5, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10a0
callq 0x1150
movl $0x2, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x48dc
callq 0x1150
movl $0x1e, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
callq 0x1150
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x20, 0x4(%rax)
je 0x4878
callq 0x1150
movl $0x1e, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
callq 0x1150
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x30(%rbp)
jmp 0x4833
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x48a8
cmpl $0x1, -0x24(%rbp)
jne 0x4897
movl $0x2, -0x34(%rbp)
jmp 0x48a6
cmpl $0x2, -0x24(%rbp)
jne 0x48a4
movl $0x1, -0x34(%rbp)
jmp 0x48a6
jmp 0x48ae
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movq -0x18(%rbp), %r9
movl -0x34(%rbp), %eax
movl %eax, (%rsp)
callq 0x45c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4807
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/fonctions/insecte.c
// Function: bebe
void bebe(int bouffe, int dureevie, t_lab lab[X][Y], t_fourmi fourmi[]) {
	srand(time(NULL));
	int nombrex, nombrey;
	nombrex = rand()%X;
	nombrey = rand()%Y;
	while(lab[nombrex][nombrey].etat!=vide && lab[nombrex][nombrey].decouvert!=seen){
		nombrex = rand()%X;
		nombrey = rand()%Y;
	}
	gene_ins(bouffe, dureevie, lab, nombrex, nombrey, fourmi, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10a0
callq 0x1150
movl $0x1e, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
callq 0x1150
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rax
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %rax, %rcx
movslq -0x20(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl $0x20, 0x4(%rcx)
movb %al, -0x21(%rbp)
je 0x4984
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x498d
jmp 0x49af
callq 0x1150
movl $0x1e, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
callq 0x1150
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, -0x20(%rbp)
jmp 0x4936
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x18(%rbp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x45c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)