LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10a0
callq 0x1150
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
cmpl $0x32, -0x2c(%rbp)
jge 0x4a36
leaq 0x4d49(%rip), %rdi      # 0x976c
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
jmp 0x4b4c
leaq 0x4d53(%rip), %rdi      # 0x9790
movb $0x0, %al
callq 0x1080
leaq 0x4d64(%rip), %rdi      # 0x97af
movb $0x0, %al
callq 0x1080
leaq 0x4b51(%rip), %rdi      # 0x95aa
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x1110
movb $0x1, %al
cmpl $0x0, -0x24(%rbp)
movb %al, -0x2d(%rbp)
jle 0x4ae2
movb $0x1, %al
cmpl $0x1e, -0x24(%rbp)
movb %al, -0x2d(%rbp)
jge 0x4ae2
movb $0x1, %al
cmpl $0x0, -0x28(%rbp)
movb %al, -0x2d(%rbp)
jle 0x4ae2
movb $0x1, %al
cmpl $0x3c, -0x28(%rbp)
movb %al, -0x2d(%rbp)
jge 0x4ae2
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rax
imulq $0x2d0, %rax, %rax      # imm = 0x2D0
addq %rax, %rcx
movslq -0x28(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
movb $0x1, %al
cmpl $0x20, 0x4(%rcx)
movb %al, -0x2d(%rbp)
jne 0x4ae2
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x2d0, %rcx, %rcx      # imm = 0x2D0
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x4aeb
jmp 0x4b22
leaq 0x4abd(%rip), %rdi      # 0x95af
movb $0x0, %al
callq 0x1080
leaq 0x4caf(%rip), %rdi      # 0x97af
movb $0x0, %al
callq 0x1080
leaq 0x4a9c(%rip), %rdi      # 0x95aa
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x1110
jmp 0x4a68
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movq -0x20(%rbp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x45c0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x21(%rbp)
je 0x4f81
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x4f81
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x21(%rbp)
je 0x4f81
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x4f81
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
je 0x4f81
cmpl $0x0, 0x10(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x4ff8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x5030
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl $0x2, %edx
callq 0x5030
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x3, %edx
callq 0x5030
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0x4, %edx
callq 0x5030
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x5, %edx
callq 0x5030
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %esi
movl $0x6, %edx
callq 0x5030
cmpl $0x0, -0x20(%rbp)
je 0x5000
jmp 0x501f
leaq 0x4a3d(%rip), %rdi      # 0x9a44
leaq 0x4a41(%rip), %rsi      # 0x9a4f
movl $0x28, %edx
leaq 0x4a4a(%rip), %rcx      # 0x9a64
callq 0x1090
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x508b
movl -0x10(%rbp), %esi
leaq 0x4a44(%rip), %rdi      # 0x9a96
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rdi
callq 0x1070
cmpq $0x0, %rax
jbe 0x507d
movq -0x8(%rbp), %rsi
movl -0x10(%rbp), %edx
leaq 0x4a4c(%rip), %rdi      # 0x9ac2
movb $0x0, %al
callq 0x1080
leaq 0x4adc(%rip), %rdi      # 0x9b60
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpl $0x3f, 0xdeb0(%rip)     # 0x13870
setl %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movl 0xde9d(%rip), %eax      # 0x13870
addl $0x1, %eax
movl %eax, 0xde94(%rip)      # 0x13870
cltq
leaq 0xde9b(%rip), %rsi      # 0x13880
shlq $0x2, %rax
addq %rax, %rsi
movl $0x1, %edi
callq 0x5a40
movq -0x8(%rbp), %rdi
callq 0x1070
cmpq $0x0, %rax
jne 0x5a15
leaq 0x4126(%rip), %rdi      # 0x9b32
movb $0x0, %al
callq 0x1080
jmp 0x5a37
movl 0xde55(%rip), %edi      # 0x13870
shll %edi
callq 0x5a90
movq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq 0x4119(%rip), %rdi      # 0x9b49
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x5a5c
jmp 0x5a7b
leaq 0x43db(%rip), %rdi      # 0x9e3e
leaq 0x3fe5(%rip), %rsi      # 0x9a4f
movl $0x25b, %edx            # imm = 0x25B
leaq 0x43e1(%rip), %rcx      # 0x9e57
callq 0x1090
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movl %eax, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpl $0x0, 0xdd84(%rip)      # 0x13870
setg %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movslq 0xdd70(%rip), %rax      # 0x13870
leaq 0xdd79(%rip), %rsi      # 0x13880
shlq $0x2, %rax
addq %rax, %rsi
xorl %edi, %edi
callq 0x5a40
cmpl $0x0, -0xc(%rbp)
je 0x5b3f
movl 0xdd4f(%rip), %edi      # 0x13870
shll %edi
callq 0x5a90
movq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq 0x402d(%rip), %rdi      # 0x9b63
movb $0x0, %al
callq 0x1080
jmp 0x5b4d
leaq 0x4036(%rip), %rdi      # 0x9b7c
movb $0x0, %al
callq 0x1080
movl 0xdd1d(%rip), %eax      # 0x13870
addl $-0x1, %eax
movl %eax, 0xdd14(%rip)      # 0x13870
cmpl $0x0, 0xdd0d(%rip)      # 0x13870
jl 0x5b67
jmp 0x5b86
leaq 0x4023(%rip), %rdi      # 0x9b91
leaq 0x3eda(%rip), %rsi      # 0x9a4f
movl $0xc7, %edx
leaq 0x401a(%rip), %rcx      # 0x9b9b
callq 0x1090
cmpl $0x0, -0xc(%rbp)
jne 0x5be2
cmpl $0x0, 0xdcdd(%rip)      # 0x13870
jne 0x5b97
jmp 0x5bb6
leaq 0x4011(%rip), %rdi      # 0x9baf
leaq 0x3eaa(%rip), %rsi      # 0x9a4f
movl $0xc9, %edx
leaq 0x3fea(%rip), %rcx      # 0x9b9b
callq 0x1090
cmpl $0x0, 0xdcb7(%rip)      # 0x13874
jl 0x5bc1
jmp 0x5be0
leaq 0x3ff1(%rip), %rdi      # 0x9bb9
leaq 0x3e80(%rip), %rsi      # 0x9a4f
movl $0xca, %edx
leaq 0x3fc0(%rip), %rcx      # 0x9b9b
callq 0x1090
jmp 0x5be2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sBool
char *sBool(long yValeur){
	//rend en clair la valeur booléenne de yValeur
	if (yValeur)
		return("vrai");
	else return("faux");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5cec
leaq 0x3de7(%rip), %rax      # 0x9acd
movq %rax, -0x8(%rbp)
jmp 0x5cf7
leaq 0x3ddf(%rip), %rax      # 0x9ad2
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x2, %edi
callq 0x10f0
movq %rax, -0x10(%rbp)
callq 0x1160
movq (%rax), %rax
movsbl -0x1(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x5d54
callq 0x1160
movq (%rax), %rax
movsbl -0x1(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x5d56
jmp 0x5d75
leaq 0x3eae(%rip), %rdi      # 0x9c0b
leaq 0x3ceb(%rip), %rsi      # 0x9a4f
movl $0xe5, %edx
leaq 0x3ee0(%rip), %rcx      # 0x9c50
callq 0x1090
movb -0x1(%rbp), %al
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x5da0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sC1p
char *sC1p(char *sA){
	//concatène sA et "."
	assert(sA!=0);
	char *sAccu=sC2(sA, ".");
	return(sAccu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5f75
jmp 0x5f94
leaq 0x3ce3(%rip), %rdi      # 0x9c5f
leaq 0x3acc(%rip), %rsi      # 0x9a4f
movl $0xf5, %edx
leaq 0x3ce8(%rip), %rcx      # 0x9c77
callq 0x1090
movq -0x8(%rbp), %rdi
leaq 0x3ceb(%rip), %rsi      # 0x9c8a
callq 0x5fc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movq -0x8(%rbp), %rdi
callq 0x1070
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1120
movq -0x20(%rbp), %rdi
callq 0x5da0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x60ba
jmp 0x60d9
leaq 0x3bcb(%rip), %rdi      # 0x9c8c
leaq 0x3987(%rip), %rsi      # 0x9a4f
movl $0x10c, %edx            # imm = 0x10C
leaq 0x3bc3(%rip), %rcx      # 0x9c97
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
jbe 0x6103
movq -0x10(%rbp), %rdi
callq 0x1070
cmpq $0x0, %rax
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x611d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
cmpl $0x0, -0x14(%rbp)
je 0x6152
movq -0x20(%rbp), %rdi
leaq 0x2fe1(%rip), %rsi      # 0x912e
callq 0x1120
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1120
movq -0x20(%rbp), %rdi
callq 0x5da0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6ad3
jmp 0x6af2
leaq 0x3006(%rip), %rdi      # 0x9ae0
leaq 0x2f6e(%rip), %rsi      # 0x9a4f
movl $0x1bb, %edx            # imm = 0x1BB
leaq 0x31c5(%rip), %rcx      # 0x9cb2
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x1070
movl %eax, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6b7d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
callq 0x1160
movq (%rax), %rax
movsbl -0x15(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x6b67
callq 0x1160
movq (%rax), %rax
movsbl -0x15(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x6b67
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x6bb0
cmpl $0x0, %eax
je 0x6b70
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6b72
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6b05
cmpl $0x0, -0x10(%rbp)
jl 0x6b85
jmp 0x6ba4
leaq 0x313d(%rip), %rdi      # 0x9cc9
leaq 0x2ebc(%rip), %rsi      # 0x9a4f
movl $0x1c1, %edx            # imm = 0x1C1
leaq 0x3113(%rip), %rcx      # 0x9cb2
callq 0x1090
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6bd0
jmp 0x6bef
leaq 0x2f09(%rip), %rdi      # 0x9ae0
leaq 0x2e71(%rip), %rsi      # 0x9a4f
movl $0x297, %edx            # imm = 0x297
leaq 0x32a7(%rip), %rcx      # 0x9e91
callq 0x1090
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movl -0x1c(%rbp), %esi
movl %eax, %edx
xorl %edi, %edi
callq 0x7080
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
callq 0x1160
movq (%rax), %rax
movsbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x6c99
movq -0x10(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x6c99
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7650
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0x6c8e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6ec0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6d38
jmp 0x6d57
leaq 0x2f98(%rip), %rdi      # 0x9cd7
leaq 0x2d09(%rip), %rsi      # 0x9a4f
movl $0x1ce, %edx            # imm = 0x1CE
leaq 0x2f90(%rip), %rcx      # 0x9ce2
callq 0x1090
cmpl $0x0, -0x4(%rbp)
je 0x6d6c
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, -0x28(%rbp)
jmp 0x6d74
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x6d74
movq -0x28(%rbp), %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x6da0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x5da0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
cmpl $0x0, -0x4(%rbp)
je 0x6e07
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, -0x30(%rbp)
jmp 0x6e14
movq -0x18(%rbp), %rdi
callq 0x1070
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x10f0
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x6e42
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
jmp 0x6e4f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1040
movq -0x28(%rbp), %rdi
callq 0x5da0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x2e76(%rip), %rdi      # 0x9cfd
movb $0x0, %al
callq 0x1080
leaq 0x28b1(%rip), %rdi      # 0x9746
leaq -0x9(%rbp), %rsi
movb $0x0, %al
callq 0x1110
leaq 0x2e76(%rip), %rdi      # 0x9d1d
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x71d0
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
callq 0x71d0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x2c24(%rip), %rsi      # 0x9d54
callq 0x6200
movq %rax, %rdi
callq 0x7160
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5da0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7175
jmp 0x7194
leaq 0x30d2(%rip), %rdi      # 0xa24e
leaq 0x28cc(%rip), %rsi      # 0x9a4f
movl $0x362, %edx            # imm = 0x362
leaq 0x30d3(%rip), %rcx      # 0xa262
callq 0x1090
movq -0x8(%rbp), %rsi
leaq 0x30d4(%rip), %rdi      # 0xa273
leaq 0x2daa(%rip), %rdx      # 0x9f50
callq 0x6200
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5da0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x10f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0x22fa(%rip), %rsi      # 0x94f1
movb $0x0, %al
callq 0x1130
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
cmpl $0x0, -0x4(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
callq 0x1160
movl -0x20(%rbp), %edi
movq (%rax), %rax
movsbl -0x5(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %esi
andl $0x4000, %esi           # imm = 0x4000
callq 0x58e0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x10f0
movq %rax, -0x18(%rbp)
movb -0x5(%rbp), %al
movb %al, -0x1a(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
callq 0x1040
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x73c1
movq -0x18(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
callq 0x1120
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x73a1
movq -0x18(%rbp), %rdi
callq 0x5da0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x10f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0x2a25(%rip), %rsi      # 0x9e2c
movb $0x0, %al
callq 0x1130
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
addl $0x1, %edx
movl $0x4, %eax
movl $0x3, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rdi
callq 0x10f0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x7465
movq -0x10(%rbp), %rdi
leaq 0x29d2(%rip), %rsi      # 0x9e30
callq 0x1120
jmp 0x7475
movq -0x10(%rbp), %rdi
leaq 0x29c4(%rip), %rsi      # 0x9e34
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x5da0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
movl $0x1, %edi
movl $0x7ffffffe, %edx       # imm = 0x7FFFFFFE
callq 0x7080
callq 0x1150
cltd
idivl -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
subl $0x1, %edx
xorl %edi, %edi
callq 0x7080
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
movl $0x1, %edi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x7080
callq 0x1150
cltd
idivl -0x4(%rbp)
addl $0x1, %edx
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
movl $0x1, %edi
callq 0x7080
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpl $0x0, -0xc(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x79f8
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x79d7
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpl $0x0, -0xc(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7aac
movq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7a88
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %edi
cmpl $0x0, -0x8(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x7bc1
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
movl $0x1, %edi
callq 0x7080
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x5c60
movl -0x3c(%rbp), %edi
movl %eax, %esi
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edx
cmpq $0x0, -0x20(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x5930
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1070
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7d20
movq -0x30(%rbp), %rdi
addq %rax, %rdi
addq $0x4, %rdi
callq 0x10f0
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x7cc0
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x7d60
movl %eax, %edi
leaq 0x2214(%rip), %rsi      # 0x9ead
leaq 0x2210(%rip), %rdx      # 0x9eb0
callq 0x6dc0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1120
jmp 0x7ccd
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
movq -0x28(%rbp), %rdi
leaq 0x1456(%rip), %rsi      # 0x912e
callq 0x1120
cmpl $0x0, -0xc(%rbp)
je 0x7cf2
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1120
jmp 0x7cff
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1120
movq -0x28(%rbp), %rdi
callq 0x5da0
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpl $0x0, -0xc(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x7650
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, 0xbab5(%rip)      # 0x13870
jne 0x7dbf
jmp 0x7dde
leaq 0x216e(%rip), %rdi      # 0x9f34
leaq 0x1c82(%rip), %rsi      # 0x9a4f
movl $0x31f, %edx            # imm = 0x31F
leaq 0x2165(%rip), %rcx      # 0x9f3e
callq 0x1090
movl $0x1, 0xcbbc(%rip)      # 0x149a4
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x3, %rdi
addq $0x4, %rdi
addq $0x1, %rdi
callq 0x10f0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x8329
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x7d60
movl %eax, %edi
leaq 0x1bbb(%rip), %rsi      # 0x9ead
leaq 0x1bb7(%rip), %rdx      # 0x9eb0
callq 0x6dc0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1120
movq -0x18(%rbp), %rdi
leaq 0x1b17(%rip), %rsi      # 0x9e39
callq 0x1120
jmp 0x8336
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x5da0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x3c, -0xc(%rbp)
movb $0x2a, -0xd(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8370
jmp 0x838f
leaq 0x1f02(%rip), %rdi      # 0xa279
leaq 0x16d1(%rip), %rsi      # 0x9a4f
movl $0x395, %edx            # imm = 0x395
leaq 0x1ef9(%rip), %rcx      # 0xa283
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x6ab0
movl %eax, -0x14(%rbp)
cmpl $0x3c, -0x14(%rbp)
jge 0x83a3
jmp 0x83c2
leaq 0x1eed(%rip), %rdi      # 0xa297
leaq 0x169e(%rip), %rsi      # 0x9a4f
movl $0x397, %edx            # imm = 0x397
leaq 0x1ec6(%rip), %rcx      # 0xa283
callq 0x1090
movl $0x3c, %eax
subl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
callq 0x7550
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl $0x3c, %eax
jne 0x83f3
jmp 0x8412
leaq 0x1eb5(%rip), %rdi      # 0xa2af
leaq 0x164e(%rip), %rsi      # 0x9a4f
movl $0x39a, %edx            # imm = 0x39A
leaq 0x1e76(%rip), %rcx      # 0xa283
callq 0x1090
movl -0x18(%rbp), %edi
movl $0x2a, %esi
callq 0x7330
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %edi
addl -0x1c(%rbp), %edi
movl $0x2a, %esi
callq 0x7330
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x1e99(%rip), %rdi      # 0xa2e6
movb $0x0, %al
callq 0x1080
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %edi
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movl -0x4(%rbp), %edi
callq 0x71d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6060
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x4(%rbp)
jle 0x851f
movq -0x18(%rbp), %rdi
leaq 0x1926(%rip), %rsi      # 0x9e3c
callq 0x5fc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edi
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x58e0
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
xorl %edi, %edi
callq 0x7080
movq -0x8(%rbp), %rdi
callq 0x5480
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x860d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x1cf3(%rip), %rdi      # 0xa2ee
movb $0x0, %al
callq 0x1080
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x85e1
leaq 0xc78(%rip), %rdi       # 0x928c
callq 0x5480
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: While
void While(long zIterationMax){
	//prend note du nombre maximum d'itérations acceptable dans le while qui suit immédiatement l'appel de cette routine
//ATTENTION:l'utilisation de cette routine est incompatible avec des sorties de boucles intempestives telles que exit(), return, etc.
	assert(zIterationMax>=0);
	ipWhilE++;
	assert(ipWhilE<=kuWhileMaX);
	zWhilE[ipWhilE]=zIterationMax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jl 0x8695
jmp 0x86b4
leaq 0x1c82(%rip), %rdi      # 0xa31e
leaq 0x13ac(%rip), %rsi      # 0x9a4f
movl $0x3fc, %edx            # imm = 0x3FC
leaq 0x1c80(%rip), %rcx      # 0xa32f
callq 0x1090
movl 0xb1ba(%rip), %eax      # 0x13874
addl $0x1, %eax
movl %eax, 0xb1b1(%rip)      # 0x13874
cmpl $0x5, 0xb1aa(%rip)      # 0x13874
jg 0x86ce
jmp 0x86ed
leaq 0x1c6b(%rip), %rdi      # 0xa340
leaq 0x1373(%rip), %rsi      # 0x9a4f
movl $0x3fe, %edx            # imm = 0x3FE
leaq 0x1c47(%rip), %rcx      # 0xa32f
callq 0x1090
movq -0x8(%rbp), %rdx
movslq 0xb17c(%rip), %rcx      # 0x13874
leaq 0xc2b1(%rip), %rax      # 0x149b0
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: bWhile
int bWhile(int bExpressionBooleenne){
	//rend bExpressionBooleenne tout en gérant l'itération en cours (ie son rang ne dépasse pas zIterationMax spécifié dans l'appel à While() qui précède
//ATTENTION:l'utilisation de cette routine est incompatible avec des sorties de boucles intempestives telles que exit(), return,etc
	Croit(0,ipWhilE,kuWhileMaX);
	zWhilE[ipWhilE]--;//décrémente le nombre d'itérations de la boucle imbriquée de rang ipWhilE
	assert(zWhilE[ipWhilE]>=0);
	if (bExpressionBooleenne==0){//la sortie imminente du while courant ramène le contexte ds la boucle imbriquée englobante,de rang ipWhilE-1
		zWhilE[ipWhilE]=0;//superflu mais ce nettoyage facilite la mise au point
		ipWhilE--;//vital
		assert(ipWhilE>=0);
	}//Chaque boucle while est donc contrôlée via 1° un appel à While() avant le while et 2° un appel à bWhile() dans l'expression booléenne liée au...
	return(bExpressionBooleenne);//...while; Appel1("") à la fin du main() vérifie que le contrôle des while est bien séquencé via "assert(ipWhilE>=0)".
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0xb153(%rip), %esi      # 0x13874
xorl %edi, %edi
movl $0x5, %edx
callq 0x7080
movslq 0xb140(%rip), %rcx      # 0x13874
leaq 0xc275(%rip), %rax      # 0x149b0
movq (%rax,%rcx,8), %rdx
addq $-0x1, %rdx
leaq 0xc266(%rip), %rax      # 0x149b0
movq %rdx, (%rax,%rcx,8)
movslq 0xb11f(%rip), %rcx      # 0x13874
leaq 0xc254(%rip), %rax      # 0x149b0
cmpq $0x0, (%rax,%rcx,8)
jl 0x8765
jmp 0x8784
leaq 0x1be8(%rip), %rdi      # 0xa354
leaq 0x12dc(%rip), %rsi      # 0x9a4f
movl $0x407, %edx            # imm = 0x407
leaq 0x1be8(%rip), %rcx      # 0xa367
callq 0x1090
cmpl $0x0, -0x4(%rbp)
jne 0x87db
movslq 0xb0e3(%rip), %rcx      # 0x13874
leaq 0xc218(%rip), %rax      # 0x149b0
movq $0x0, (%rax,%rcx,8)
movl 0xb0ce(%rip), %eax      # 0x13874
addl $-0x1, %eax
movl %eax, 0xb0c5(%rip)      # 0x13874
cmpl $0x0, 0xb0be(%rip)      # 0x13874
jl 0x87ba
jmp 0x87d9
leaq 0x13f8(%rip), %rdi      # 0x9bb9
leaq 0x1287(%rip), %rsi      # 0x9a4f
movl $0x40b, %edx            # imm = 0x40B
leaq 0x1b93(%rip), %rcx      # 0xa367
callq 0x1090
jmp 0x87db
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/marcespie[P]unix-samples/chapter2/ttysig.c
// Function: byebye
void
byebye(int sig)
{
	save_data();
	signal(sig, SIG_DFL);
	errwrap(tcsetattr(0, TCSANOW, &basetty));
	kill(getpid(), sig);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x1200
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
xorl %esi, %esi
leaq 0x2e5f(%rip), %rdx      # 0x4094
movl %esi, %edi
callq 0x10e0
cmpl $-0x1, %eax
jne 0x1254
movl $0x1, %edi
leaq 0xdb7(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x10c0
jmp 0x1256
callq 0x1060
movl %eax, %edi
movl -0x4(%rbp), %esi
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/marcespie[P]unix-samples/chapter2/ttysig.c
// Function: tstp_handler
void
tstp_handler(int sig)
{
	int save_errno = errno;

	signal(sig, SIG_DFL);
	errwrap(tcsetattr(0, TCSANOW, &basetty));
	kill(getpid(), sig);
	errno = save_errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x1030
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
xorl %esi, %esi
leaq 0x2dfa(%rip), %rdx      # 0x4094
movl %esi, %edi
callq 0x10e0
cmpl $-0x1, %eax
jne 0x12b9
movl $0x1, %edi
leaq 0xd52(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x10c0
jmp 0x12bb
callq 0x1060
movl %eax, %edi
movl -0x4(%rbp), %esi
callq 0x10b0
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
callq 0x1030
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq