LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 $0x32, %eax
jge 0x31df
leaq 0x3563(%rip), %rdi      # 0x6736
xorl %eax, %eax
callq 0x10a0
jmp 0x329d
movl %r12d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq %r15, 0x20(%rsp)
leaq 0x35d0(%rip), %rdi      # 0x67c4
leaq 0x355f(%rip), %r12      # 0x675a
leaq 0x339f(%rip), %r13      # 0x65a1
leaq 0x1c(%rsp), %rbx
leaq 0x18(%rsp), %rbp
leaq 0x3433(%rip), %r15      # 0x6646
callq 0x1070
movq %r12, %rdi
xorl %eax, %eax
callq 0x10a0
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
movq %r15, %rdi
jne 0x3213
movl %eax, %r8d
imulq $0x2d0, %rcx, %rax      # imm = 0x2D0
addq %r14, %rax
leaq (%r8,%r8,2), %rdx
cmpl $0x20, 0x4(%rax,%rdx,4)
movq %r15, %rdi
jne 0x3213
leaq (%rax,%rdx,4), %rax
cmpl $0x1, (%rax)
movq %r15, %rdi
jne 0x3213
movl $0x0, (%rsp)
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %esi
movq %r14, %rdx
movq 0x20(%rsp), %r9
callq 0x2e62
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_O1/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), %r8
movl 0xd5a0(%rip), %ecx      # 0x10870
decl %ecx
cmpl %ecx, %r8d
jge 0x3330
leaq (%r8,%r8,4), %rcx
leaq (%rsi,%rcx,4), %rcx
addq $0x24, %rcx
movq %r8, %rdx
incq %rdx
movslq -0x4(%rcx), %rsi
movslq (%rcx), %r9
imulq $0x2d0, %rsi, %r10      # imm = 0x2D0
addq %rdi, %r10
leaq (%r9,%r9,2), %r11
movl %r8d, 0x8(%r10,%r11,4)
movl -0x10(%rcx), %r8d
movl %r8d, -0x24(%rcx)
movq -0xc(%rcx), %r8
movq %r8, -0x20(%rcx)
movl %esi, -0x18(%rcx)
movl %r9d, -0x14(%rcx)
movslq 0xd54f(%rip), %rsi      # 0x10870
decq %rsi
addq $0x14, %rcx
movq %rdx, %r8
cmpq %rsi, %rdx
jl 0x32e6
movabsq $-0xffffffd6, %rcx      # imm = 0xFFFFFFFF0000002A
movq %rcx, 0x4(%rax)
decl 0xd52c(%rip)            # 0x10870
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r11
imulq $0x2d0, %rax, %r10      # imm = 0x2D0
addq %rdi, %r10
leaq (%r11,%r11,2), %r11
movl 0x8(%r10,%r11,4), %eax
movslq %eax, %r15
movslq %r8d, %rbx
movslq %r9d, %r14
imulq $0x2d0, %rbx, %rbx      # imm = 0x2D0
addq %rdi, %rbx
leaq (%r14,%r14,2), %r14
cmpl $0x2a, 0x4(%rbx,%r14,4)
jne 0x3392
movl 0x30(%rsp), %ebp
leaq (%r15,%r15,4), %r12
movl %ebp, 0x4(%rsi,%r12,4)
leaq (%r15,%r15,4), %r15
movl 0x4(%rsi,%r15,4), %ebp
testl %ebp, %ebp
jle 0x33e3
leaq (%rsi,%r15,4), %r15
movl 0x8(%r15), %r12d
testl %r12d, %r12d
jle 0x33e3
leaq (%r10,%r11,4), %rcx
leaq (%rbx,%r14,4), %rdx
decl %ebp
movl %ebp, 0x4(%r15)
decl %r12d
movl %r12d, 0x8(%r15)
movl $0x25, 0x4(%rdx)
movl $0x20, 0x4(%rcx)
movl %eax, 0x8(%rdx)
movl $0xffffffff, 0x8(%rcx)  # imm = 0xFFFFFFFF
movl %r8d, 0xc(%r15)
movl %r9d, 0x10(%r15)
jmp 0x33e8
callq 0x32ae
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x343e
testl %r13d, %r13d
je 0x343e
testl %r12d, %r12d
je 0x343e
testl %r15d, %r15d
je 0x343e
testl %ebp, %ebp
je 0x343e
testl %r14d, %r14d
je 0x343e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %edx
callq 0x34b9
movq %rbx, %rdi
movl %r13d, %esi
movl $0x2, %edx
callq 0x34b9
movq %rbx, %rdi
movl %r12d, %esi
movl $0x3, %edx
callq 0x34b9
movq %rbx, %rdi
movl %r15d, %esi
movl $0x4, %edx
callq 0x34b9
movq %rbx, %rdi
movl %ebp, %esi
movl $0x5, %edx
callq 0x34b9
movq %rbx, %rdi
movl %r14d, %esi
movl $0x6, %edx
callq 0x34b9
leaq 0x3413(%rip), %rdi      # 0x68b4
leaq 0x3417(%rip), %rsi      # 0x68bf
leaq 0x3425(%rip), %rcx      # 0x68d4
movl $0x28, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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 0x34be
retq
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leaq 0x3438(%rip), %rdi      # 0x6906
movl %edx, %esi
xorl %eax, %eax
callq 0x10a0
cmpb $0x0, (%r14)
je 0x34f0
leaq 0x344e(%rip), %rdi      # 0x6932
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10a0
leaq 0x3c0f(%rip), %rdi      # 0x7106
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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, 0xce91(%rip)     # 0x10880
setl %dl
movl $0x1, (%rsp)
leaq 0x288c(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
movslq 0xce63(%rip), %rax      # 0x10880
leaq 0x1(%rax), %rdi
movl %edi, 0xce59(%rip)      # 0x10880
leaq 0xce62(%rip), %rcx      # 0x10890
cmpl $0x1, 0x4(%rcx,%rax,4)
je 0x3a78
movl $0x1, 0x4(%rcx,%rax,4)
cmpb $0x0, (%rbx)
je 0x3a67
addl %edi, %edi
movl $0x20, %esi
callq 0x48ec
leaq 0x2f4d(%rip), %rdi      # 0x69a2
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x10a0
leaq 0x3684(%rip), %rdi      # 0x70f2
addq $0x10, %rsp
popq %rbx
jmp 0x1070
leaq 0x319d(%rip), %rdi      # 0x6c1c
leaq 0x2e39(%rip), %rsi      # 0x68bf
leaq 0x31a8(%rip), %rcx      # 0x6c35
movl $0x25b, %edx            # imm = 0x25B
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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 %esi, %esi
testq %r14, %r14
setne %sil
xorl %edx, %edx
cmpl $0x0, 0xcd97(%rip)      # 0x10880
setg %dl
movl $0x1, (%rsp)
leaq 0x2792(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
movslq 0xcd69(%rip), %rdi      # 0x10880
leaq 0xcd72(%rip), %rax      # 0x10890
cmpl $0x0, (%rax,%rdi,4)
je 0x3b89
movl $0x0, (%rax,%rdi,4)
testl %ebx, %ebx
je 0x3b51
addl %edi, %edi
movl $0x20, %esi
callq 0x48ec
leaq 0x2e7a(%rip), %rdi      # 0x69bc
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10a0
jmp 0x3b5d
leaq 0x35b0(%rip), %rdi      # 0x7108
callq 0x1070
movl 0xcd1d(%rip), %ecx      # 0x10880
leal -0x1(%rcx), %eax
movl %eax, 0xcd14(%rip)      # 0x10880
testl %ecx, %ecx
jle 0x3ba8
testl %ebx, %ebx
jne 0x3b81
testl %eax, %eax
jne 0x3bc7
cmpl $0x0, 0xcd05(%rip)      # 0x10884
js 0x3be6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x308c(%rip), %rdi      # 0x6c1c
leaq 0x2d28(%rip), %rsi      # 0x68bf
leaq 0x3097(%rip), %rcx      # 0x6c35
movl $0x25b, %edx            # imm = 0x25B
callq 0x10b0
leaq 0x2e26(%rip), %rdi      # 0x69d5
leaq 0x2d09(%rip), %rsi      # 0x68bf
leaq 0x2e22(%rip), %rcx      # 0x69df
movl $0xc7, %edx
callq 0x10b0
leaq 0x2e25(%rip), %rdi      # 0x69f3
leaq 0x2cea(%rip), %rsi      # 0x68bf
leaq 0x2e03(%rip), %rcx      # 0x69df
movl $0xc9, %edx
callq 0x10b0
leaq 0x2e10(%rip), %rdi      # 0x69fd
leaq 0x2ccb(%rip), %rsi      # 0x68bf
leaq 0x2de4(%rip), %rcx      # 0x69df
movl $0xca, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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 0x3c81
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x3ca0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2d80(%rip), %rdi      # 0x6a08
leaq 0x2c30(%rip), %rsi      # 0x68bf
leaq 0x2db7(%rip), %rcx      # 0x6a4d
movl $0xe5, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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, 0xcce4(%rip)      # 0x10990
je 0x3d17
movslq 0xdcfb(%rip), %rax      # 0x119b0
leal 0x1(%rax), %ecx
movl %ecx, 0xdcf2(%rip)      # 0x119b0
leaq 0xd4eb(%rip), %rcx      # 0x111b0
movq %rdi, (%rcx,%rax,8)
cmpq $0xfe, %rax
jl 0x3d91
leaq 0x2fd6(%rip), %rdi      # 0x6cb2
callq 0x4601
xorl %r14d, %r14d
leaq 0xccb5(%rip), %r15      # 0x109a0
leaq 0xd4ae(%rip), %rbx      # 0x111a0
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x3d00
callq 0x1030
movq $0x0, (%r14,%r15)
addq $0x8, %r14
cmpq $0x800, %r14            # imm = 0x800
jne 0x3cf2
jmp 0x3d7a
movslq 0xd482(%rip), %rax      # 0x111a0
leal 0x1(%rax), %ecx
movl %ecx, 0xd479(%rip)      # 0x111a0
leaq 0xcc72(%rip), %rcx      # 0x109a0
movq %rdi, (%rcx,%rax,8)
cmpq $0xfe, %rax
jl 0x3d91
leaq 0x2f31(%rip), %rdi      # 0x6c72
callq 0x4601
xorl %r14d, %r14d
leaq 0xd460(%rip), %r15      # 0x111b0
leaq 0xdc59(%rip), %rbx      # 0x119b0
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x3d65
callq 0x1030
movq $0x0, (%r14,%r15)
addq $0x8, %r14
cmpq $0x800, %r14            # imm = 0x800
jne 0x3d57
movl $0x1, %eax
subl 0xcc0b(%rip), %eax      # 0x10990
movl %eax, 0xcc05(%rip)      # 0x10990
movl $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x246d(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
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 0x3ca0
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23db(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
movq %r14, %rdi
callq 0x1090
movq %rax, %r15
movq %rbx, %rdi
callq 0x1090
leaq (%rax,%r15), %rcx
testl %ecx, %ecx
js 0x3f44
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 0x3f22
movq %r15, %rdi
callq 0x1090
movw $0x20, (%r15,%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r15, %rdi
callq 0x3ca0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2b3c(%rip), %rdi      # 0x6a87
leaq 0x296d(%rip), %rsi      # 0x68bf
leaq 0x2b39(%rip), %rcx      # 0x6a92
movl $0x10c, %edx            # imm = 0x10C
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x0, 0xc(%rsp)
testq %rdi, %rdi
je 0x43ff
movq %rdi, %rbx
callq 0x1090
movq %rax, %r14
movl $0x0, 0xc(%rsp)
xorl %ebp, %ebp
testl %r14d, %r14d
jle 0x43ec
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 0x43db
movq %rbx, %rdi
movq %r12, %rsi
callq 0x443d
testl %eax, %eax
je 0x43dd
incl %ebp
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %r14d, %eax
jl 0x43bb
testl %ebp, %ebp
js 0x441e
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x254a(%rip), %rdi      # 0x6950
leaq 0x24b2(%rip), %rsi      # 0x68bf
leaq 0x2699(%rip), %rcx      # 0x6aad
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x10b0
leaq 0x269f(%rip), %rdi      # 0x6ac4
leaq 0x2493(%rip), %rsi      # 0x68bf
leaq 0x267a(%rip), %rcx      # 0x6aad
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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 0x44c5
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ebp
callq 0x1090
xorl %edi, %edi
movl %ebp, %esi
movl %eax, %edx
callq 0x4745
movslq (%rbx), %r15
movsbq (%r14,%r15), %r12
callq 0x1180
movq (%rax), %rax
movzwl (%rax,%r12,2), %eax
andl $0x400, %eax            # imm = 0x400
jne 0x44a9
movq %r14, %rdi
callq 0x1090
movq %rax, %rcx
movl $0x0, %eax
cmpq %r15, %rcx
jbe 0x44a9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4ac0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x44b2
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 0x4634
leaq 0x2484(%rip), %rdi      # 0x6950
leaq 0x23ec(%rip), %rsi      # 0x68bf
leaq 0x2775(%rip), %rcx      # 0x6c4f
movl $0x297, %edx            # imm = 0x297
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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 0x4563
movq %rsi, %rbx
movl %edi, %ebp
testl %edi, %edi
je 0x4537
movq %rbx, %rdi
callq 0x1090
incl %eax
movslq %eax, %rdi
jmp 0x453c
movl $0x1, %edi
callq 0x1110
movq %rax, %r14
testl %ebp, %ebp
je 0x4553
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1050
movq %r14, %rdi
callq 0x3ca0
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2568(%rip), %rdi      # 0x6ad2
leaq 0x234e(%rip), %rsi      # 0x68bf
leaq 0x2565(%rip), %rcx      # 0x6add
movl $0x1ce, %edx            # imm = 0x1CE
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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 0x1cdb(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
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 0x3ca0
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24ec(%rip), %rdi      # 0x6af8
xorl %eax, %eax
callq 0x10a0
leaq 0x2104(%rip), %rdi      # 0x671e
leaq 0x7(%rsp), %rsi
xorl %eax, %eax
callq 0x1130
leaq 0x2aef(%rip), %rdi      # 0x711c
callq 0x1070
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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
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 0x1c27(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
movq %r14, %rdi
callq 0x1090
xorl %ebp, %ebp
xorl %edi, %edi
movl $0x2, %esi
movl %eax, %edx
callq 0x4745
movl (%rbx), %r15d
movq %r14, %rdi
callq 0x1090
xorl %edi, %edi
movl %r15d, %esi
movl %eax, %edx
callq 0x4745
movslq (%rbx), %r15
movsbq (%r14,%r15), %r12
callq 0x1180
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r12,2)
jne 0x4726
movq %r14, %rdi
callq 0x1090
cmpb $-0x3d, %r12b
jne 0x4717
cmpq %r15, %rax
jbe 0x4717
movsbl 0x1(%r14,%r15), %eax
xorl %ecx, %ecx
leaq 0x2a7c(%rip), %rdx      # 0x7160
xorl %esi, %esi
testl %esi, %esi
movl $0x1, %esi
jne 0x46fa
xorl %esi, %esi
movl (%rcx,%rdx), %edi
addl %eax, %edi
sete %sil
addq $0x4, %rcx
cmpq $0x10, %rcx
jne 0x46e6
testl %esi, %esi
je 0x4715
incl %r15d
movl %r15d, (%rbx)
movl $0x1, %ebp
jmp 0x4717
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2333(%rip), %rdi      # 0x6a60
leaq 0x218b(%rip), %rsi      # 0x68bf
leaq 0x23dd(%rip), %rcx      # 0x6b18
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl $0x18, %edi
callq 0x1110
movq %rax, %r14
leaq 0x1a2b(%rip), %r15      # 0x61cd
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
movl $0x18, %edi
callq 0x1110
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1150
leaq 0x2362(%rip), %rsi      # 0x6b36
movq %r14, %rdi
callq 0x3df1
movq %rax, %rdi
movq %r12, %rsi
callq 0x3df1
movq %rax, %rdi
callq 0x4806
movq %rax, %rbx
movq %rax, %rdi
callq 0x3ca0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x483a
movq %rdi, %rsi
leaq 0x27d8(%rip), %rdi      # 0x6fee
callq 0x3df1
leaq 0x24ec(%rip), %rsi      # 0x6d0e
movq %rax, %rdi
callq 0x3df1
movq %rax, %rbx
movq %rax, %rdi
callq 0x3ca0
movq %rbx, %rax
popq %rbx
retq
leaq 0x2788(%rip), %rdi      # 0x6fc9
leaq 0x2077(%rip), %rsi      # 0x68bf
leaq 0x278e(%rip), %rcx      # 0x6fdd
movl $0x362, %edx            # imm = 0x362
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x18, %edi
callq 0x1110
movq %rax, %r14
leaq 0x195a(%rip), %rsi      # 0x61cd
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_O1/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
subq $0x18, %rsp
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), %edx
andl $0x4000, %edx           # imm = 0x4000
movl $0x1, (%rsp)
leaq 0x1965(%rip), %rdi      # 0x628c
movl %r14d, %esi
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0x1110
movq %rax, %r14
leaq 0x16(%rsp), %rsi
movb %bpl, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rax, %rdi
callq 0x1050
cmpl $0x2, %ebx
jl 0x497d
decl %ebx
leaq 0x16(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1140
decl %ebx
jne 0x496e
movq %r14, %rdi
callq 0x3ca0
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sEntierAvecSigne
char *sEntierAvecSigne(int iEntier){
	//// "+5" ou "-5" ou " 0"
	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
movl $0x18, %edi
callq 0x1110
movq %rax, %r14
leaq 0x2261(%rip), %rsi      # 0x6c0e
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_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sEst
char *sEst(int bAssertion){
	//rend "est" tel quel,ou négativé avec "n'"..."pas" si bAssertion est faux 
	#define kuEstLg 3//"est"
	#define kuNestPasLg 4//"n'est pas"
	char *sEst=malloc( kuAntiSlashZerO + (bAssertion)? kuEstLg : kuNestPasLg);
	if (bAssertion)
		strcat(sEst,"est");
	else strcpy(sEst,"n'est pas");
	OctetGereR(sEst);
	return(sEst);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
xorl %edi, %edi
cmpl $-0x1, %ebp
sete %dil
addq $0x3, %rdi
callq 0x1110
movq %rax, %rbx
testl %ebp, %ebp
je 0x49f3
movq %rbx, %rdi
callq 0x1090
movl $0x747365, (%rbx,%rax)  # imm = 0x747365
jmp 0x4a06
movabsq $0x617020747365276e, %rax # imm = 0x617020747365276E
movq %rax, (%rbx)
movw $0x73, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3ca0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: nHasard
int nHasard(int uBorneLim){
	//rend un nombre aléatoire ds [0..uBorneLim[
	int nHasard;
	Croit(1,uBorneLim,kuIntegerMaX-1);
	nHasard=rand()%uBorneLim;
	Croit(0,nHasard,uBorneLim-1);
	return(nHasard);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x1, %edi
movl %ebx, %esi
movl $0x7ffffffe, %edx       # imm = 0x7FFFFFFE
callq 0x4745
callq 0x1170
cltd
idivl %ebx
movl %edx, %ebp
decl %ebx
xorl %edi, %edi
movl %edx, %esi
movl %ebx, %edx
callq 0x4745
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: uHasard
int uHasard(int uBorneMax){
	//rend un nombre aléatoire ds [1..nBorneMax]
	int uHasard;
	Croit(1,uBorneMax,kuIntegerMaX);
	uHasard=1+rand()%uBorneMax;
	Croit(1,uHasard,uBorneMax);
	return(uHasard);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x1, %edi
movl %ebx, %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x4745
callq 0x1170
cltd
idivl %ebx
leal 0x1(%rdx), %ebp
movl $0x1, %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x4745
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: bVoyellE2
int bVoyellE2(char *sString,int *pnCodeCaractereRg){
	//sString[*pnCodeCaractereRg] ou Chaine[*pnCodeCaractereRg..*pnCodeCaractereRg+1] code une voyelle;si vrai et 2 codes, passe au code suivant
	int nCar;
	char cCode;
    #define knVoyelle1LiM 29
	int nVoyelle1[knVoyelle1LiM]={65,68,69,71,74,76,81,82,86,87,     88,92,93,94,96,100,101,103,106,108,      113,114,117,118,119,124,125,126,128};
    #define knVoyelle2LiM 01
	int nVoyelle2[knVoyelle2LiM]={72};//aeiouyéàèùâêîôûäïöüÿAEIOUYÂÊÎÔÛÉÀÙÂÊÎÔÛÄËÏÖÜŸã";//piqûre Haüy;nValide2[1] pour le seul Ÿ
	int bVoyellE2=0;
	assert(sString!=0);
	Croit(0,*pnCodeCaractereRg,strlen(sString));
	cCode=sString[*pnCodeCaractereRg];
	bVoyellE2=isalpha(cCode);
	if (bVoyellE2){//voyelle ou consonne?
		for (bVoyellE2=0,nCar=0; nCar<knVoyelle1LiM; nCar++)
			bVoyellE2=bVoyellE2||(cCode==-nVoyelle1[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<knVoyelle1LiM; nCar++)
				bVoyellE2=bVoyellE2||(cCode==-nVoyelle1[nCar]);
			if (bVoyellE2)
				(*pnCodeCaractereRg)++;//2 codes pour un seul caractère
		}
		else if (cCode==kcEchappemenT2) {
			cCode=sString[*pnCodeCaractereRg+1];
			for (nCar=0; nCar<knVoyelle2LiM; nCar++)
				bVoyellE2= bVoyellE2 || (cCode==-nVoyelle2[nCar]);
			if (bVoyellE2)
				(*pnCodeCaractereRg)++;//2 codes pour un seul caractère
		}
	}
	return(bVoyellE2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4bb1
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ebp
callq 0x1090
xorl %r13d, %r13d
xorl %edi, %edi
movl %ebp, %esi
movl %eax, %edx
callq 0x4745
movslq (%rbx), %r15
movsbq (%r14,%r15), %r12
callq 0x1180
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r12,2)
jne 0x4b62
movq %r14, %rdi
callq 0x1090
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
jbe 0x4b8d
cmpb $-0x3b, %r12b
je 0x4b9c
movzbl %r12b, %ecx
cmpl $0xc3, %ecx
jne 0x4b8d
movsbl 0x1(%r14,%r15), %eax
xorl %ecx, %ecx
leaq 0x1d06(%rip), %rdx      # 0x6840
xorl %esi, %esi
testl %esi, %esi
movl $0x1, %esi
jne 0x4b50
xorl %esi, %esi
movl (%rcx,%rdx), %edi
addl %eax, %edi
sete %sil
addq $0x4, %rcx
cmpq $0x74, %rcx
jne 0x4b3c
testl %esi, %esi
jne 0x4ba4
xorl %eax, %eax
jmp 0x4b8d
leaq 0x1cd7(%rip), %rcx      # 0x6840
xorl %edx, %edx
movl $0x1, %eax
testl %r13d, %r13d
jne 0x4b80
xorl %eax, %eax
movl (%rdx,%rcx), %esi
addl %r12d, %esi
sete %al
addq $0x4, %rdx
movl %eax, %r13d
cmpq $0x74, %rdx
jne 0x4b6b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $-0x48, 0x1(%r14,%r15)
jne 0x4b8d
incl %r15d
movl %r15d, (%rbx)
movl $0x1, %eax
jmp 0x4b8d
leaq 0x1d98(%rip), %rdi      # 0x6950
leaq 0x1d00(%rip), %rsi      # 0x68bf
leaq 0x24a7(%rip), %rcx      # 0x706d
movl $0x3c0, %edx            # imm = 0x3C0
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: MemIntValuer
void MemIntValuer(int piMemOrigine[],int nItemEnTout,int iValeur){
	int nItem;
	Vrai2(piMemOrigine!=0,nItemEnTout>=0);
	for (nItem=0; nItem<nItemEnTout; nItem++){
		piMemOrigine[nItem]=iValeur;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
movl %ebp, %edx
notl %edx
shrl $0x1f, %edx
movl $0x1, (%rsp)
leaq 0x1618(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
testl %ebp, %ebp
jle 0x4c9e
movl %ebp, %eax
xorl %ecx, %ecx
movl %ebx, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x4c92
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: MemLongValuer
void MemLongValuer(int pyMemOrigine[],int nItemEnTout,long yValeur){
	int nItem;
	Vrai2(pyMemOrigine!=0,nItemEnTout>=0);
	for (nItem=0; nItem<nItemEnTout; nItem++){
		pyMemOrigine[nItem]=yValeur;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
movl %ebp, %edx
notl %edx
shrl $0x1f, %edx
movl $0x1, (%rsp)
leaq 0x1567(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
testl %ebp, %ebp
jle 0x4d4f
movl %ebp, %eax
xorl %ecx, %ecx
movl %ebx, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x4d43
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: uModulo1
int uModulo1(int uDividende,int uDiviseur){
	//rend le modulo standard à ceci près que le résultat 0 éventuel est remplacé par uDiviseur: uModulo1(12,4)=4 
	int nModulo;
	Vrai2(uDividende>0,uDiviseur>0);
	nModulo=uDividende%uDiviseur;
	if (nModulo==0)
		nModulo=uDiviseur;
	if (0)//ou 1 pr que li+1 soit exécutée 
		seee("uModulo1",uDividende,uDiviseur,nModulo);
	Croit(1,nModulo,uDiviseur);
	return(nModulo);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
xorl %esi, %esi
testl %edi, %edi
setg %sil
xorl %edx, %edx
testl %ebx, %ebx
setg %dl
movl $0x1, (%rsp)
leaq 0x14d3(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
movl %ebp, %eax
cltd
idivl %ebx
movl %edx, %ebp
testl %edx, %edx
cmovel %ebx, %ebp
movl $0x1, %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x4745
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sNie
char *sNie(char *sVerbe,int bNegativer,char *sAffirmation,char *sNegation){
	//rend sVerbe suivi de sAffirmation,ou négativé avec "ne" et sNegation si bNegativer
	#define kuNegationEtBlancLgMax 4
	Vrai4(sVerbe!=0,bBool(bNegativer),sAffirmation!=0,sNegation!=0);
	char *sNie=malloc(strlen(sVerbe)+ySup(strlen(sAffirmation),strlen(sNegation))+kuNegationEtBlancLgMax);
	if (bNegativer){
		strcpy(sNie,sChoix(bVoyelle(sVerbe,0),"n'","ne "));
		strcat(sNie,sVerbe);
	}
	else strcpy(sNie,sVerbe);
	strcat(sNie," ");
	if (bNegativer)
		strcat(sNie,sNegation);
	else strcat(sNie,sAffirmation);
	OctetGereR(sNie);
	return(sNie);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
xorl %edx, %edx
cmpl $0x2, %ebp
setb %dl
xorl %ecx, %ecx
testq %r15, %r15
setne %cl
xorl %r8d, %r8d
testq %rbx, %rbx
setne %r8b
movl $0x1, (%rsp)
leaq 0x1453(%rip), %rdi      # 0x628c
movl $0x1, %r9d
callq 0x33f4
movq %r14, %rdi
callq 0x1090
movq %rax, %r12
movq %r15, %rdi
callq 0x1090
movq %rax, %r13
movq %rbx, %rdi
callq 0x1090
cmpq %rax, %r13
cmovgq %r13, %rax
leaq (%r12,%rax), %rdi
addq $0x4, %rdi
callq 0x1110
movq %rax, %r12
testl %ebp, %ebp
je 0x4eb4
movq %r14, %rdi
xorl %esi, %esi
callq 0x4f01
leaq 0x1ddd(%rip), %rsi      # 0x6c6b
leaq 0x1dd9(%rip), %rdx      # 0x6c6e
movl %eax, %edi
callq 0x4582
movq %r12, %rdi
movq %rax, %rsi
callq 0x1050
movq %r12, %rdi
movq %r14, %rsi
callq 0x1140
jmp 0x4ec2
movq %r12, %rdi
movq %r14, %rsi
callq 0x1050
movq %r15, %rbx
movq %r12, %rdi
callq 0x1090
movw $0x20, (%r12,%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r12, %rdi
callq 0x3ca0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: bVoyelle
int bVoyelle(char *sString,int nCodeCaractereRg){
	//sString[nCodeCaractereRg] ou Chaine[nCodeCaractereRg..nCodeCaractereRg+1] code une voyelle
	int nRg=nCodeCaractereRg;
	Vrai2(sString!=0,nCodeCaractereRg>=0);
	int bVoyelle=bVoyellE2(sString,&nRg);
	return(bVoyelle);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
movl %esi, (%r14)
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
notl %edx
shrl $0x1f, %edx
movl $0x1, (%rsp)
leaq 0x135b(%rip), %rdi      # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ac0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: OutilAMORCER
void OutilAMORCER(){
	//amorce le présent module une fois pour toutes
	//NB ne toucher ni à nEcriS ni à bEcriS[] utilisés avant l'amorçage;
	assert(nEcriS==1);//vu l'appel s0("") en tête du main();pour s0() et s1()
	assert(strlen("à")>1);//ATTENTION: strlen("à")==2 et strlen("a")==1. strlen() ne compte plus des caractères mais des codes caractères,d'où le 2.
	bOutilAmorceR=kV;
}

// Assembly:
cmpl $0x1, 0xb91f(%rip)      # 0x10880
jne 0x4f6e
movl $0x1, 0xca47(%rip)      # 0x119b4
retq
pushq %rax
leaq 0x1d7c(%rip), %rdi      # 0x6cf2
leaq 0x1942(%rip), %rsi      # 0x68bf
leaq 0x1d78(%rip), %rcx      # 0x6cfc
movl $0x31f, %edx            # imm = 0x31F
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sPas
char *sPas(char *sVerbe,int bNegativer){
	//rend sVerbe tel quel,ou négativé avec "ne"..."pas" si bNegativer 
	#define kuNeLg 3//"n'" ou "ne "
	#define kuPasLg 4//" pas"
	char *sPas=malloc(kuNeLg+strlen(sVerbe)+kuPasLg+kuAntiSlashZerO);
	if (bNegativer){
		strcpy(sPas,sChoix(bVoyelle(sVerbe,0),"n'","ne "));
		strcat(sPas,sVerbe);
		strcat(sPas, " pas");
	}
	else strcpy(sPas,sVerbe);
	OctetGereR(sPas);
	return(sPas);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x1090
leaq 0x8(%rax), %rdi
callq 0x1110
movq %rax, %rbx
testl %ebp, %ebp
je 0x5454
movq %r14, %rdi
xorl %esi, %esi
callq 0x4f01
leaq 0x1851(%rip), %rsi      # 0x6c6b
leaq 0x184d(%rip), %rdx      # 0x6c6e
movl %eax, %edi
callq 0x4582
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1050
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1140
movq %rbx, %rdi
callq 0x1090
movl $0x73617020, (%rbx,%rax) # imm = 0x73617020
movb $0x0, 0x4(%rbx,%rax)
jmp 0x545f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
movq %rbx, %rdi
callq 0x3ca0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: Titrer
void Titrer(char *sTitre){
	//affiche sTitre centré sur une ligne de kuTitreLargeur caractères de type kcMotif
	const int kuTitreLargeur=60;//où ce que vous voulez
	const char kcMotif='*';//où ce que vous voulez
	assert(sTitre!=0);
	int nTitreLg=nCaractere(sTitre);
	assert(nTitreLg<kuTitreLargeur);
	int nEspace=(kuTitreLargeur-nTitreLg)/2;//quitte à perdre un caractère
	int bUnMotifEnSus=bImpair(nTitreLg);//ie un kcMotif sera ajouté pr récupérer le caractère perdu li-1
	assert(nEspace+nTitreLg+nEspace+bUnMotifEnSus==kuTitreLargeur);
	printf("%s%s%s\n",sFois(nEspace,kcMotif),sTitre,sFois(nEspace+bUnMotifEnSus,kcMotif));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x54e6
movq %rdi, %rbx
callq 0x4379
cmpl $0x3c, %eax
jae 0x5505
movl $0x3c, %ebp
subl %eax, %ebp
movl %eax, %r15d
andl $0x1, %r15d
movl %ebp, %ecx
andl $-0x2, %ecx
addl %r15d, %eax
addl %ecx, %eax
cmpl $0x3c, %eax
jne 0x5524
shrl %ebp
movl %ebp, %edi
movl $0x2a, %esi
callq 0x48ec
movq %rax, %r14
addl %r15d, %ebp
movl %ebp, %edi
movl $0x2a, %esi
callq 0x48ec
leaq 0x1b95(%rip), %rdi      # 0x7061
movq %r14, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
leaq 0x1b07(%rip), %rdi      # 0x6ff4
leaq 0x13cb(%rip), %rsi      # 0x68bf
leaq 0x1b03(%rip), %rcx      # 0x6ffe
movl $0x395, %edx            # imm = 0x395
callq 0x10b0
leaq 0x1b06(%rip), %rdi      # 0x7012
leaq 0x13ac(%rip), %rsi      # 0x68bf
leaq 0x1ae4(%rip), %rcx      # 0x6ffe
movl $0x397, %edx            # imm = 0x397
callq 0x10b0
leaq 0x1aff(%rip), %rdi      # 0x702a
leaq 0x138d(%rip), %rsi      # 0x68bf
leaq 0x1ac5(%rip), %rcx      # 0x6ffe
movl $0x39a, %edx            # imm = 0x39A
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sPluriel
char *sPluriel(int nEffectif,char *sSingulier){
	//si sSingulier est "pomme",rend "3 pommes","1 pomme" ou "0 pomme",selon nEffectif;sSingulier est supposé prendre un "s" au pluriel
	char *sPluriel;
	Vrai2(nEffectif>=0,sSingulier!=0);
	sPluriel=sC2b(sEntier(nEffectif),sSingulier);
	if (nEffectif>1)
		sPluriel=sC2(sPluriel,"s");
	return(sPluriel);//rend "3 s" si (nCardinal=3 et sSingulier est la chaîne vide)
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movl %edi, %ebx
movl %edi, %esi
notl %esi
shrl $0x1f, %esi
xorl %edx, %edx
testq %r14, %r14
setne %dl
movl $0x1, (%rsp)
leaq 0xd16(%rip), %rdi       # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
movl $0x18, %edi
callq 0x1110
movq %rax, %r15
leaq 0xc2d(%rip), %rsi       # 0x61cd
movq %rax, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1150
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e84
cmpl $0x2, %ebx
jl 0x55d4
leaq 0x1657(%rip), %rsi      # 0x6c1a
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3df1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: VecteurVoir
void VecteurVoir(char *sTitre,int piQuelVecteur[],int nIndexMin,int nIndexMax){
	//affiche piQuelVecteur[nIndexMin..nIndexMax],dc bornes incluses
	int nE;
	Vrai2(sTitre!=0,piQuelVecteur!=0);
	Croit(0,nIndexMin,nIndexMax);
	s(sTitre);
		for (nE=nIndexMin;nE<=nIndexMax;nE++)
			printf("%4d",piQuelVecteur[nE]);
	s("");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
xorl %edx, %edx
testq %r14, %r14
setne %dl
movl $0x1, (%rsp)
leaq 0xc5b(%rip), %rdi       # 0x628c
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x33f4
xorl %edi, %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x4745
movq %r15, %rdi
callq 0x3697
cmpl %ebx, %ebp
jg 0x5689
movslq %ebp, %rax
leaq (%r14,%rax,4), %r15
subl %ebp, %ebx
incl %ebx
leaq 0x19f9(%rip), %r14      # 0x7069
xorl %r12d, %r12d
movl (%r15,%r12,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10a0
incq %r12
cmpl %r12d, %ebx
jne 0x5673
movl $0xa, %edi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040