LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x8526(%rip), %rbx      # 0xa0f0
movq %rbx, %rdi
callq 0x14f4
leaq 0xd977(%rip), %r14      # 0xf550
pushq $0xa
popq %rdi
pushq $0x1e
popq %r12
movl %r12d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2ee9
movq %rbx, %rdi
callq 0x19bf
movq %rbx, %rdi
callq 0x2350
movq %rbx, %rdi
movq %r14, %rsi
callq 0x128c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x171a
movq %rbx, %rdi
callq 0x1a80
testl %eax, %eax
jne 0x1cac
movq %rbx, %rdi
pushq $0xa
popq %rsi
movl %r12d, %edx
movq %r14, %rcx
callq 0x212e
testl %eax, %eax
je 0x1cd8
xorl %eax, %eax
callq 0x2dcc
movl %eax, %r13d
movl %eax, %eax
imulq $0x14, %rax, %rax
leaq (%rax,%r14), %r15
addq $-0x4, %r15
testl %r13d, %r13d
jle 0x1bfe
movl -0x4(%r15), %esi
movl (%r15), %eax
cmpq $0x1e, %rsi
setb %cl
cmpl $0x3c, %eax
setb %dl
testb %dl, %cl
je 0x1ca3
movl %eax, %edx
imulq $0x2d0, %rsi, %rax      # imm = 0x2D0
addq %rbx, %rax
imulq $0xc, %rdx, %rcx
cmpl $0x25, 0x4(%rcx,%rax)
jne 0x1ca3
movq %rbx, %rdi
movq %r14, %rcx
pushq $0xa
popq %r8
movl %r12d, %r9d
callq 0x27ff
movq %rbx, %rdi
callq 0x2350
decl %r13d
addq $-0x14, %r15
jmp 0x1c55
cmpl $0x1, %eax
je 0x1cbf
cmpl $0x2, %eax
jne 0x1cc8
leaq 0x37ad(%rip), %rdi      # 0x546a
jmp 0x1ccf
leaq 0x37b4(%rip), %rdi      # 0x547a
jmp 0x1ccf
leaq 0x377d(%rip), %rdi      # 0x544c
callq 0x1070
xorl %eax, %eax
jmp 0x1cdb
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/./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 0x37b2(%rip), %r15      # 0x54b1
leaq 0x37c1(%rip), %r12      # 0x54c7
leaq 0x34b1(%rip), %r13      # 0x51be
leaq 0x34b9(%rip), %rbx      # 0x51cd
leaq -0x2c(%rbp), %r14
leaq 0x376c(%rip), %rdi      # 0x548b
callq 0x1070
leaq 0x3769(%rip), %rdi      # 0x5494
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 0x1d85
cmpl $0x2, %eax
je 0x1d77
cmpl $0x3, %eax
je 0x1d90
leaq 0x3764(%rip), %rdi      # 0x54d4
callq 0x1070
jmp 0x1d8a
callq 0x1bb5
xorl %edi, %edi
callq 0x2dd3
jmp 0x1d8a
callq 0x1b29
cmpl $0x3, -0x2c(%rbp)
jne 0x1d18
leaq 0x3750(%rip), %rdi      # 0x54e7
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10d0
callq 0x1170
pushq $0x3
popq %rcx
cltd
idivl %ecx
movl %edx, %ebp
incl %ebp
leaq 0x3723(%rip), %rdi      # 0x550c
movl %ebp, %esi
xorl %eax, %eax
callq 0x10a0
testl %ebp, %ebp
cmovlel %ebx, %ebp
movl %ebp, 0x4(%rsp)
leaq 0x379f(%rip), %r14      # 0x55a1
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x3833(%rip), %r13      # 0x5646
leaq 0x378c(%rip), %rbx      # 0x55a6
xorl %ebp, %ebp
cmpl 0x4(%rsp), %ebp
je 0x1e9b
incl %ebp
leaq 0x370f(%rip), %rdi      # 0x553a
movl %ebp, %esi
xorl %eax, %eax
callq 0x10a0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1130
movl 0xc(%rsp), %eax
leal -0x1e(%rax), %ecx
cmpl $-0x1d, %ecx
setb %dl
movl 0x8(%rsp), %ecx
leal -0x3c(%rcx), %esi
cmpl $-0x3b, %esi
setb %sil
orb %dl, %sil
jne 0x1e85
movl %ecx, %ecx
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq 0x10(%rsp), %rax
imulq $0xc, %rcx, %rcx
cmpl $0x20, 0x4(%rcx,%rax)
jne 0x1e85
addq %rcx, %rax
cmpl $0x1, (%rax)
je 0x1e92
movq %r13, %rdi
callq 0x1070
movq %rbx, %rdi
jmp 0x1e2b
movl $0x2a, 0x4(%rax)
jmp 0x1e1c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/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 0x3734(%rip), %rdi      # 0x55f5
leaq 0x3738(%rip), %rsi      # 0x5600
callq 0x1120
movq %rax, %rbx
leaq 0x32f6(%rip), %r15      # 0x51cd
xorl %r13d, %r13d
cmpq $0x1e, %r13
je 0x1f1f
pushq $0x4
popq %r12
cmpq $0x2d4, %r12            # imm = 0x2D4
je 0x1f13
movl -0x4(%r14,%r12), %ebp
movl (%r14,%r12), %edi
movq %rbx, %rsi
callq 0x10c0
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
addq $0xc, %r12
jmp 0x1ee4
incq %r13
addq $0x2d0, %r14            # imm = 0x2D0
jmp 0x1eda
xorl %eax, %eax
callq 0x2dcc
leaq 0x319a(%rip), %rsi      # 0x50c7
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_O2/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
imulq $0xc, %rdi, %rdi
movslq 0x8(%rdi,%rsi), %rsi
imulq $0x14, %rsi, %rsi
movl (%rcx,%rsi), %ebp
movslq %edx, %rdi
movslq %r11d, %r14
imulq $0x2d0, %rdi, %rdi      # imm = 0x2D0
addq %r10, %rdi
imulq $0xc, %r14, %r14
movslq 0x8(%r14,%rdi), %rdi
imulq $0x14, %rdi, %rdi
cmpl (%rcx,%rdi), %ebp
jne 0x231a
addq %rcx, %rsi
addq %rcx, %rdi
movl 0x8(%rsi), %r8d
movl 0x8(%rdi), %r9d
cmpl %r9d, %r8d
jge 0x232d
movq %r10, %rdi
movq %rcx, %rsi
movl %ebx, %edx
movl %eax, %ecx
jmp 0x2338
movl %r8d, %edi
movl %r9d, %esi
movq %r10, %rdx
callq 0x2fbc
pushq $0x1
popq %rax
jmp 0x233f
jle 0x2344
movq %r10, %rdi
movq %rcx, %rsi
movl %r11d, %ecx
callq 0x3170
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
jne 0x230e
movl 0x4(%rdi), %edi
cmpl %edi, 0x4(%rsi)
jle 0x230e
jmp 0x232f
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0xc, %rcx, %rbx
cmpl $0x25, 0x4(%rbx,%rax)
jne 0x2576
movl %esi, %ecx
jmp 0x25a7
movslq %edi, %rax
leal -0x1(%rsi), %ecx
movslq %ecx, %rdx
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %r11, %rax
imulq $0xc, %rdx, %rdx
cmpl $0x25, 0x4(%rdx,%rax)
je 0x25a5
leal 0x1(%rsi), %ecx
movslq %ecx, %rdx
imulq $0xc, %rdx, %rdx
cmpl $0x25, 0x4(%rdx,%rax)
jne 0x25b7
movl %edi, %edx
pushq %r10
pushq %r11
callq 0x22a4
popq %rcx
popq %rdx
pushq $0x1
popq %rax
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(%rbx,%rcx)
je 0x2572
jmp 0x25b5
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4
popq %rdx
pushq $0x1
popq %rcx
xorl %esi, %esi
cmpq $0x1e, %rsi
je 0x27fe
movq %rdx, %r8
leaq 0xc(%r8), %r9
cmpq $0x2e0, %r9             # imm = 0x2E0
je 0x27f0
cmpl $0x2a, (%rdi,%r8)
movq %r9, %r8
jne 0x27d7
jmp 0x27fc
incq %rsi
addq $0x2d0, %rdi            # imm = 0x2D0
jmp 0x27ce
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0xa
popq %rbp
leaq 0x29a0(%rip), %r14      # 0x571d
xorl %r15d, %r15d
cmpq $0x1e, %r15
je 0x2dc3
xorl %r12d, %r12d
cmpq $0x3c, %r12
je 0x2db0
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
jmp 0x2d89
movl %ebp, %edi
callq 0x1040
incq %r15
addq $0xf0, %rbx
jmp 0x2d80
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rax
jne 0x2eda
movl %r15d, %ecx
movl %r14d, %edx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %r13
imulq $0xc, %rdx, %rcx
cmpl $0x20, 0x4(%rcx,%r13)
jne 0x2eda
cmpl $0x29, 0xca26(%rip)     # 0xf870
jl 0x2e5a
leaq 0x294f(%rip), %rdi      # 0x57a2
callq 0x1070
jmp 0x2ed8
movl 0x40(%rsp), %eax
addq %rcx, %r13
movl $0x25, 0x4(%r13)
movl 0xca01(%rip), %ecx      # 0xf870
movl %ecx, 0x8(%r13)
incl %ecx
movl %ecx, 0xc9f5(%rip)      # 0xf870
movslq 0x8(%r13), %r13
cmpl $0x1, %eax
je 0x2ea4
testl %eax, %eax
jne 0x2eae
callq 0x1170
pushq $0x64
popq %rcx
cltd
idivl %ecx
imulq $0x14, %r13, %rax
addq %rbx, %rax
cmpl $0x31, %edx
jg 0x2ebb
andl $0x0, (%rax)
jmp 0x2ec1
imulq $0x14, %r13, %rax
andl $0x0, (%rbx,%rax)
jmp 0x2ec1
imulq $0x14, %r13, %rax
movl $0x1, (%rbx,%rax)
jmp 0x2ec1
movl $0x1, (%rax)
imulq $0x14, %r13, %rax
movl %r12d, 0x4(%rbx,%rax)
movl %ebp, 0x8(%rbx,%rax)
movl %r15d, 0xc(%rbx,%rax)
movl %r14d, 0x10(%rbx,%rax)
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_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, %r14
movl %esi, 0x14(%rsp)
movl %edi, 0x10(%rsp)
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10d0
callq 0x1170
pushq $0x2
popq %rcx
cltd
idivl %ecx
movq %rdx, 0x18(%rsp)
leal 0x1(%rdx), %eax
movl %eax, 0xc(%rsp)
pushq $0x3c
popq %r15
pushq $0x1e
popq %r12
cmpl $0x5, %ebx
je 0x2fad
callq 0x1170
movl %eax, %r13d
callq 0x1170
cltd
idivl %r15d
movl %edx, %r8d
movl %r13d, %eax
cltd
idivl %r12d
movl %edx, %ecx
movslq %edx, %rax
movslq %r8d, %rdx
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %r14, %rax
imulq $0xc, %rdx, %rdx
cmpl $0x20, 0x4(%rdx,%rax)
jne 0x2f3b
movl 0xc(%rsp), %edx
cmpl $0x2, %edx
pushq $0x1
popq %rax
cmovel %eax, %ebp
cmpl $0x0, 0x18(%rsp)
pushq $0x2
popq %rax
cmovel %eax, %ebp
testb $0x1, %bl
cmovel %edx, %ebp
movl %ebp, (%rsp)
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %esi
movq %r14, %rdx
movq 0x20(%rsp), %r9
callq 0x2dda
incl %ebx
jmp 0x2f36
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10d0
pushq $0x3c
popq %r13
pushq $0x1e
popq %rbx
callq 0x1170
movl %eax, %r12d
callq 0x1170
cltd
idivl %r13d
movl %edx, %r8d
movl %r12d, %eax
cltd
idivl %ebx
movl %edx, %ecx
movslq %edx, %rax
movslq %r8d, %rdx
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %r14, %rax
imulq $0xc, %rdx, %rdx
cmpl $0x20, 0x4(%rdx,%rax)
je 0x302b
addq %rdx, %rax
cmpl $0x1, (%rax)
jne 0x2fec
andl $0x0, (%rsp)
movl %r15d, %edi
movl %ebp, %esi
movq %r14, %rdx
movq 0x10(%rsp), %r9
callq 0x2dda
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/fonctions/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
pushq $0x64
popq %rcx
cltd
idivl %ecx
cmpl $0x31, %edx
jg 0x309c
leaq 0x26a6(%rip), %rdi      # 0x5736
xorl %eax, %eax
callq 0x10a0
jmp 0x315f
movl %r12d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq %r15, 0x20(%rsp)
leaq 0x2713(%rip), %rdi      # 0x57c4
callq 0x1070
leaq 0x269d(%rip), %r12      # 0x575a
movq %r12, %rdi
xorl %eax, %eax
callq 0x10a0
leaq 0x24d3(%rip), %r13      # 0x55a1
leaq 0x1c(%rsp), %rbx
leaq 0x18(%rsp), %rbp
leaq 0x2567(%rip), %r15      # 0x5646
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 0x312f
movl %eax, %r8d
imulq $0x2d0, %rcx, %rax      # imm = 0x2D0
addq %r14, %rax
imulq $0xc, %r8, %rdx
cmpl $0x20, 0x4(%rdx,%rax)
jne 0x312f
addq %rdx, %rax
cmpl $0x1, (%rax)
je 0x3143
movq %r15, %rdi
callq 0x1070
movq %r12, %rdi
xorl %eax, %eax
callq 0x10a0
jmp 0x30df
andl $0x0, (%rsp)
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %esi
movq %r14, %rdx
movq 0x20(%rsp), %r9
callq 0x2dda
pushq $0x1
popq %rbx
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_O2/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, %rdx      # imm = 0x2D0
addq %rdi, %rdx
imulq $0xc, %rcx, %rcx
leaq (%rdx,%rcx), %rax
movslq 0x8(%rcx,%rdx), %rdx
imulq $0x14, %rdx, %rcx
addq %rsi, %rcx
addq $0x24, %rcx
movslq 0xc6d1(%rip), %rsi      # 0xf870
decq %rsi
cmpq %rsi, %rdx
jge 0x31d5
movslq (%rcx), %rsi
movups -0x10(%rcx), %xmm0
movslq -0x4(%rcx), %r8
imulq $0x2d0, %r8, %r8        # imm = 0x2D0
addq %rdi, %r8
imulq $0xc, %rsi, %r9
movl %edx, 0x8(%r9,%r8)
incq %rdx
movups %xmm0, -0x24(%rcx)
movl %esi, -0x14(%rcx)
addq $0x14, %rcx
jmp 0x3198
movabsq $-0xffffffd6, %rcx      # imm = 0xFFFFFFFF0000002A
movq %rcx, 0x4(%rax)
decl 0xc687(%rip)            # 0xf870
retq
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0xc, %r10, %r14
movl 0x8(%r14,%rax), %r10d
movslq %r8d, %r11
movslq %r9d, %rbx
imulq $0x2d0, %r11, %r11      # imm = 0x2D0
addq %rdi, %r11
imulq $0xc, %rbx, %r15
movslq %r10d, %rbx
imulq $0x14, %rbx, %rbx
cmpl $0x2a, 0x4(%r15,%r11)
leaq 0x4(%rsi,%rbx), %r12
jne 0x323d
movl 0x30(%rsp), %ebp
movl %ebp, (%r12)
jmp 0x3241
movl (%r12), %ebp
testl %ebp, %ebp
jle 0x3284
addq %rsi, %rbx
movl 0x8(%rbx), %r12d
testl %r12d, %r12d
jle 0x3284
addq %r14, %rax
addq %r15, %r11
decl %ebp
movl %ebp, 0x4(%rbx)
decl %r12d
movl %r12d, 0x8(%rbx)
movl $0x25, 0x4(%r11)
movl $0x20, 0x4(%rax)
movl %r10d, 0x8(%r11)
orl $-0x1, 0x8(%rax)
movl %r8d, 0xc(%rbx)
movl %r9d, 0x10(%rbx)
jmp 0x3289
callq 0x3170
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %rbx
movl 0x40(%rsp), %ebp
testl %esi, %esi
je 0x32dd
testl %r13d, %r13d
je 0x32dd
testl %r12d, %r12d
je 0x32dd
testl %r15d, %r15d
je 0x32dd
testl %r14d, %r14d
je 0x32dd
testl %ebp, %ebp
je 0x32dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x334a
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x334a
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x334a
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x334a
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x334a
pushq $0x6
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x334a
leaq 0x2580(%rip), %rdi      # 0x58b4
leaq 0x2584(%rip), %rsi      # 0x58bf
leaq 0x2592(%rip), %rcx      # 0x58d4
pushq $0x28
popq %rdx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 0x334f
retq
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leaq 0x25a7(%rip), %rdi      # 0x5906
movl %edx, %esi
xorl %eax, %eax
callq 0x10a0
cmpb $0x0, (%r14)
je 0x3381
leaq 0x25bd(%rip), %rdi      # 0x5932
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10a0
leaq 0x2d7e(%rip), %rdi      # 0x6106
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
xorl %esi, %esi
cmpl $0x3f, 0xc151(%rip)     # 0xf880
setl %sil
callq 0x3394
movslq 0xc141(%rip), %rax      # 0xf880
leaq 0x1(%rax), %rcx
movl %ecx, 0xc137(%rip)      # 0xf880
leaq 0xc140(%rip), %rcx      # 0xf890
leaq 0x4(%rcx,%rax,4), %rsi
pushq $0x1
popq %rdi
callq 0x3791
cmpb $0x0, (%rbx)
je 0x3784
movl 0xc118(%rip), %edi      # 0xf880
addl %edi, %edi
callq 0x37b8
leaq 0x222c(%rip), %rdi      # 0x59a2
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x10a0
leaq 0x2967(%rip), %rdi      # 0x60f2
popq %rbx
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: FlipFlop
void FlipFlop(int bNouvelEtat,int *pbFlipFlop){
	//bascule *pbFlipFlop après avoir vérifié que la valeur booléenne de bNouvelEtat bascule effectivt à chaque appel de FlipFlop
	/*if (bNouvelEtat==*pbFlipFlop)
		Stop(knStopFlipFloP);*/
	assert(bNouvelEtat!=*pbFlipFlop);
	*pbFlipFlop=bNouvelEtat;
}

// Assembly:
cmpl %edi, (%rsi)
je 0x3798
movl %edi, (%rsi)
retq
pushq %rax
leaq 0x247c(%rip), %rdi      # 0x5c1c
leaq 0x2118(%rip), %rsi      # 0x58bf
leaq 0x2487(%rip), %rcx      # 0x5c35
movl $0x25b, %edx            # imm = 0x25B
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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, %r14
callq 0x1090
movq %rax, %rbx
xorl %edi, %edi
testq %r14, %r14
setne %dil
xorl %esi, %esi
cmpl $0x0, 0xc09f(%rip)      # 0xf880
setg %sil
callq 0x3394
movslq 0xc08f(%rip), %rax      # 0xf880
leaq 0xc098(%rip), %rcx      # 0xf890
leaq (%rcx,%rax,4), %rsi
xorl %edi, %edi
callq 0x3791
testl %ebx, %ebx
je 0x382a
movl 0xc073(%rip), %edi      # 0xf880
addl %edi, %edi
callq 0x37b8
leaq 0x21a1(%rip), %rdi      # 0x59bc
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10a0
jmp 0x3836
leaq 0x28d7(%rip), %rdi      # 0x6108
callq 0x1070
movl 0xc044(%rip), %ecx      # 0xf880
leal -0x1(%rcx), %eax
movl %eax, 0xc03b(%rip)      # 0xf880
testl %ecx, %ecx
jle 0x3862
testl %ebx, %ebx
jne 0x385a
testl %eax, %eax
jne 0x3881
cmpl $0x0, 0xc02c(%rip)      # 0xf884
js 0x38a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x216c(%rip), %rdi      # 0x59d5
leaq 0x204f(%rip), %rsi      # 0x58bf
leaq 0x2168(%rip), %rcx      # 0x59df
movl $0xc7, %edx
callq 0x10b0
leaq 0x216b(%rip), %rdi      # 0x59f3
leaq 0x2030(%rip), %rsi      # 0x58bf
leaq 0x2149(%rip), %rcx      # 0x59df
movl $0xc9, %edx
callq 0x10b0
leaq 0x2156(%rip), %rdi      # 0x59fd
leaq 0x2011(%rip), %rsi      # 0x58bf
leaq 0x212a(%rip), %rcx      # 0x59df
movl $0xca, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rdi
callq 0x1110
movq %rax, %rbx
callq 0x1180
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
testw $0x2008, %ax            # imm = 0x2008
je 0x3938
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x3957
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x20c9(%rip), %rdi      # 0x5a08
leaq 0x1f79(%rip), %rsi      # 0x58bf
leaq 0x2100(%rip), %rcx      # 0x5a4d
movl $0xe5, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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, 0xc02d(%rip)      # 0xf990
je 0x39cb
movslq 0xd044(%rip), %rax      # 0x109b0
leal 0x1(%rax), %ecx
movl %ecx, 0xd03b(%rip)      # 0x109b0
leaq 0xc834(%rip), %rcx      # 0x101b0
movq %rdi, (%rcx,%rax,8)
cmpq $0xfe, %rax
jl 0x3a3f
leaq 0x231f(%rip), %rdi      # 0x5cb2
callq 0x4080
xorl %r14d, %r14d
leaq 0xc7fe(%rip), %rbx      # 0x101a0
leaq 0xbff7(%rip), %r15      # 0xf9a0
cmpq $0x800, %r14            # imm = 0x800
je 0x3a2d
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x39c0
callq 0x1030
andq $0x0, (%r14,%r15)
addq $0x8, %r14
jmp 0x39a9
movslq 0xc7ce(%rip), %rax      # 0x101a0
leal 0x1(%rax), %ecx
movl %ecx, 0xc7c5(%rip)      # 0x101a0
leaq 0xbfbe(%rip), %rcx      # 0xf9a0
movq %rdi, (%rcx,%rax,8)
cmpq $0xfe, %rax
jl 0x3a3f
leaq 0x227d(%rip), %rdi      # 0x5c72
callq 0x4080
xorl %r14d, %r14d
leaq 0xcfac(%rip), %rbx      # 0x109b0
leaq 0xc7a5(%rip), %r15      # 0x101b0
cmpq $0x800, %r14            # imm = 0x800
je 0x3a2d
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x3a22
callq 0x1030
andq $0x0, (%r14,%r15)
addq $0x8, %r14
jmp 0x3a0b
pushq $0x1
popq %rax
subl 0xbf5a(%rip), %eax      # 0xf990
movl %eax, 0xbf54(%rip)      # 0xf990
andl $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
testq %r14, %r14
setne %dil
xorl %esi, %esi
testq %rbx, %rbx
setne %sil
callq 0x3394
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 0x3957
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %edi, %edi
testq %r14, %r14
setne %dil
xorl %esi, %esi
testq %rbx, %rbx
setne %sil
callq 0x3394
movq %r14, %rdi
callq 0x1090
movq %rax, %r15
movq %rbx, %rdi
callq 0x1090
leaq (%rax,%r15), %rcx
testl %ecx, %ecx
js 0x3bae
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 0x3b8c
movq %r15, %rdi
callq 0x1090
movw $0x20, (%r15,%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r15, %rdi
callq 0x3957
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1ed2(%rip), %rdi      # 0x5a87
leaq 0x1d03(%rip), %rsi      # 0x58bf
leaq 0x1ecf(%rip), %rcx      # 0x5a92
movl $0x10c, %edx            # imm = 0x10C
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 0x3ebe
movq %rdi, %rbx
callq 0x1090
movq %rax, %r14
xorl %eax, %eax
leaq 0xc(%rsp), %r15
xorl %ebp, %ebp
movl %eax, 0xc(%rsp)
cmpl %r14d, %eax
jge 0x3eab
cltq
movsbq (%rbx,%rax), %r12
callq 0x1180
movq (%rax), %rax
testb $0xc, 0x1(%rax,%r12,2)
jne 0x3ea1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3efc
testl %eax, %eax
je 0x3ea3
incl %ebp
movl 0xc(%rsp), %eax
incl %eax
jmp 0x3e72
testl %ebp, %ebp
js 0x3edd
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a8b(%rip), %rdi      # 0x5950
leaq 0x19f3(%rip), %rsi      # 0x58bf
leaq 0x1bda(%rip), %rcx      # 0x5aad
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x10b0
leaq 0x1be0(%rip), %rdi      # 0x5ac4
leaq 0x19d4(%rip), %rsi      # 0x58bf
leaq 0x1bbb(%rip), %rcx      # 0x5aad
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 0x3f80
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ebp
callq 0x1090
xorl %edi, %edi
movl %ebp, %esi
movl %eax, %edx
callq 0x419e
movslq (%rbx), %r15
movsbq (%r14,%r15), %r12
callq 0x1180
movq (%rax), %rax
movzwl (%rax,%r12,2), %eax
andl $0x400, %eax            # imm = 0x400
jne 0x3f64
movq %r14, %rdi
callq 0x1090
movq %rax, %rcx
movl $0x0, %eax
cmpq %r15, %rcx
jbe 0x3f64
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44a5
testl %eax, %eax
je 0x3f6d
pushq $0x1
popq %rax
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 0x40b3
leaq 0x19c9(%rip), %rdi      # 0x5950
leaq 0x1931(%rip), %rsi      # 0x58bf
leaq 0x1cba(%rip), %rcx      # 0x5c4f
movl $0x297, %edx            # imm = 0x297
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x4008
movq %rsi, %rbx
movl %edi, %ebp
testl %edi, %edi
je 0x3fde
movq %rbx, %rdi
callq 0x1090
incl %eax
movslq %eax, %rdi
jmp 0x3fe1
pushq $0x1
popq %rdi
callq 0x1110
movq %rax, %r14
testl %ebp, %ebp
je 0x3ff8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1050
movq %r14, %rdi
callq 0x3957
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1ac3(%rip), %rdi      # 0x5ad2
leaq 0x18a9(%rip), %rsi      # 0x58bf
leaq 0x1ac0(%rip), %rcx      # 0x5add
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
xorl %edi, %edi
testq %rsi, %rsi
setne %dil
xorl %esi, %esi
testq %rdx, %rdx
setne %sil
callq 0x3394
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 0x3957
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a6d(%rip), %rdi      # 0x5af8
xorl %eax, %eax
callq 0x10a0
leaq 0x1685(%rip), %rdi      # 0x571e
leaq 0x7(%rsp), %rsi
xorl %eax, %eax
callq 0x1130
leaq 0x2070(%rip), %rdi      # 0x611c
callq 0x1070
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: bConsonnE2
int bConsonnE2(char *sString,int *pnCodeCaractereRg){
	//sString[*pnCodeCaractereRg] ou Chaine[*pnCodeCaractereRg..*pnCodeCaractereRg+1] code une consonne;si vrai et 2 codes, passe au code suivant
	int nCar;
	char cCode;
    #define knConsonne1LiM 21
    #define knConsonne2LiM 04
	int nConsonne1[knConsonne1LiM]={64,65,66,67,69,70,71,73,74,75,76,77,79,80,81,82,83,85,86,87,89};//consonnes sans signe diacritique
	int nConsonne2[knConsonne2LiM]={79,89,111,121};//ççÑñ";
	int bConsonne2=0;
	Vrai2(sString!=0,pnCodeCaractereRg!=0);
	Croit(0,2,strlen(sString));
	Croit(0,*pnCodeCaractereRg,strlen(sString));
	cCode=sString[*pnCodeCaractereRg];
	bConsonne2=isalpha(cCode);//consonne ou voyelle sans signe diacritique (accents,cédille,tilde...)
	if (bConsonne2){//consonne?
		assert(0);//ie code actuellt non exécuté vu le contexte des appels à bConsonnE2()
		for (bConsonne2=0,nCar=0; nCar<knConsonne1LiM; nCar++)
			bConsonne2=bConsonne2||(cCode==-nConsonne1[nCar]);
		}
	else if (*pnCodeCaractereRg<strlen(sString)) {//l'accès à sString[nCodeCaractereRg+1] est valide
		if (cCode==kcEchappemenT1){
			cCode=sString[*pnCodeCaractereRg+1];
			for (nCar=0; nCar<knConsonne2LiM; nCar++)
				bConsonne2=bConsonne2||(cCode==-nConsonne2[nCar]);
			if (bConsonne2)
				(*pnCodeCaractereRg)++;
		}
	}
	return(bConsonne2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
testq %r14, %r14
setne %dil
xorl %esi, %esi
testq %rbx, %rbx
setne %sil
callq 0x3394
movq %r14, %rdi
callq 0x1090
xorl %ebp, %ebp
pushq $0x2
popq %rsi
xorl %edi, %edi
movl %eax, %edx
callq 0x419e
movl (%rbx), %r15d
movq %r14, %rdi
callq 0x1090
xorl %edi, %edi
movl %r15d, %esi
movl %eax, %edx
callq 0x419e
movslq (%rbx), %r15
movsbq (%r14,%r15), %r12
callq 0x1180
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r12,2)
jne 0x417f
movq %r14, %rdi
callq 0x1090
cmpb $-0x3d, %r12b
jne 0x4174
cmpq %r15, %rax
jbe 0x4174
movsbl 0x1(%r14,%r15), %eax
xorl %ecx, %ecx
pushq $0x1
popq %rdx
leaq 0x201e(%rip), %rsi      # 0x6160
xorl %edi, %edi
cmpq $0x10, %rcx
je 0x4163
testl %edi, %edi
movl %edx, %edi
jne 0x415d
xorl %edi, %edi
movl (%rcx,%rsi), %r8d
addl %eax, %r8d
sete %dil
addq $0x4, %rcx
jmp 0x4144
testl %edi, %edi
je 0x4172
incl %r15d
movl %r15d, (%rbx)
pushq $0x1
popq %rbp
jmp 0x4174
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18da(%rip), %rdi      # 0x5a60
leaq 0x1732(%rip), %rsi      # 0x58bf
leaq 0x1984(%rip), %rcx      # 0x5b18
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sCouple
char *sCouple(int iEntierA,int iEntierB){
	//rend la chaîne (iEntierA,iEntierB)	
	char *sCouple=sP(sC3(sEntier(iEntierA),",",sEntier(iEntierB)));
	OctetGereR(sCouple);
	return(sCouple);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
callq 0x426b
movq %rax, %r14
movl %ebx, %edi
callq 0x426b
leaq 0x193f(%rip), %rsi      # 0x5b36
movq %r14, %rdi
movq %rax, %rdx
callq 0x3bf9
movq %rax, %rdi
callq 0x4220
movq %rax, %rbx
movq %rax, %rdi
callq 0x3957
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sP
char *sP(char *sEntreParenthese){
	//rend sEntreParenthese précédé de "(" et suivi de ")"
	assert(sEntreParenthese!=0);	
	char *sP=sC3("(",sEntreParenthese,")");
	OctetGereR(sP);
	return(sP);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x424c
movq %rdi, %rsi
leaq 0x1dbe(%rip), %rdi      # 0x5fee
leaq 0x1ad7(%rip), %rdx      # 0x5d0e
callq 0x3bf9
movq %rax, %rbx
movq %rax, %rdi
callq 0x3957
movq %rbx, %rax
popq %rbx
retq
leaq 0x1d76(%rip), %rdi      # 0x5fc9
leaq 0x1665(%rip), %rsi      # 0x58bf
leaq 0x1d7c(%rip), %rcx      # 0x5fdd
movl $0x362, %edx            # imm = 0x362
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sEntier
char *sEntier(int iEntier){
	//convertit iEntier en chaîne de chiffres décimaux: 24 donne "24", -5 donne "-5".
	char *sEntier=malloc(23+kuAntiSlashZerO);//2**64=4 milliards au carré = 16*(10**18) dc "4"+18 zéros=19 chiffres; ajouter 1 caractère pr le signe "-".
	sprintf(sEntier,"%d",iEntier);//iEntier tient forcément ds sEntier vu allocation généreuse: 4 octets alloués là où 21 suffisent.
	return(sEntier);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x18
popq %rdi
callq 0x1110
movq %rax, %r14
leaq 0xf4a(%rip), %rsi       # 0x51cd
movq %rax, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1150
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sFois
char *sFois(int nFois,char cMotif){
	//juxtapose nFois cMotif
	int uF;
	char *sFwa;
	char cFwa[2];
	Vrai2(nFois>=0,isprint(cMotif));//implique 1 code caractère par caractère,dc cMotif ne peut coder un "é" car il est occupe 2 codes caractères.
	sFwa=malloc(nFois+kuAntiSlashZerO);
	cFwa[0]=cMotif;
	cFwa[1]='\0';
	strcpy(sFwa,cFwa);
	for (uF=2;uF<=nFois;uF++)
		strcat(sFwa,cFwa);
	OctetGereR(sFwa);
	return(sFwa);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl %edi, %r14d
notl %r14d
shrl $0x1f, %r14d
callq 0x1180
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %esi
andl $0x4000, %esi           # imm = 0x4000
movl %r14d, %edi
callq 0x3394
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0x1110
movq %rax, %r14
leaq 0x6(%rsp), %r15
movb %bpl, (%r15)
movb $0x0, 0x1(%r15)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1050
pushq $0x2
popq %rbp
movq %r14, %rdi
cmpl %ebx, %ebp
jg 0x436a
movq %r15, %rsi
callq 0x1140
incl %ebp
jmp 0x4357
callq 0x3957
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq