LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ecx
xorl %eax, %eax
movl $0x1, %edx
movl $0x4, %esi
xorl %r8d, %r8d
testl %edx, %edx
je 0x1bad
cmpl $0x0, -0x4(%rdi,%rsi)
je 0x1bb4
movl $0x1, %edx
movb $0x1, %r9b
jmp 0x1bc2
xorl %r9d, %r9d
xorl %edx, %edx
jmp 0x1bc2
xorl %r9d, %r9d
cmpl $0x23, (%rdi,%rsi)
sete %r9b
movl %r9d, %edx
testl %ecx, %ecx
je 0x1bd6
xorl %r8d, %r8d
cmpl $0x25, (%rdi,%rsi)
setne %r8b
movl %r8d, %ecx
jmp 0x1bd8
xorl %ecx, %ecx
orb %r8b, %r9b
je 0x1c13
addq $0xc, %rsi
cmpq $0x2d4, %rsi            # imm = 0x2D4
jne 0x1b95
incq %rax
addq $0x2d0, %rdi            # imm = 0x2D0
cmpq $0x1e, %rax
jne 0x1b90
movl $0x1, %eax
testl %edx, %edx
jne 0x1c15
xorl %eax, %eax
testl %ecx, %ecx
sete %al
leal 0x2(,%rax,2), %eax
jmp 0x1c15
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x45ca(%rip), %rdi      # 0x61ec
callq 0x1070
leaq 0x45e2(%rip), %rdi      # 0x6210
callq 0x1070
leaq 0x45fd(%rip), %rdi      # 0x6237
callq 0x1070
leaq 0x4626(%rip), %rdi      # 0x626c
callq 0x1070
leaq 0x4657(%rip), %rdi      # 0x62a9
callq 0x1070
leaq 0x467e(%rip), %rdi      # 0x62dc
callq 0x1070
leaq 0x469f(%rip), %rdi      # 0x6309
callq 0x1070
leaq 0x46fb(%rip), %rdi      # 0x6371
callq 0x1070
leaq 0x4735(%rip), %rdi      # 0x63b7
callq 0x1070
leaq 0x4767(%rip), %rdi      # 0x63f5
callq 0x1070
leaq 0x4795(%rip), %rdi      # 0x642f
callq 0x1070
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/./main.c
// Function: lancement
int lancement() {
	int i, vic, res=5;
	int bouffe=10;
	int dureevie=30;
	int nb_ins;
	int posx;
	int posy;


	init_lab_rand(lab);							//Initialise le labyrinthe

	gene_ins_deb(bouffe, dureevie, lab, fourmi);//Génération des insectes de départ

	gene_nour(lab); 							//Génération de chaque case de nourriture

	decouvrir(lab);								//Cette fonction actualise la découverte du labyrinthe

	afficher_stats(lab, fourmi);
	afficher_lab(lab, fourmi);					//Cette fonction affiche le labyrinthe


	vic=verif_victoire(lab);						//Cette fonction vérifie si on est en situation de victoire (labyrinthe découvert)

	while(vic==0){
		res=action_user(lab, bouffe, dureevie, fourmi);
		if(res==0) return 1;
		nb_ins=nb_insecte();

		for(i=nb_ins-1; i>=0; i--) {					//Cette boucle gère le déplacement des insectes
			posx=fourmi[i].x;
			posy=fourmi[i].y;
			if(posx>=0 && posx<X && posy>=0 && posy<Y && lab[posx][posy].etat==insecte) {
				deplacement(lab, posx, posy, fourmi, bouffe, dureevie);
				decouvrir(lab);
			}
		}
		afficher_stats(lab, fourmi);
		afficher_lab(lab, fourmi);
		vic=verif_victoire(lab);
	}

	if(vic==1)
	printf("Vous avez gagné\n");
	else if(vic==2)
	printf("Vous avez perdu\n");
	else
	printf("Erreur au niveau du lancement\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x943b(%rip), %rbx      # 0xb0f0
movq %rbx, %rdi
callq 0x1539
leaq 0xe88c(%rip), %r14      # 0x10550
movl $0xa, %edi
movl $0x1e, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x310d
movq %rbx, %rdi
callq 0x1a9c
movq %rbx, %rdi
callq 0x2490
movq %rbx, %rdi
movq %r14, %rsi
callq 0x128c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x178f
movq %rbx, %rdi
callq 0x1b80
testl %eax, %eax
jne 0x1dae
movq %rbx, %rdi
movl $0xa, %esi
movl $0x1e, %edx
movq %r14, %rcx
callq 0x226b
testl %eax, %eax
je 0x1dda
xorl %eax, %eax
callq 0x2fac
testl %eax, %eax
jle 0x1ce9
movl %eax, %r15d
leaq (%r15,%r15,4), %rax
incq %r15
leaq (%r14,%rax,4), %r12
addq $-0x4, %r12
movl -0x4(%r12), %esi
movl (%r12), %eax
cmpq $0x1e, %rsi
setb %cl
cmpl $0x3c, %eax
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1d9c
movl %eax, %edx
imulq $0x2d0, %rsi, %rax      # imm = 0x2D0
addq %rbx, %rax
leaq (%rdx,%rdx,2), %rcx
cmpl $0x25, 0x4(%rax,%rcx,4)
jne 0x1d9c
movq %rbx, %rdi
movq %r14, %rcx
movl $0xa, %r8d
movl $0x1e, %r9d
callq 0x2947
movq %rbx, %rdi
callq 0x2490
decq %r15
addq $-0x14, %r12
cmpq $0x1, %r15
ja 0x1d49
jmp 0x1ce9
cmpl $0x1, %eax
je 0x1dc1
cmpl $0x2, %eax
jne 0x1dca
leaq 0x46c7(%rip), %rdi      # 0x6486
jmp 0x1dd1
leaq 0x46ce(%rip), %rdi      # 0x6496
jmp 0x1dd1
leaq 0x4697(%rip), %rdi      # 0x6468
callq 0x1070
xorl %eax, %eax
jmp 0x1ddf
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x46d0(%rip), %r15      # 0x64cd
leaq 0x46df(%rip), %r12      # 0x64e3
leaq 0x43cf(%rip), %r13      # 0x61da
leaq 0x43d7(%rip), %rbx      # 0x61e9
leaq -0x2c(%rbp), %r14
leaq 0x468a(%rip), %rdi      # 0x64a7
callq 0x1070
leaq 0x4687(%rip), %rdi      # 0x64b0
callq 0x1070
movq %r15, %rdi
callq 0x1070
movq %r12, %rdi
callq 0x1070
movq %r13, %rdi
xorl %eax, %eax
callq 0x10a0
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1130
movl -0x2c(%rbp), %eax
cmpl $0x1, %eax
je 0x1e83
cmpl $0x2, %eax
je 0x1e75
cmpl $0x3, %eax
je 0x1e8e
leaq 0x4682(%rip), %rdi      # 0x64f0
callq 0x1070
jmp 0x1e88
callq 0x1ca3
xorl %edi, %edi
callq 0x2fb3
jmp 0x1e88
callq 0x1c17
cmpl $0x3, -0x2c(%rbp)
jne 0x1e16
leaq 0x466e(%rip), %rdi      # 0x6503
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10d0
callq 0x1170
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
movl %eax, %ebx
subl %ecx, %ebx
negl %ecx
leal (%rax,%rcx), %esi
incl %esi
leaq 0x462b(%rip), %rdi      # 0x6528
xorl %eax, %eax
callq 0x10a0
movl %ebx, 0xc(%rsp)
testl %ebx, %ebx
js 0x1fc0
leaq 0x46a6(%rip), %r14      # 0x65bd
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x473a(%rip), %r13      # 0x6662
leaq 0x4693(%rip), %rbx      # 0x65c2
xorl %eax, %eax
movq %rax, 0x18(%rsp)
leal 0x1(%rax), %ebp
leaq 0x4616(%rip), %rdi      # 0x6556
movl %ebp, %esi
xorl %eax, %eax
callq 0x10a0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1130
movl 0x14(%rsp), %eax
leal -0x1e(%rax), %ecx
cmpl $-0x1d, %ecx
setb %dl
movl 0x10(%rsp), %ecx
leal -0x3c(%rcx), %esi
cmpl $-0x3b, %esi
setb %sil
orb %dl, %sil
jne 0x1f9b
movl %ecx, %ecx
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq 0x20(%rsp), %rax
leaq (%rcx,%rcx,2), %rcx
cmpl $0x20, 0x4(%rax,%rcx,4)
jne 0x1f9b
leaq (%rax,%rcx,4), %rax
cmpl $0x1, (%rax)
je 0x1fa8
movq %r13, %rdi
callq 0x1070
movq %rbx, %rdi
jmp 0x1f40
movl $0x2a, 0x4(%rax)
movq 0x18(%rsp), %rax
cmpl 0xc(%rsp), %eax
movl %ebp, %eax
jne 0x1f31
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x462b(%rip), %rdi      # 0x6611
leaq 0x462f(%rip), %rsi      # 0x661c
callq 0x1120
movq %rax, %rbx
leaq 0x41ed(%rip), %r15      # 0x61e9
xorl %r12d, %r12d
movl $0x4, %r13d
movl -0x4(%r14,%r13), %ebp
movl (%r14,%r13), %edi
movq %rbx, %rsi
callq 0x10c0
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
addq $0xc, %r13
cmpq $0x2d4, %r13            # imm = 0x2D4
jne 0x2005
incq %r12
addq $0x2d0, %r14            # imm = 0x2D0
cmpq $0x1e, %r12
jne 0x1fff
xorl %eax, %eax
callq 0x2fac
leaq 0x4093(%rip), %rsi      # 0x60e3
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x10e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/fonctions/utilisateur.c
// Function: action_user
int action_user(t_lab lab[X][Y], int bouffe, int dureevie, t_fourmi fourmi[]){
  int choix, i, j;
  char reponse='\0';
  do {
    printf(" 1 - Ajouter de la nourriture\n");
    printf(" 2 - Ajouter un insecte\n");
    printf(" 3 - Passer\n");
    printf(" 4 - Abandonner la partie\n");
    printf(" 5 - Sauvegarder la partie\n");
    printf(" 6 - Charger la partie\n");
    printf("Votre choix : ");
    scanf("%i%*c", &choix);

    switch(choix) {
		case 1 : ajout_nourriture(lab) ; break;
		case 2 : ajout_insecte(lab, bouffe, dureevie, fourmi) ; break;
		case 3 : break;
		case 4 : {  printf("Souhaitez vous vraiment abandonner la partie ? (y/n) : ");
					scanf("%c%*c", &reponse);
					if(reponse!='y' || reponse!='n') {
						while(reponse!='y' && reponse!='n') {
							printf("Souhaitez vous vraiment abandonner la partie ? (y/n) : ");
							scanf("%c%*c", &reponse);
						}
						if(reponse=='n')
							choix=7;
						}
				 } ; break;
		case 5 :{
					sauver_lab(lab, fourmi);
				}  ; break;
		case 6 :{
					charger_lab(lab, fourmi);
				} ; break;
		case 666 : decouvrir_lab(lab); break;
    default : printf("\nErreur retentez\n\n"); choix=7; break;

    }
  }
  while(choix==7);
  if(choix==4)
    return 0;
  else
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movq %rdi, %r15
leaq 0x3(%rsp), %r12
movb $0x0, (%r12)
leaq 0x4276(%rip), %r13      # 0x6510
leaq 0x4383(%rip), %rbp      # 0x6624
leaq 0x43b4(%rip), %r14      # 0x665c
movl $0x1, %ebx
leaq 0x43e5(%rip), %rdi      # 0x6699
callq 0x1070
leaq 0x43f7(%rip), %rdi      # 0x66b7
callq 0x1070
leaq 0x4403(%rip), %rdi      # 0x66cf
callq 0x1070
leaq 0x4403(%rip), %rdi      # 0x66db
callq 0x1070
leaq 0x4411(%rip), %rdi      # 0x66f5
callq 0x1070
leaq 0x4420(%rip), %rdi      # 0x6710
callq 0x1070
leaq 0x3ede(%rip), %rdi      # 0x61da
xorl %eax, %eax
callq 0x10a0
leaq 0x4314(%rip), %rdi      # 0x661e
leaq 0x4(%rsp), %rsi
xorl %eax, %eax
callq 0x1130
movl 0x4(%rsp), %eax
leal -0x1(%rax), %ecx
cmpl $0x5, %ecx
ja 0x235e
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movq %r15, %rdi
callq 0x1eac
jmp 0x239d
movq %rbp, %rdi
xorl %eax, %eax
callq 0x10a0
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1130
movzbl 0x3(%rsp), %eax
cmpl $0x79, %eax
je 0x239d
cmpl $0x6e, %eax
jne 0x2336
jmp 0x23af
cmpl $0x29a, %eax            # imm = 0x29A
jne 0x23a3
movq %r15, %rdi
callq 0x1b54
jmp 0x239d
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x2072
jmp 0x239d
movq %r15, %rdi
callq 0x1fd1
jmp 0x239d
movq %r15, %rdi
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
callq 0x32d8
movl 0x4(%rsp), %eax
jmp 0x23bc
leaq 0x437d(%rip), %rdi      # 0x6727
callq 0x1070
movl $0x7, 0x4(%rsp)
movl $0x7, %eax
cmpl $0x7, %eax
je 0x22ad
cmpl $0x4, %eax
jne 0x23cc
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/fonctions/deplacement.c
// Function: combat
int combat(int x, int y, int a, int b, int bouffe, int dureevie, t_lab lab[X][Y], t_fourmi fourmi[]) {
	if(fourmi[lab[x][y].insecte].sexe!=fourmi[lab[a][b].insecte].sexe){
		bebe(bouffe, dureevie, lab, fourmi);
		return 1;
	}
	else {
		if(fourmi[lab[x][y].insecte].age<fourmi[lab[a][b].insecte].age)
			delete_insecte(lab, fourmi, x, y);
		else if(fourmi[lab[x][y].insecte].age>fourmi[lab[a][b].insecte].age)
			delete_insecte(lab, fourmi, a, b);
		else if(fourmi[lab[x][y].insecte].age==fourmi[lab[a][b].insecte].age && fourmi[lab[x][y].insecte].nourriture>fourmi[lab[a][b].insecte].nourriture)
			delete_insecte(lab, fourmi, a, b);
		else if(fourmi[lab[x][y].insecte].age==fourmi[lab[a][b].insecte].age && fourmi[lab[x][y].insecte].nourriture<fourmi[lab[a][b].insecte].nourriture)
			delete_insecte(lab, fourmi, x, y);
		else
			delete_insecte(lab, fourmi, x, y);
		return 0;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %r11d
movl %esi, %eax
movl %edi, %ebx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r10
movslq %edi, %rsi
movslq %eax, %rdi
imulq $0x2d0, %rsi, %rsi      # imm = 0x2D0
addq %r10, %rsi
leaq (%rdi,%rdi,2), %rdi
movslq 0x8(%rsi,%rdi,4), %rsi
leaq (%rsi,%rsi,4), %rsi
movl (%rcx,%rsi,4), %ebp
movslq %edx, %rdi
movslq %r11d, %r14
imulq $0x2d0, %rdi, %rdi      # imm = 0x2D0
addq %r10, %rdi
leaq (%r14,%r14,2), %r14
movslq 0x8(%rdi,%r14,4), %rdi
leaq (%rdi,%rdi,4), %rdi
cmpl (%rcx,%rdi,4), %ebp
jne 0x2458
leaq (%rcx,%rsi,4), %rsi
leaq (%rcx,%rdi,4), %rdi
movl 0x8(%rsi), %r8d
movl 0x8(%rdi), %r9d
cmpl %r9d, %r8d
jge 0x246d
movq %r10, %rdi
movq %rcx, %rsi
movl %ebx, %edx
movl %eax, %ecx
jmp 0x2478
movl %r8d, %edi
movl %r9d, %esi
movq %r10, %rdx
callq 0x3218
movl $0x1, %eax
jmp 0x247f
jle 0x2484
movq %r10, %rdi
movq %rcx, %rsi
movl %r11d, %ecx
callq 0x3413
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
jne 0x244c
movl 0x4(%rdi), %edi
cmpl %edi, 0x4(%rsi)
jle 0x244c
jmp 0x246f
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %r9, %r10
movl %r8d, %r9d
movl %ecx, %r8d
movq %rdx, %r11
leal -0x1(%rdi), %edx
movslq %edx, %rax
movslq %esi, %rcx
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %r11, %rax
leaq (%rcx,%rcx,2), %rbx
cmpl $0x25, 0x4(%rax,%rbx,4)
jne 0x26a8
movl %esi, %ecx
jmp 0x26d9
movslq %edi, %rax
leal -0x1(%rsi), %ecx
movslq %ecx, %rdx
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %r11, %rax
leaq (%rdx,%rdx,2), %rdx
cmpl $0x25, 0x4(%rax,%rdx,4)
je 0x26d7
leal 0x1(%rsi), %ecx
movslq %ecx, %rdx
leaq (%rdx,%rdx,2), %rdx
cmpl $0x25, 0x4(%rax,%rdx,4)
jne 0x26ed
movl %edi, %edx
pushq %r10
pushq %r11
callq 0x23e0
addq $0x10, %rsp
movl $0x1, %eax
popq %rbx
retq
leal 0x1(%rdi), %edx
movslq %edx, %rax
imulq $0x2d0, %rax, %rcx      # imm = 0x2D0
addq %r11, %rcx
xorl %eax, %eax
cmpl $0x25, 0x4(%rcx,%rbx,4)
je 0x26a4
jmp 0x26eb
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x2a, (%rdi,%rcx)
je 0x2941
addq $0xc, %rcx
cmpq $0x2d4, %rcx            # imm = 0x2D4
jne 0x291b
incq %rax
addq $0x2d0, %rdi            # imm = 0x2D0
cmpq $0x1e, %rax
jne 0x2916
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x37f5(%rip), %r14      # 0x6750
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%rbx,%r12,4), %eax
leal 0x30(%rax), %ecx
movl %eax, %esi
orl $0x30, %esi
cmpl $0xa, %eax
cmovael %ecx, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10a0
incq %r12
cmpq $0x3c, %r12
jne 0x2f61
movl $0xa, %edi
callq 0x1040
incq %r15
addq $0xf0, %rbx
cmpq $0x1e, %r15
jne 0x2f5e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/fonctions/insecte.c
// Function: gene_ins
int gene_ins(int bouffe, int dureevie, t_lab lab[X][Y], int a, int b, t_fourmi fourmi[], int choixsexe) {
	srand(time(NULL));
  if(a<=0 || a>=X || b<=0 || b>=Y || lab[a][b].etat!=vide)
    return 1;
	else if(nb_ins>Z){
		printf("\nNombre maximum d'insecte atteint\n");
	}
  else {
    lab[a][b].etat=insecte;
  	lab[a][b].insecte=nb_ins;
		nb_ins++;
		int indice=lab[a][b].insecte;
		//Si on veut un choix aléatoire du sexe
		if(choixsexe==0) {
			int sexe=rand()%100;
	  	if(sexe<50)
	  		fourmi[indice].sexe = MALE;
	  	else
	  		fourmi[indice].sexe = FEMELLE;
		}
		// Si on veut un male
		else if(choixsexe==1) {
			fourmi[indice].sexe = MALE;
		}
		// Si on veut une femelle
		else {
			fourmi[indice].sexe = FEMELLE;
		}

  	fourmi[indice].nourriture = bouffe;
  	fourmi[indice].age = dureevie;
		fourmi[indice].x=a;
		fourmi[indice].y=b;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %r14d
movl %ecx, %r15d
movq %rdx, %r13
movl %esi, %ebp
movl %edi, %r12d
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10d0
leal -0x1e(%r15), %eax
cmpl $-0x1d, %eax
setb %al
leal -0x3c(%r14), %ecx
cmpl $-0x3b, %ecx
setb %cl
orb %al, %cl
movl $0x1, %eax
jne 0x30fe
movl %r15d, %ecx
movl %r14d, %edx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %r13
leaq (%rdx,%rdx,2), %rcx
cmpl $0x20, 0x4(%r13,%rcx,4)
jne 0x30fe
cmpl $0x29, 0xd844(%rip)     # 0x10870
jl 0x303f
leaq 0x37a0(%rip), %rdi      # 0x67d5
callq 0x1070
jmp 0x30fc
movl 0x40(%rsp), %eax
leaq (,%rcx,4), %rcx
addq %r13, %rcx
movl $0x25, 0x4(%rcx)
movl 0xd815(%rip), %edx      # 0x10870
movl %edx, 0x8(%rcx)
incl %edx
movl %edx, 0xd80a(%rip)      # 0x10870
movslq 0x8(%rcx), %r13
cmpl $0x1, %eax
je 0x30b0
testl %eax, %eax
jne 0x30c4
callq 0x1170
movslq %eax, %rcx
imulq $0x51eb851f, %rcx, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %eax
subl %eax, %ecx
leaq (,%r13,4), %rax
addq %r13, %rax
leaq (%rbx,%rax,4), %rax
cmpl $0x31, %ecx
jg 0x30d8
movl $0x0, (%rax)
jmp 0x30de
leaq (,%r13,4), %rax
addq %r13, %rax
movl $0x0, (%rbx,%rax,4)
jmp 0x30de
leaq (,%r13,4), %rax
addq %r13, %rax
movl $0x1, (%rbx,%rax,4)
jmp 0x30de
movl $0x1, (%rax)
leaq (,%r13,4), %rax
addq %r13, %rax
movl %r12d, 0x4(%rbx,%rax,4)
movl %ebp, 0x8(%rbx,%rax,4)
movl %r15d, 0xc(%rbx,%rax,4)
movl %r14d, 0x10(%rbx,%rax,4)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/fonctions/insecte.c
// Function: ajout_insecte
int ajout_insecte (t_lab lab[X][Y], int bouffe, int dureevie, t_fourmi fourmi[]) {
	int a, b;
  srand(time(NULL));
  int nombre = rand()%100;
  if(nombre<50){
    printf("Vous n'avez aucun insecte à placer");
    return 0;
  }
  else {
    printf("Vous pouvez placer un insecte\n");
    printf("Entrez les coordonnées x et y de l'insecte séparées par un espace : ");
    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 l'insecte séparées par un espace : ");
      scanf("%i%i", &a, &b);
    }
    gene_ins(bouffe, dureevie, lab, a, b, fourmi, 0);
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10d0
callq 0x1170
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
cmpl $0x31, %eax
jg 0x3339
leaq 0x343c(%rip), %rdi      # 0x6769
xorl %eax, %eax
callq 0x10a0
jmp 0x3402
movl %r12d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq %r15, 0x20(%rsp)
leaq 0x34a9(%rip), %rdi      # 0x67f7
callq 0x1070
leaq 0x3433(%rip), %r12      # 0x678d
movq %r12, %rdi
xorl %eax, %eax
callq 0x10a0
leaq 0x3252(%rip), %r13      # 0x65bd
leaq 0x1c(%rsp), %rbx
leaq 0x18(%rsp), %rbp
leaq 0x32e6(%rip), %r15      # 0x6662
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1130
movl 0x1c(%rsp), %ecx
leal -0x1e(%rcx), %eax
cmpl $-0x1d, %eax
setb %dl
movl 0x18(%rsp), %eax
leal -0x3c(%rax), %esi
cmpl $-0x3b, %esi
setb %sil
orb %dl, %sil
jne 0x33cd
movl %eax, %r8d
imulq $0x2d0, %rcx, %rax      # imm = 0x2D0
addq %r14, %rax
leaq (%r8,%r8,2), %rdx
cmpl $0x20, 0x4(%rax,%rdx,4)
jne 0x33cd
leaq (%rax,%rdx,4), %rax
cmpl $0x1, (%rax)
je 0x33e1
movq %r15, %rdi
callq 0x1070
movq %r12, %rdi
xorl %eax, %eax
callq 0x10a0
jmp 0x337c
movl $0x0, (%rsp)
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %esi
movq %r14, %rdx
movq 0x20(%rsp), %r9
callq 0x2fba
movl $0x1, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/fonctions/insecte.c
// Function: delete_insecte
void delete_insecte(t_lab lab[X][Y], t_fourmi fourmi[], int x, int y) {
	int i, a, b;
	int indice=lab[x][y].insecte;
	for(i=indice; i<nb_ins-1; i++) {
		// Mise à jour du labyrinthe
		a=fourmi[i+1].x;
		b=fourmi[i+1].y;
		lab[a][b].insecte=i;
		// Mise à jour des cases du tableau de fourmi
		fourmi[i].sexe=fourmi[i+1].sexe;
		fourmi[i].nourriture=fourmi[i+1].nourriture;
		fourmi[i].age=fourmi[i+1].age;
		fourmi[i].x=fourmi[i+1].x;
		fourmi[i].y=fourmi[i+1].y;
	}
	lab[x][y].etat=food;
	lab[x][y].insecte=-1;
	nb_ins--;
}

// Assembly:
movslq %edx, %rax
movslq %ecx, %rcx
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %rdi, %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,4), %rax
movslq 0x8(%rax), %rdx
movl 0xd43b(%rip), %ecx      # 0x10870
decl %ecx
cmpl %ecx, %edx
jge 0x3489
leaq (%rdx,%rdx,4), %rcx
leaq (%rsi,%rcx,4), %rcx
addq $0x24, %rcx
movq %rdx, %rsi
incq %rsi
movslq (%rcx), %r8
movups -0x10(%rcx), %xmm0
movslq -0x4(%rcx), %r9
imulq $0x2d0, %r9, %r9        # imm = 0x2D0
addq %rdi, %r9
leaq (%r8,%r8,2), %r10
movl %edx, 0x8(%r9,%r10,4)
movups %xmm0, -0x24(%rcx)
movl %r8d, -0x14(%rcx)
movslq 0xd3f6(%rip), %r8       # 0x10870
decq %r8
addq $0x14, %rcx
movq %rsi, %rdx
cmpq %r8, %rsi
jl 0x344a
movabsq $-0xffffffd6, %rcx      # imm = 0xFFFFFFFF0000002A
movq %rcx, 0x4(%rax)
decl 0xd3d3(%rip)            # 0x10870
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/fonctions/insecte.c
// Function: modif_pos
int modif_pos(t_lab lab[X][Y], t_fourmi fourmi[], int x, int y, int a, int b, int bouffe, int dureevie){
		int indice=lab[x][y].insecte;
		// On vérifie si on va sur une case de nourriture
		if(lab[a][b].etat==food)
			fourmi[indice].nourriture=bouffe;

		if(fourmi[indice].nourriture>0 && fourmi[indice].age>0) {
			// On décrémente la nourriture de l'insecte
			fourmi[indice].nourriture=fourmi[indice].nourriture-1;
			fourmi[indice].age=fourmi[indice].age-1;
			// modif de l'état de la case
			lab[a][b].etat=insecte;
			lab[x][y].etat=vide;
			// modif de l'indice de l'insecte dans la case
			lab[a][b].insecte=indice;
			lab[x][y].insecte=-1;
			// maj de la position de l'insecte
			fourmi[indice].x=a;
			fourmi[indice].y=b;
		}
		else {
			delete_insecte(lab, fourmi, x, y);
		}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %edx, %rax
movslq %ecx, %r10
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %rdi, %rax
leaq (%r10,%r10,2), %r11
movslq %r8d, %r10
movslq %r9d, %r14
imulq $0x2d0, %r10, %rbx      # imm = 0x2D0
addq %rdi, %rbx
leaq (%r14,%r14,2), %r14
cmpl $0x2a, 0x4(%rbx,%r14,4)
movl 0x8(%rax,%r11,4), %r10d
movslq %r10d, %r15
leaq (%r15,%r15,4), %r15
leaq 0x4(%rsi,%r15,4), %r12
jne 0x34f1
movl 0x30(%rsp), %ebp
movl %ebp, (%r12)
jmp 0x34f5
movl (%r12), %ebp
testl %ebp, %ebp
jle 0x353e
leaq (%rsi,%r15,4), %r15
movl 0x8(%r15), %r12d
testl %r12d, %r12d
jle 0x353e
leaq (%rax,%r11,4), %rax
leaq (%rbx,%r14,4), %rcx
decl %ebp
movl %ebp, 0x4(%r15)
decl %r12d
movl %r12d, 0x8(%r15)
movl $0x25, 0x4(%rcx)
movl $0x20, 0x4(%rax)
movl %r10d, 0x8(%rcx)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl %r8d, 0xc(%r15)
movl %r9d, 0x10(%r15)
jmp 0x3543
callq 0x3413
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: AsserT
void AsserT(char *sContexte,int bAssertion1,int bAssertion2,int bAssertion3,int bAssertion4,int bAssertion5,int bAssertion6){
	int bAssertion=bAssertion1 && bAssertion2 && bAssertion3 && bAssertion4 && bAssertion5 && bAssertion6;
	if (!bAssertion){
		AsserT0(sContexte,bAssertion1,1);
		AsserT0(sContexte,bAssertion2,2);
		AsserT0(sContexte,bAssertion3,3);
		AsserT0(sContexte,bAssertion4,4);
		AsserT0(sContexte,bAssertion5,5);
		AsserT0(sContexte,bAssertion6,6);
	}
	assert(bAssertion);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %rbx
movl 0x40(%rsp), %r14d
testl %esi, %esi
je 0x359a
testl %r13d, %r13d
je 0x359a
testl %r12d, %r12d
je 0x359a
testl %r15d, %r15d
je 0x359a
testl %ebp, %ebp
je 0x359a
testl %r14d, %r14d
je 0x359a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %edx
callq 0x3615
movq %rbx, %rdi
movl %r13d, %esi
movl $0x2, %edx
callq 0x3615
movq %rbx, %rdi
movl %r12d, %esi
movl $0x3, %edx
callq 0x3615
movq %rbx, %rdi
movl %r15d, %esi
movl $0x4, %edx
callq 0x3615
movq %rbx, %rdi
movl %ebp, %esi
movl $0x5, %edx
callq 0x3615
movq %rbx, %rdi
movl %r14d, %esi
movl $0x6, %edx
callq 0x3615
leaq 0x3337(%rip), %rdi      # 0x6934
leaq 0x333b(%rip), %rsi      # 0x693f
leaq 0x3349(%rip), %rcx      # 0x6954
movl $0x28, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: AsserT0
void AsserT0(char *sContexte,int bAssertion,int nParametre){
	if (!bAssertion){
		printf("    *** Assertion fausse (paramètre n°%d)",nParametre);
		if (strlen(sContexte)>0)
			printf(" dans \"%s\"",sContexte,nParametre);
		printf(".\n");
	}
}

// Assembly:
testl %esi, %esi
je 0x361a
retq
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leaq 0x335c(%rip), %rdi      # 0x6986
movl %edx, %esi
xorl %eax, %eax
callq 0x10a0
cmpb $0x0, (%r14)
je 0x364c
leaq 0x3372(%rip), %rdi      # 0x69b2
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10a0
leaq 0x3b33(%rip), %rdi      # 0x7186
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: Appel0
void Appel0(char *sMessage){
	//affiche sMessage s'il est non vide;sinon,affiche "Programme en cours...". Puis passe à la ligne. Vérifie le parenthésage des appels.
	Vrai2(sMessage!=0,nEcriS<knEcrisMaX);
	FlipFlop(1,&bEcriS[++nEcriS]);
	if (strlen(sMessage)==0){
		printf("Programme en cours...\n");
	} else printf("%s%s: tâche en cours...\n",sE(2*nEcriS),sMessage);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
xorl %edx, %edx
cmpl $0x3f, 0xcd35(%rip)     # 0x10880
setl %dl
movl $0x1, (%rsp)
leaq 0x274c(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
movslq 0xcd07(%rip), %rax      # 0x10880
leaq 0x1(%rax), %rdi
movl %edi, 0xccfd(%rip)      # 0x10880
leaq 0xcd06(%rip), %rcx      # 0x10890
cmpl $0x1, 0x4(%rcx,%rax,4)
je 0x3bd4
movl $0x1, 0x4(%rcx,%rax,4)
cmpb $0x0, (%rbx)
je 0x3bc3
addl %edi, %edi
movl $0x20, %esi
callq 0x4a5f
leaq 0x2e71(%rip), %rdi      # 0x6a22
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x10a0
leaq 0x35a8(%rip), %rdi      # 0x7172
addq $0x10, %rsp
popq %rbx
jmp 0x1070
leaq 0x30c1(%rip), %rdi      # 0x6c9c
leaq 0x2d5d(%rip), %rsi      # 0x693f
leaq 0x30cc(%rip), %rcx      # 0x6cb5
movl $0x25b, %edx            # imm = 0x25B
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: Appel1
void Appel1(char *sMessage){
	//affiche sMessage s'il est non vide;sinon,affiche "Programme terminé.". Puis passe à la ligne. Vérifie le parenthésage des appels.
	int nMessageLg=strlen(sMessage);
	Vrai2(sMessage!=0,nEcriS>0);
	FlipFlop(0,&bEcriS[nEcriS]);
	if (nMessageLg)
		printf("%s%s: tâche terminée.\n",sE(2*nEcriS),sMessage);
	else printf("Programme terminé.\n");
	nEcriS--;
	assert(nEcriS>=0);
	if (!nMessageLg){
		assert(nEcriS==0);//ie s0 et s1 sont correctt parenthésés
		assert(ipWhilE>=0);//si ok,il a bien été ajouté 1° un appel à While() avant chaque boucle while et 2° un appel à bWhile() dans ladite boucle
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1090
movq %rax, %r14
xorl %esi, %esi
testq %rbx, %rbx
setne %sil
xorl %edx, %edx
cmpl $0x0, 0xcc3b(%rip)      # 0x10880
setg %dl
movl $0x1, (%rsp)
leaq 0x2652(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
movslq 0xcc0d(%rip), %rdi      # 0x10880
leaq 0xcc16(%rip), %rax      # 0x10890
cmpl $0x0, (%rax,%rdi,4)
je 0x3cf5
movl $0x0, (%rax,%rdi,4)
testl %r14d, %r14d
je 0x3cc1
addl %edi, %edi
movl $0x20, %esi
callq 0x4a5f
leaq 0x2d9d(%rip), %rdi      # 0x6a3c
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10a0
movl 0xcbce(%rip), %eax      # 0x10880
leal -0x1(%rax), %ecx
movl %ecx, 0xcbc5(%rip)      # 0x10880
testl %eax, %eax
jg 0x3ced
jmp 0x3d14
leaq 0x34c0(%rip), %rdi      # 0x7188
callq 0x1070
movl 0xcbad(%rip), %ecx      # 0x10880
leal -0x1(%rcx), %eax
movl %eax, 0xcba4(%rip)      # 0x10880
testl %ecx, %ecx
jle 0x3d14
testl %eax, %eax
jne 0x3d33
cmpl $0x0, 0xcb99(%rip)      # 0x10884
js 0x3d52
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2fa0(%rip), %rdi      # 0x6c9c
leaq 0x2c3c(%rip), %rsi      # 0x693f
leaq 0x2fab(%rip), %rcx      # 0x6cb5
movl $0x25b, %edx            # imm = 0x25B
callq 0x10b0
leaq 0x2d3a(%rip), %rdi      # 0x6a55
leaq 0x2c1d(%rip), %rsi      # 0x693f
leaq 0x2d36(%rip), %rcx      # 0x6a5f
movl $0xc7, %edx
callq 0x10b0
leaq 0x2d39(%rip), %rdi      # 0x6a73
leaq 0x2bfe(%rip), %rsi      # 0x693f
leaq 0x2d17(%rip), %rcx      # 0x6a5f
movl $0xc9, %edx
callq 0x10b0
leaq 0x2d24(%rip), %rdi      # 0x6a7d
leaq 0x2bdf(%rip), %rsi      # 0x693f
leaq 0x2cf8(%rip), %rcx      # 0x6a5f
movl $0xca, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sC
char *sC(char cAlphaNumeriqueOuEspace){
	//convertit cA en string;cA est censé être un caractère alphanumérique (donc non accentué) ou un espace
	char *sAccu=malloc(1+kuAntiSlashZerO);
	char sMotif[2];
	assert(isalnum(cAlphaNumeriqueOuEspace) || isspace(cAlphaNumeriqueOuEspace));//isspace: espace,saut de page,fin de ligne,retour chariot,tabulation.
	sMotif[0]=cAlphaNumeriqueOuEspace;
	sMotif[1]='\0';
	strcpy(sAccu,sMotif);
	OctetGereR(sAccu);
	return(sAccu);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x2, %edi
callq 0x1110
movq %rax, %rbx
callq 0x1180
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
testl $0x2008, %eax           # imm = 0x2008
je 0x3ded
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x3e0c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2c94(%rip), %rdi      # 0x6a88
leaq 0x2b44(%rip), %rsi      # 0x693f
leaq 0x2ccb(%rip), %rcx      # 0x6acd
movl $0xe5, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: OctetGereR
void OctetGereR(char *sMalloc){
	//prend note de l'allocation de sMalloc sur l'espace courant et libère le demi-espace le plus ancien si cette allocation sature l'espace courant
	int nAlloc;
	char *sAlloc;
	if (zuOctetGereR==0){
		yOctetGereR0[nOctetGereR0++]=(long) sMalloc;
		if (nOctetGereR0>=kuOctetGererMaX){
			Confirmer("Changement de demi-espace de chaînes de caractères (0 vers 1)");//mettre en commentaire après mise au point
			for (nAlloc=0; nAlloc<=kuOctetGererMaX; nAlloc++) {
				sAlloc=(char *) yOctetGereR1[nAlloc];
				if (sAlloc!=0)
					free(sAlloc);
				yOctetGereR1[nAlloc]=0;
			}
			zuOctetGereR=1-zuOctetGereR;//change de demi-espace
			nOctetGereR1=0;//premier index valide sur le futur demi-espace 
		}
	} else {
		yOctetGereR1[nOctetGereR1++]=(long) sMalloc;
		if (nOctetGereR1>=kuOctetGererMaX){
			Confirmer("Changement de demi-espace de chaînes de caractères (1 vers 0)");//mettre en commentaire après mise au point
			for (nAlloc=0; nAlloc<=kuOctetGererMaX; nAlloc++) {
				sAlloc=(char *) yOctetGereR0[nAlloc];
				if (sAlloc!=0)
					free(sAlloc);
				yOctetGereR0[nAlloc]=0;
			}
			zuOctetGereR=1-zuOctetGereR;//change de demi-espace
			nOctetGereR0=0;//premier index valide sur le futur demi-espace
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0xcb78(%rip)      # 0x10990
je 0x3e83
movslq 0xdb8f(%rip), %rax      # 0x119b0
leal 0x1(%rax), %ecx
movl %ecx, 0xdb86(%rip)      # 0x119b0
leaq 0xd37f(%rip), %rcx      # 0x111b0
movq %rdi, (%rcx,%rax,8)
cmpq $0xfe, %rax
jl 0x3efd
leaq 0x2eea(%rip), %rdi      # 0x6d32
callq 0x476a
xorl %r14d, %r14d
leaq 0xcb49(%rip), %r15      # 0x109a0
leaq 0xd342(%rip), %rbx      # 0x111a0
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x3e6c
callq 0x1030
movq $0x0, (%r14,%r15)
addq $0x8, %r14
cmpq $0x800, %r14            # imm = 0x800
jne 0x3e5e
jmp 0x3ee6
movslq 0xd316(%rip), %rax      # 0x111a0
leal 0x1(%rax), %ecx
movl %ecx, 0xd30d(%rip)      # 0x111a0
leaq 0xcb06(%rip), %rcx      # 0x109a0
movq %rdi, (%rcx,%rax,8)
cmpq $0xfe, %rax
jl 0x3efd
leaq 0x2e45(%rip), %rdi      # 0x6cf2
callq 0x476a
xorl %r14d, %r14d
leaq 0xd2f4(%rip), %r15      # 0x111b0
leaq 0xdaed(%rip), %rbx      # 0x119b0
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x3ed1
callq 0x1030
movq $0x0, (%r14,%r15)
addq $0x8, %r14
cmpq $0x800, %r14            # imm = 0x800
jne 0x3ec3
movl $0x1, %eax
subl 0xca9f(%rip), %eax      # 0x10990
movl %eax, 0xca99(%rip)      # 0x10990
movl $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sC2
char *sC2(char *sA,char *sB){
	//concatène sA et sB
	int uRequis;
	Vrai2(sA!=0,sB!=0);
	uRequis=1+strlen(sA)+strlen(sB);
	char *sAccu=malloc(uRequis+kuAntiSlashZerO);
	strcpy(sAccu,sA);
	strcat(sAccu,sB);
	OctetGereR(sAccu);
	return(sAccu);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
xorl %edx, %edx
testq %rbx, %rbx
setne %dl
movl $0x1, (%rsp)
leaq 0x231d(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
movq %r14, %rdi
callq 0x1090
movq %rax, %r15
movq %rbx, %rdi
callq 0x1090
addl %r15d, %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x1110
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r15, %rdi
callq 0x3e0c
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sC2b
char *sC2b(char *sA,char *sB){
	//concatène sA à sB,avec un blanc intercalé si sA et sB sont de longueur non nulle
	int bBlancEnSus,nRequis;
	char *sAccu;
	Vrai2(sA!=0,sB!=0);
	nRequis=strlen(sA)+strlen(sB);
	assert(nRequis>=0);
	bBlancEnSus=(strlen(sA)>0) && (strlen(sB)>0);
	if (bBlancEnSus)
		nRequis++;
	sAccu=malloc(nRequis+kuAntiSlashZerO);//les accents aigus génèrent des codes caractères en sus qui sont ignorés par strlen...Le 4 minimise les dégâts
	strcpy(sAccu,sA);
	if (bBlancEnSus)
		strcat(sAccu," ");
	strcat(sAccu,sB);
	OctetGereR(sAccu);
	return(sAccu);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
xorl %edx, %edx
testq %rbx, %rbx
setne %dl
movl $0x1, (%rsp)
leaq 0x228b(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
movq %r14, %rdi
callq 0x1090
movq %rax, %r15
movq %rbx, %rdi
callq 0x1090
leaq (%rax,%r15), %rcx
testl %ecx, %ecx
js 0x40b0
testq %r15, %r15
setne %dl
testq %rax, %rax
setne %al
andb %dl, %al
movzbl %al, %r12d
leal (%rcx,%r12), %edi
incl %edi
callq 0x1110
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
cmpb $0x1, %r12b
jne 0x408e
movq %r15, %rdi
callq 0x1090
movw $0x20, (%r15,%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r15, %rdi
callq 0x3e0c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2a50(%rip), %rdi      # 0x6b07
leaq 0x2881(%rip), %rsi      # 0x693f
leaq 0x2a4d(%rip), %rcx      # 0x6b12
movl $0x10c, %edx            # imm = 0x10C
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: nCaractere
int nCaractere(char *sString){
	//rend le nombre de caractères de sString (et non pas le nombre de codes caractères,contrairt à strlen() qui renvoie 2 pour un seul "à")
	int nC=0;//index sur le code caractère courant de sString
	int nCaractere=0;
	int nChaineLg;
	char cCode;
	assert(sString!=0);
	for (nChaineLg=strlen(sString),nC=0;nC<nChaineLg;nC++){
		cCode=sString[nC];
		if ( isalpha(cCode) || isdigit(cCode) || bLettrE2(sString,&nC) ) //dernier terme: voyelle ou consonne avec un signe diacritique
			nCaractere++;
	}
	assert(nCaractere>=0);
	return(nCaractere);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4563
movq %rdi, %rbx
callq 0x1090
movq %rax, %r14
movl $0x0, 0xc(%rsp)
xorl %ebp, %ebp
testl %r14d, %r14d
jle 0x4554
callq 0x1180
movq %rax, %r15
leaq 0xc(%rsp), %r12
xorl %eax, %eax
cltq
movsbq (%rbx,%rax), %rax
movq (%r15), %rcx
testb $0xc, 0x1(%rcx,%rax,2)
jne 0x453f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x45a1
testl %eax, %eax
je 0x4541
incl %ebp
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %r14d, %eax
jl 0x451f
testl %ebp, %ebp
js 0x4582
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2466(%rip), %rdi      # 0x69d0
leaq 0x23ce(%rip), %rsi      # 0x693f
leaq 0x25b5(%rip), %rcx      # 0x6b2d
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x10b0
leaq 0x25bb(%rip), %rdi      # 0x6b44
leaq 0x23af(%rip), %rsi      # 0x693f
leaq 0x2596(%rip), %rcx      # 0x6b2d
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: bLettrE2
int bLettrE2(char *sString,int *pnCodeCaractereRg){
	//sString[*pnCodeCaractereRg] ou Chaine[*pnCodeCaractereRg..*pnCodeCaractereRg+1] code une consonne;si vrai et 2 codes, passe au code suivant
	char cCode;
	int bLettrE2=0;
	assert(sString!=0);
	Croit(0,*pnCodeCaractereRg,strlen(sString));
	cCode=sString[*pnCodeCaractereRg];
	bLettrE2=isalpha(cCode);//vrai si consonnes ou voyelles sans signe diacritique (accent,cédille,tilde...)
	if ( !bLettrE2 && (*pnCodeCaractereRg<strlen(sString)) ) {//l'accès à sString[nCodeCaractereRg+1] est valide
		bLettrE2=bVoyellE2(sString,pnCodeCaractereRg) || bConsonnE2(sString,pnCodeCaractereRg);
	}
	return(bLettrE2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4629
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ebp
callq 0x1090
xorl %edi, %edi
movl %ebp, %esi
movl %eax, %edx
callq 0x48b8
movslq (%rbx), %r15
movsbq (%r14,%r15), %r12
callq 0x1180
movq (%rax), %rax
movzwl (%rax,%r12,2), %eax
andl $0x400, %eax            # imm = 0x400
jne 0x460d
movq %r14, %rdi
callq 0x1090
movq %rax, %rcx
movl $0x0, %eax
cmpq %r15, %rcx
jbe 0x460d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c33
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x4616
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x479d
leaq 0x23a0(%rip), %rdi      # 0x69d0
leaq 0x2308(%rip), %rsi      # 0x693f
leaq 0x2691(%rip), %rcx      # 0x6ccf
movl $0x297, %edx            # imm = 0x297
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sChoix0
char *sChoix0(int bOption,char *sOption){
	//rend sOption si bOption est vrai;sinon,rend une chaîne vide.
	int nRequis;
	assert(sOption!=0);
	nRequis = bOption? strlen(sOption) : 0;
	char *sCopie=malloc(nRequis+kuAntiSlashZerO);
	if (bOption)
		strcpy(sCopie,sOption);
	OctetGereR(sCopie);
	return(sCopie);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x46cc
testl %edi, %edi
je 0x46ac
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x1090
incl %eax
movslq %eax, %rdi
callq 0x1110
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
jmp 0x46b9
movl $0x1, %edi
callq 0x1110
movq %rax, %r14
movq %r14, %rdi
callq 0x3e0c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x247f(%rip), %rdi      # 0x6b52
leaq 0x2265(%rip), %rsi      # 0x693f
leaq 0x247c(%rip), %rcx      # 0x6b5d
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sChoix
char *sChoix(int bOptionSinonAlternative,char *sOption,char *sAlternative){
	//rend sOption si bOptionSinonAlternative est vrai; sinon,rend sAlternative.
	int nRequis;
	Vrai2(sOption!=0,sAlternative!=0);
	nRequis = bOptionSinonAlternative? strlen(sOption) : strlen(sAlternative);
	char *sCopie=malloc(nRequis+kuAntiSlashZerO);
	if (bOptionSinonAlternative)
		strcpy(sCopie,sOption);
	else strcpy(sCopie,sAlternative);
	OctetGereR(sCopie);
	return(sCopie);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
xorl %esi, %esi
testq %rbx, %rbx
setne %sil
xorl %edx, %edx
testq %r14, %r14
setne %dl
movl $0x1, (%rsp)
leaq 0x1b8e(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
testl %ebp, %ebp
cmoveq %r14, %rbx
movq %rbx, %rdi
callq 0x1090
incl %eax
movslq %eax, %rdi
callq 0x1110
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1050
movq %r14, %rdi
callq 0x3e0c
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: Confirmer
void Confirmer(char *sMessage){
	char cCar;
	printf("%s Valider SVP (touche entrée)",sMessage);
	scanf("%c",&cCar);
	printf(" Merci d'avoir validé.\n");
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x2403(%rip), %rdi      # 0x6b78
xorl %eax, %eax
callq 0x10a0
leaq 0x1fce(%rip), %rdi      # 0x6751
leaq 0x7(%rsp), %rsi
xorl %eax, %eax
callq 0x1130
leaq 0x2a06(%rip), %rdi      # 0x719c
callq 0x1070
popq %rax
retq