LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x1110
movq %rax, %r14
leaq 0x1879(%rip), %rsi      # 0x5c0e
movq %rax, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1150
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: 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 0x43db
movq %rbx, %rdi
callq 0x1090
movl $0x747365, (%rbx,%rax)  # imm = 0x747365
jmp 0x43ee
movabsq $0x617020747365276e, %rax # imm = 0x617020747365276E
movq %rax, (%rbx)
movw $0x73, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3957
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
movl %ebx, %esi
movl $0x7ffffffe, %edx       # imm = 0x7FFFFFFE
callq 0x419e
callq 0x1170
cltd
idivl %ebx
movl %edx, %ebp
decl %ebx
xorl %edi, %edi
movl %edx, %esi
movl %ebx, %edx
callq 0x419e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %edi, %ebx
pushq $0x1
popq %rbp
movl %ebp, %edi
movl %ebx, %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x419e
callq 0x1170
cltd
idivl %ebx
leal 0x1(%rdx), %r14d
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x419e
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x459e
movq %rsi, %rbx
movq %rdi, %r15
movl (%rsi), %ebp
callq 0x1090
xorl %r14d, %r14d
xorl %edi, %edi
movl %ebp, %esi
movl %eax, %edx
callq 0x419e
movslq (%rbx), %r12
movsbq (%r15,%r12), %r13
callq 0x1180
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r13,2)
jne 0x4544
movq %r15, %rdi
callq 0x1090
xorl %r14d, %r14d
cmpq %r12, %rax
jbe 0x458c
cmpb $-0x3b, %r13b
je 0x457a
movzbl %r13b, %eax
cmpl $0xc3, %eax
jne 0x458c
movsbl 0x1(%r15,%r12), %eax
xorl %ecx, %ecx
pushq $0x1
popq %rdx
leaq 0x131d(%rip), %rsi      # 0x5840
xorl %edi, %edi
cmpq $0x74, %rcx
je 0x4571
testl %edi, %edi
movl %edx, %edi
jne 0x453e
xorl %edi, %edi
movl (%rcx,%rsi), %r8d
addl %eax, %r8d
sete %dil
addq $0x4, %rcx
jmp 0x4525
pushq $0x1
popq %rax
leaq 0x12f2(%rip), %rcx      # 0x5840
xorl %edx, %edx
cmpq $0x74, %rdx
je 0x458c
testl %r14d, %r14d
movl %eax, %r14d
jne 0x456b
xorl %r14d, %r14d
movl (%rdx,%rcx), %esi
addl %r13d, %esi
sete %r14b
addq $0x4, %rdx
jmp 0x4550
testl %edi, %edi
jne 0x4582
xorl %r14d, %r14d
jmp 0x458c
cmpb $-0x48, 0x1(%r15,%r12)
jne 0x458c
incl %r12d
movl %r12d, (%rbx)
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13ab(%rip), %rdi      # 0x5950
leaq 0x1313(%rip), %rsi      # 0x58bf
leaq 0x1aba(%rip), %rcx      # 0x606d
movl $0x3c0, %edx            # imm = 0x3C0
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
xorl %edi, %edi
testq %r15, %r15
setne %dil
notl %esi
shrl $0x1f, %esi
callq 0x3394
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
cmpq %rax, %r14
je 0x4641
movl %ebx, (%r15,%rax,4)
incq %rax
jmp 0x4633
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
xorl %edi, %edi
testq %r15, %r15
setne %dil
notl %esi
shrl $0x1f, %esi
callq 0x3394
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
cmpq %rax, %r14
je 0x46ae
movl %ebx, (%r15,%rax,4)
incq %rax
jmp 0x46a0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %edi, %edi
testl %ebp, %ebp
setg %dil
xorl %esi, %esi
testl %ebx, %ebx
setg %sil
callq 0x3394
movl %ebp, %eax
cltd
idivl %ebx
movl %edx, %ebp
testl %edx, %edx
cmovel %ebx, %ebp
pushq $0x1
popq %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x419e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %edi, %edi
testq %r14, %r14
setne %dil
xorl %esi, %esi
cmpl $0x2, %ebp
setb %sil
xorl %edx, %edx
testq %r15, %r15
setne %dl
xorl %ecx, %ecx
testq %rbx, %rbx
setne %cl
callq 0x33da
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 0x47db
movq %r14, %rdi
xorl %esi, %esi
callq 0x4828
leaq 0x14b6(%rip), %rsi      # 0x5c6b
leaq 0x14b2(%rip), %rdx      # 0x5c6e
movl %eax, %edi
callq 0x4027
movq %r12, %rdi
movq %rax, %rsi
callq 0x1050
movq %r12, %rdi
movq %r14, %rsi
callq 0x1140
jmp 0x47e9
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 0x3957
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_O2/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
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %esi, (%r14)
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
notl %esi
shrl $0x1f, %esi
callq 0x3394
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44a5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xb01c(%rip)      # 0xf880
jne 0x4871
movl $0x1, 0xc144(%rip)      # 0x109b4
retq
pushq %rax
leaq 0x1479(%rip), %rdi      # 0x5cf2
leaq 0x103f(%rip), %rsi      # 0x58bf
leaq 0x1475(%rip), %rcx      # 0x5cfc
movl $0x31f, %edx            # imm = 0x31F
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 0x4d0c
movq %r14, %rdi
xorl %esi, %esi
callq 0x4828
leaq 0xf99(%rip), %rsi       # 0x5c6b
leaq 0xf95(%rip), %rdx       # 0x5c6e
movl %eax, %edi
callq 0x4027
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 0x4d17
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
movq %rbx, %rdi
callq 0x3957
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x4d9b
movq %rdi, %rbx
callq 0x3e4d
cmpl $0x3c, %eax
jae 0x4dba
pushq $0x3c
popq %rbp
subl %eax, %ebp
movl %eax, %r12d
andl $0x1, %r12d
movl %ebp, %ecx
andl $-0x2, %ecx
addl %r12d, %eax
addl %ecx, %eax
cmpl $0x3c, %eax
jne 0x4dd9
shrl %ebp
pushq $0x2a
popq %r14
movl %ebp, %edi
movl %r14d, %esi
callq 0x42fc
movq %rax, %r15
addl %r12d, %ebp
movl %ebp, %edi
movl %r14d, %esi
callq 0x42fc
leaq 0x12de(%rip), %rdi      # 0x6061
movq %r15, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
leaq 0x1252(%rip), %rdi      # 0x5ff4
leaq 0xb16(%rip), %rsi       # 0x58bf
leaq 0x124e(%rip), %rcx      # 0x5ffe
movl $0x395, %edx            # imm = 0x395
callq 0x10b0
leaq 0x1251(%rip), %rdi      # 0x6012
leaq 0xaf7(%rip), %rsi       # 0x58bf
leaq 0x122f(%rip), %rcx      # 0x5ffe
movl $0x397, %edx            # imm = 0x397
callq 0x10b0
leaq 0x124a(%rip), %rdi      # 0x602a
leaq 0xad8(%rip), %rsi       # 0x58bf
leaq 0x1210(%rip), %rcx      # 0x5ffe
movl $0x39a, %edx            # imm = 0x39A
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
notl %edi
shrl $0x1f, %edi
xorl %esi, %esi
testq %rbx, %rbx
setne %sil
callq 0x3394
movl %ebp, %edi
callq 0x426b
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3b0c
cmpl $0x2, %ebp
jl 0x4e47
leaq 0xde1(%rip), %rsi       # 0x5c1a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3a9f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
xorl %edi, %edi
testq %r15, %r15
setne %dil
xorl %esi, %esi
testq %rbx, %rbx
setne %sil
callq 0x3394
xorl %edi, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x419e
movq %r15, %rdi
callq 0x34ff
movslq %r14d, %r15
movslq %ebp, %r12
leaq 0x11b2(%rip), %r14      # 0x6069
cmpq %r12, %r15
jg 0x4ecf
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10a0
incq %r15
jmp 0x4eb7
pushq $0xa
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
js 0x4f1c
movslq 0xa985(%rip), %rax      # 0xf884
leal 0x1(%rax), %ecx
movl %ecx, 0xa97c(%rip)      # 0xf884
cmpq $0x5, %rax
jge 0x4f3b
leaq 0xbaab(%rip), %rcx      # 0x109c0
movq %rdi, 0x8(%rcx,%rax,8)
popq %rax
retq
leaq 0x1176(%rip), %rdi      # 0x6099
leaq 0x995(%rip), %rsi       # 0x58bf
leaq 0x1179(%rip), %rcx      # 0x60aa
movl $0x3fc, %edx            # imm = 0x3FC
callq 0x10b0
leaq 0x1179(%rip), %rdi      # 0x60bb
leaq 0x976(%rip), %rsi       # 0x58bf
leaq 0x115a(%rip), %rcx      # 0x60aa
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
movl 0xa921(%rip), %esi      # 0xf884
pushq $0x5
popq %rdx
xorl %edi, %edi
callq 0x419e
movslq 0xa910(%rip), %rax      # 0xf884
leaq 0xba45(%rip), %rcx      # 0x109c0
movq (%rcx,%rax,8), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, (%rcx,%rax,8)
testq %rdx, %rdx
jle 0x4fa6
testl %ebx, %ebx
jne 0x4fa2
andq $0x0, (%rcx,%rax,8)
leal -0x1(%rax), %ecx
movl %ecx, 0xa8e6(%rip)      # 0xf884
testl %eax, %eax
jle 0x4fc5
movl %ebx, %eax
popq %rbx
retq
leaq 0x1122(%rip), %rdi      # 0x60cf
leaq 0x90b(%rip), %rsi       # 0x58bf
leaq 0x1127(%rip), %rcx      # 0x60e2
movl $0x407, %edx            # imm = 0x407
callq 0x10b0
leaq 0xa31(%rip), %rdi       # 0x59fd
leaq 0x8ec(%rip), %rsi       # 0x58bf
leaq 0x1108(%rip), %rcx      # 0x60e2
movl $0x40b, %edx            # imm = 0x40B
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
xorl %esi, %esi
callq 0x1090
leaq 0x2e86(%rip), %rdx      # 0x4094
xorl %edi, %edi
xorl %esi, %esi
callq 0x10d0
cmpl $-0x1, %eax
je 0x122b
callq 0x1060
movl %eax, %edi
movl %ebx, %esi
popq %rbx
jmp 0x10a0
leaq 0xdd2(%rip), %rsi       # 0x2004
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x1030
movq %rax, %r14
movl (%rax), %ebp
movl %ebx, %edi
xorl %esi, %esi
callq 0x1090
leaq 0x2e38(%rip), %rdx      # 0x4094
xorl %edi, %edi
xorl %esi, %esi
callq 0x10d0
cmpl $-0x1, %eax
je 0x1280
callq 0x1060
movl %eax, %edi
movl %ebx, %esi
callq 0x10a0
movl %ebp, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd7d(%rip), %rsi       # 0x2004
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/marcespie[P]unix-samples/chapter2/ttysig.c
// Function: tcont_handler
void
tcont_handler(int sig)
{
	int save_errno = errno;

	signal(SIGTSTP, tstp_handler);
	errwrap(tcsetattr(0, TCSANOW, &mytty));
	errno = save_errno;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x1030
movq %rax, %rbx
movl (%rax), %ebp
leaq -0x69(%rip), %rsi       # 0x123c
pushq $0x14
popq %rdi
callq 0x1090
leaq 0x2e1c(%rip), %rdx      # 0x40d0
xorl %edi, %edi
xorl %esi, %esi
callq 0x10d0
cmpl $-0x1, %eax
je 0x12cb
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd52(%rip), %rsi       # 0x2024
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/marcespie[P]unix-samples/chapter2/ttysig.c
// Function: main
int
main()
{
	if (!isatty(0)) {
		fprintf(stderr, "This example programs shows tty behavior\n");
		exit(0);
	}
	// save basic tty stuff for later
	errwrap(tcgetattr(0, &basetty));
	errwrap(tcgetattr(0, &mytty));

	// obvious signals where we need to change/restore behavior
	signal(SIGTSTP, tstp_handler);
	signal(SIGCONT, tcont_handler);

	// all the signals that "kill" your program, so you should save
	// data AND restore the tty
	signal(SIGINT, byebye);
	signal(SIGQUIT, byebye);
	signal(SIGTERM, byebye);
	signal(SIGHUP, byebye);

	// XXX a lot of modern shells may handle tty modes for us, but
	// it's by no way guaranteed, so to be fully compliant we must
	// restore the tty on TSTP, and restore it on CONT.


	// tweak stuff we want (e.g., echo off)
	mytty.c_lflag &= ~ECHO;
	errwrap(tcsetattr(0, TCSANOW, &mytty));


	char buffer[MYSIZE];

	while (true) {
		ssize_t r;
		errwrap(r = read(0, buffer, sizeof buffer));
		if (r == 0)
			break;
		safe_write(1, buffer, r);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
xorl %edi, %edi
callq 0x1040
testl %eax, %eax
je 0x13df
leaq 0x2d99(%rip), %rsi      # 0x4094
xorl %edi, %edi
callq 0x10c0
cmpl $-0x1, %eax
je 0x1402
leaq 0x2dbe(%rip), %rsi      # 0x40d0
xorl %edi, %edi
callq 0x10c0
cmpl $-0x1, %eax
je 0x140b
leaq -0xed(%rip), %rsi       # 0x123c
pushq $0x14
popq %rdi
callq 0x1090
leaq -0xa7(%rip), %rsi       # 0x1291
pushq $0x12
popq %rdi
callq 0x1090
leaq -0x14a(%rip), %rbx      # 0x11fd
pushq $0x2
popq %rdi
movq %rbx, %rsi
callq 0x1090
pushq $0x3
popq %rdi
movq %rbx, %rsi
callq 0x1090
pushq $0xf
popq %rdi
movq %rbx, %rsi
callq 0x1090
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0x1090
leaq 0x2d56(%rip), %rdx      # 0x40d0
andb $-0x9, 0x2d5b(%rip)     # 0x40dc
xorl %edi, %edi
xorl %esi, %esi
callq 0x10d0
cmpl $-0x1, %eax
je 0x1414
movq %rsp, %rbx
pushq $0x1
popq %rbp
movl $0x400, %edx            # imm = 0x400
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1080
testq %rax, %rax
je 0x13c2
cmpq $-0x1, %rax
je 0x13ce
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1420
jmp 0x1399
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %rbp
retq
leaq 0xcc3(%rip), %rsi       # 0x2098
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x2c12(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xc52(%rip), %rdi       # 0x2042
pushq $0x29
popq %rsi
pushq $0x1
popq %rdx
callq 0x10f0
xorl %edi, %edi
callq 0x10e0
leaq 0xc63(%rip), %rsi       # 0x206c
jmp 0x13d5
leaq 0xc71(%rip), %rsi       # 0x2083
jmp 0x13d5
leaq 0xc09(%rip), %rsi       # 0x2024
jmp 0x13d5
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/marcespie[P]unix-samples/chapter2/safe_write.c
// Function: safe_write
void
safe_write(int fd, 
    const void *buf,
    size_t sz)
{
	const char *b = buf;
	while (sz != 0) {
		ssize_t r;
		errwrap(r = write(fd, b, sz));
		assert(r <= sz);
		b += r;
		sz -= r;
		// loop invariant: we have to write [buf, buf+sz[ to fd
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rbx, %rbx
je 0x144e
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1050
cmpq $-0x1, %rax
je 0x1453
subq %rax, %rbx
jb 0x1464
addq %rax, %r14
jmp 0x142c
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc61(%rip), %rsi       # 0x20bb
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x10b0
leaq 0xc65(%rip), %rdi       # 0x20d0
leaq 0xc66(%rip), %rsi       # 0x20d8
leaq 0xc6c(%rip), %rcx       # 0x20e5
pushq $0x11
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./utf32.c
// Function: utf32_strcmp
int utf32_strcmp(const int32_t *str1, const int32_t *str2) {
  while (*str1 && (*str1 == *str2)) {
    str1++;
    str2++;
  }
  return *str1 - *str2;
}

// Assembly:
xorl %ecx, %ecx
movl (%rdi,%rcx), %eax
movl (%rsi,%rcx), %edx
testl %eax, %eax
je 0x3592
cmpl %edx, %eax
jne 0x3592
addq $0x4, %rcx
jmp 0x357e
subl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./utf32.c
// Function: c_to_utf32
void c_to_utf32(const char *source, int32_t *dest, int max) {
  int i = 0;
  while (source[i] != '\0' && i < max - 1) {
    dest[i] = (int32_t)source[i];
    i++;
  }
  dest[i] = 0;
}

// Assembly:
decl %edx
movslq %edx, %rcx
xorl %eax, %eax
movsbl (%rdi,%rax), %edx
testl %edx, %edx
je 0x35b1
cmpq %rcx, %rax
jge 0x35b1
movl %edx, (%rsi,%rax,4)
incq %rax
jmp 0x359c
andl $0x0, (%rsi,%rax,4)
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./utf32.c
// Function: utf32_to_c
void utf32_to_c(const int32_t *source, char *dest, int max) {
  int i = 0;
  while (source[i] != 0 && i < max - 1) {
    if (source[i] <= 0x7F) {
      dest[i] = (char)source[i];
    } else {
      dest[i] = '?';
    }
    i++;
  }
  dest[i] = '\0';
}

// Assembly:
decl %edx
movslq %edx, %rcx
xorl %eax, %eax
pushq $0x3f
popq %rdx
movl (%rdi,%rax,4), %r8d
testl %r8d, %r8d
je 0x35e2
cmpq %rcx, %rax
jge 0x35e2
cmpl $0x80, %r8d
cmovgel %edx, %r8d
movb %r8b, (%rsi,%rax)
incq %rax
jmp 0x35c0
movb $0x0, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-error.c
// Function: handle_error
V handle_error(NgaState *vm, CELL error) {
  CELL saved_ip = vm->cpu[vm->active].ip;
  if (vm->ErrorHandlers[error] != 0) {
    printf("\nHandling %lld\n", (long long)error);
    execute(vm, vm->ErrorHandlers[error]);
  }
  vm->cpu[vm->active].ip = saved_ip;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x200004(%rdi), %r15
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rcx      # imm = 0x874
movl 0x20000c(%rdi,%rcx), %ebp
movslq %esi, %r14
cmpl $0x0, 0x2079c4(%rdi,%r14,4)
je 0x372f
movq %rdi, %rbx
leaq 0x5972(%rip), %rdi      # 0x9080
movq %r14, %rsi
xorl %eax, %eax
callq 0x3150
movl 0x2079c4(%rbx,%r14,4), %esi
movq %rbx, %rdi
callq 0x390d
movslq 0x2043a4(%rbx), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
movl %ebp, 0x8(%r15,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-ioctl.c
// Function: ioctl_get_terminal_size
void ioctl_get_terminal_size(NgaState *vm) {
  struct winsize size;
  ioctl(STDOUT_FILENO, TIOCGWINSZ, &size);
  stack_push(vm, size.ws_row);
  stack_push(vm, size.ws_col);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
movq %rsp, %r14
movl $0x5413, %esi           # imm = 0x5413
movq %r14, %rdx
xorl %eax, %eax
callq 0x31a0
movzwl (%r14), %eax
movslq 0x2043a4(%rbx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rbx, %rcx
addq $0x200004, %rcx         # imm = 0x200004
movslq (%rcx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, (%rcx)
movl %eax, 0x18(%rcx,%rdx,4)
movzwl 0x2(%r14), %eax
movslq 0x2043a4(%rbx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rbx, %rcx
addq $0x200004, %rcx         # imm = 0x200004
movslq (%rcx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, (%rcx)
movl %eax, 0x18(%rcx,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-ioctl.c
// Function: ioctl_set_character_breaking_mode
void ioctl_set_character_breaking_mode(NgaState *vm) {
  struct termios term;
  tcgetattr(STDIN_FILENO, &term);
  term.c_lflag &=(~ICANON & ECHO);
  tcsetattr(STDIN_FILENO, TCSANOW, &term);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x4(%rsp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x3300
andl $0x8, 0xc(%rbx)
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3310
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-ioctl.c
// Function: ioctl_set_line_buffered_mode
void ioctl_set_line_buffered_mode(NgaState *vm) {
  struct termios term;
  tcgetattr(STDIN_FILENO, &term);
  term.c_lflag |= ICANON;
  term.c_lflag |= ECHO;
  tcsetattr(STDIN_FILENO, TCSANOW, &term);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x4(%rsp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x3300
orb $0xa, 0xc(%rbx)
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3310
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-blocks.c
// Function: read_block
V read_block(NgaState *vm) {
  CELL buffer = stack_pop(vm);
  CELL block = stack_pop(vm);
  int32_t m[1024];
  int fp = open(vm->BlockFile, O_RDONLY, 0666);
  lseek(fp, 4096 * block, SEEK_SET);
  read(fp, m, 4096);
  for (int i = 0; i < 1024; i++) {
    vm->memory[buffer + i] = (CELL)m[i];
  }
  close(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%rdi,%rax), %rcx
movslq 0x200004(%rdi,%rax), %rdx
leaq -0x1(%rdx), %rsi
movl %esi, 0x200004(%rdi,%rax)
movslq 0x200018(%rcx,%rdx,4), %r12
leal -0x2(%rdx), %esi
movl %esi, 0x200004(%rdi,%rax)
movslq 0x200014(%rcx,%rdx,4), %r14
addq $0x2075c0, %rdi         # imm = 0x2075C0
xorl %r15d, %r15d
xorl %esi, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x3320
movl %eax, %ebp
shlq $0xc, %r14
movl %eax, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3190
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x3210
leaq (%rbx,%r12,4), %rax
cmpq $0x400, %r15            # imm = 0x400
je 0x3b55
movl (%rsp,%r15,4), %ecx
movl %ecx, (%rax,%r15,4)
incq %r15
jmp 0x3b3f
movl %ebp, %edi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31c0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-blocks.c
// Function: write_block
V write_block(NgaState *vm) {
  CELL buffer = stack_pop(vm);
  CELL block = stack_pop(vm);
  int32_t m[1024];
  int fp = open(vm->BlockFile, O_WRONLY, 0666);
  lseek(fp, 4096 * block, SEEK_SET);
  for (int i = 0; i < 1024; i++) {
    m[i] = (int32_t)vm->memory[buffer + i];
  }
  write(fp, m, 4096);
  close(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %r14
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%rdi,%rax), %rcx
movslq 0x200004(%rdi,%rax), %rdx
leaq -0x1(%rdx), %rsi
movl %esi, 0x200004(%rdi,%rax)
movslq 0x200018(%rcx,%rdx,4), %r13
leal -0x2(%rdx), %esi
movl %esi, 0x200004(%rdi,%rax)
movslq 0x200014(%rcx,%rdx,4), %r15
addq $0x2075c0, %rdi         # imm = 0x2075C0
xorl %r12d, %r12d
pushq $0x1
popq %rsi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x3320
movl %eax, %ebx
shlq $0xc, %r15
movl %eax, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3190
leaq (%r14,%r13,4), %rax
cmpq $0x400, %r12            # imm = 0x400
je 0x3c02
movl (%rax,%r12,4), %ecx
movl %ecx, (%rsp,%r12,4)
incq %r12
jmp 0x3bec
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
callq 0x30d0
movl %ebx, %edi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31c0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/retro.c
// Function: string_extract
char *string_extract(NgaState *vm, CELL at) {
  CELL starting = at, i = 0;
  while (vm->memory[starting] && i < 8192)
    vm->string_data[i++] = (char)vm->memory[starting++];
  vm->string_data[i] = 0;
  return (char *)vm->string_data;
}

// Assembly:
movq %rdi, %rax
movslq %esi, %rcx
leaq (%rdi,%rcx,4), %rcx
addq $0x2045b8, %rax         # imm = 0x2045B8
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
testl %esi, %esi
je 0x3ce3
cmpq $0x1fff, %rdx           # imm = 0x1FFF
ja 0x3ce3
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x3cca
movb $0x0, (%rax,%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_open
V file_open(NgaState *vm) {
  CELL slot = files_get_handle(vm);
  CELL mode = stack_pop(vm);
  CELL name = stack_pop(vm);
  char *modes[] = {"rb", "w", "a", "rb+"};
  char *request = string_extract(vm, name);
  if (slot > 0) {
    vm->OpenFileHandles[slot] = fopen(request, modes[mode]);
  }
  if (vm->OpenFileHandles[slot] == NULL) {
    vm->OpenFileHandles[slot] = 0;
    slot = 0;
  }
  stack_push(vm, slot);
//  FILE *file = (slot > 0) ? fopen(request, modes[mode]) : NULL;
//  vm->OpenFileHandles[slot] = (file != NULL) ? file : 0;
//  stack_push(vm, slot);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3d7c
movl %eax, %ebp
movslq 0x2043a4(%rbx), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
addq %rbx, %rax
addq $0x200004, %rax         # imm = 0x200004
movslq (%rax), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, (%rax)
movslq 0x14(%rax,%rcx,4), %r14
leal -0x2(%rcx), %edx
movl %edx, (%rax)
movl 0x10(%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x3cb8
testl %ebp, %ebp
jle 0x3e05
leaq 0x524a(%rip), %rcx      # 0x9034
movslq (%rcx,%r14,4), %rsi
addq %rcx, %rsi
movq %rax, %rdi
callq 0x3340
movl %ebp, %ecx
movq %rax, 0x288ef0(%rbx,%rcx,8)
jmp 0x3e10
movslq %ebp, %rcx
movq 0x288ef0(%rbx,%rcx,8), %rax
leaq 0x200004(%rbx), %rdx
testq %rax, %rax
jne 0x3e27
andq $0x0, 0x288ef0(%rbx,%rcx,8)
xorl %ebp, %ebp
movslq 0x2043a4(%rbx), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%rdx,%rax), %rcx
movslq (%rdx,%rax), %rsi
leaq 0x1(%rsi), %rdi
movl %edi, (%rdx,%rax)
movl %ebp, 0x18(%rcx,%rsi,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_read
V file_read(NgaState *vm) {
  CELL slot = stack_pop(vm);
  FILE *file = vm->OpenFileHandles[slot];
  if (slot <= 0 || slot > MAX_OPEN_FILES || file == 0) {
    printf("\nERROR (nga/file_read): Invalid file handle\n");
    exit(1);
  }
  stack_push(vm, feof(file) ? 0 : fgetc(file));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
addq %rdi, %rax
addq $0x200004, %rax         # imm = 0x200004
movslq (%rax), %rcx
leal -0x1(%rcx), %edx
movl %edx, (%rax)
movslq 0x14(%rax,%rcx,4), %rax
leal -0x21(%rax), %ecx
cmpl $-0x20, %ecx
jb 0x3ed5
movq %rdi, %rbx
movq 0x288ef0(%rdi,%rax,8), %r14
testq %r14, %r14
je 0x3ed5
leaq 0x200004(%rbx), %r15
movq %r14, %rdi
callq 0x3280
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x3ead
movq %r14, %rdi
callq 0x31b0
movslq 0x2043a4(%rbx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
leaq (%r15,%rcx), %rdx
movslq (%r15,%rcx), %rsi
leaq 0x1(%rsi), %rdi
movl %edi, (%r15,%rcx)
movl %eax, 0x18(%rdx,%rsi,4)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5529(%rip), %rdi      # 0x9405
callq 0x30a0
pushq $0x1
popq %rdi
callq 0x33b0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_close
V file_close(NgaState *vm) {
  CELL slot = stack_pop(vm);
  FILE *file = vm->OpenFileHandles[slot];
  if (slot <= 0 || slot > MAX_OPEN_FILES || file == 0) {
    printf("\nERROR (nga/file_close): Invalid file handle\n");
    exit(1);
  }
  fclose(file);
  vm->OpenFileHandles[slot] = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%rdi,%rax), %rcx
movslq 0x200004(%rdi,%rax), %rdx
leal -0x1(%rdx), %esi
movl %esi, 0x200004(%rdi,%rax)
movslq 0x200018(%rcx,%rdx,4), %r14
leal -0x21(%r14), %eax
cmpl $-0x20, %eax
jb 0x3fb6
movq %rdi, %rbx
movq 0x288ef0(%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x3fb6
callq 0x3110
andq $0x0, 0x288ef0(%rbx,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5329(%rip), %rdi      # 0x92e6
callq 0x30a0
pushq $0x1
popq %rdi
callq 0x33b0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_get_position
V file_get_position(NgaState *vm) {
  CELL slot = stack_pop(vm);
  if (slot <= 0 || slot > MAX_OPEN_FILES || vm->OpenFileHandles[slot] == 0) {
    printf("\nERROR (nga/file_get_position): Invalid file handle\n");
    exit(1);
  }
  stack_push(vm, (CELL) ftell(vm->OpenFileHandles[slot]));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
addq %rdi, %rax
addq $0x200004, %rax         # imm = 0x200004
movslq (%rax), %rcx
leal -0x1(%rcx), %edx
movl %edx, (%rax)
movl 0x14(%rax,%rcx,4), %eax
leal -0x21(%rax), %ecx
cmpl $-0x20, %ecx
jb 0x403f
movq %rdi, %rbx
movq 0x288ef0(%rdi,%rax,8), %rdi
testq %rdi, %rdi
je 0x403f
leaq 0x200004(%rbx), %r14
callq 0x3270
movslq 0x2043a4(%rbx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
leaq (%r14,%rcx), %rdx
movslq (%r14,%rcx), %rsi
leaq 0x1(%rsi), %rdi
movl %edi, (%r14,%rcx)
movl %eax, 0x18(%rdx,%rsi,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x52cd(%rip), %rdi      # 0x9313
callq 0x30a0
pushq $0x1
popq %rdi
callq 0x33b0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_get_size
V file_get_size(NgaState *vm) {
  CELL slot, current, r, size;
  struct stat buffer;
  slot = stack_pop(vm);
  if (slot <= 0 || slot > MAX_OPEN_FILES || vm->OpenFileHandles[slot] == 0) {
    printf("\nERROR (nga/file_get_size): Invalid file handle\n");
    exit(1);
  }
  fstat(fileno(vm->OpenFileHandles[slot]), &buffer);
  if (!S_ISDIR(buffer.st_mode)) {
    current = ftell(vm->OpenFileHandles[slot]);
    r = fseek(vm->OpenFileHandles[slot], 0, SEEK_END);
    size = ftell(vm->OpenFileHandles[slot]);
    fseek(vm->OpenFileHandles[slot], current, SEEK_SET);
  } else {
    r = -1;
    size = 0;
  }
  stack_push(vm, (r == 0) ? size : 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
addq %rdi, %rax
addq $0x200004, %rax         # imm = 0x200004
movslq (%rax), %rcx
leal -0x1(%rcx), %edx
movl %edx, (%rax)
movl 0x14(%rax,%rcx,4), %r13d
leal -0x21(%r13), %eax
cmpl $-0x20, %eax
jb 0x41ce
movq %rdi, %rbx
movq 0x288ef0(%rdi,%r13,8), %rdi
testq %rdi, %rdi
je 0x41ce
leaq 0x200004(%rbx), %r12
callq 0x32b0
leaq 0x8(%rsp), %r14
movl %eax, %edi
movq %r14, %rsi
callq 0x3410
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%r14), %eax
xorl %r14d, %r14d
cmpl $0x4000, %eax           # imm = 0x4000
je 0x4199
movq 0x288ef0(%rbx,%r13,8), %rdi
callq 0x3270
movq %rax, %r15
movq 0x288ef0(%rbx,%r13,8), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x32f0
movl %eax, %ebp
movq 0x288ef0(%rbx,%r13,8), %rdi
callq 0x3270
movq %rax, %r14
movq 0x288ef0(%rbx,%r13,8), %rdi
movslq %r15d, %rsi
xorl %edx, %edx
callq 0x32f0
testl %ebp, %ebp
movl $0x0, %eax
cmovnel %eax, %r14d
movslq 0x2043a4(%rbx), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%r12,%rax), %rcx
movslq (%r12,%rax), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, (%r12,%rax)
movl %r14d, 0x18(%rcx,%rdx,4)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51a6(%rip), %rdi      # 0x937b
callq 0x30a0
pushq $0x1
popq %rdi
callq 0x33b0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_delete
V file_delete(NgaState *vm) {
  char *request;
  CELL name = stack_pop(vm);
  request = string_extract(vm, name);
  unlink(request);
}

// Assembly:
pushq %rax
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%rdi,%rax), %rcx
movslq 0x200004(%rdi,%rax), %rdx
leal -0x1(%rdx), %esi
movl %esi, 0x200004(%rdi,%rax)
movl 0x200018(%rcx,%rdx,4), %esi
callq 0x3cb8
movq %rax, %rdi
popq %rax
jmp 0x3080
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_read_bytes
V file_read_bytes(NgaState *vm) {
  CELL slot = stack_pop(vm);
  CELL size = stack_pop(vm);
  CELL dest = stack_pop(vm);
  CELL z = fread((char *)file_bytes, 1, size, vm->OpenFileHandles[slot]);
  for (CELL i = 0; i < size; i++) {
    CELL x = file_bytes[i];
    vm->memory[dest + i] = x;
  }
  stack_push(vm, z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x200004(%rdi), %r12
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
addq %rdi, %rax
addq $0x200004, %rax         # imm = 0x200004
movslq (%rax), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, (%rax)
movslq 0x14(%rax,%rcx,4), %rdx
leaq -0x2(%rcx), %rsi
movl %esi, (%rax)
movslq 0x10(%rax,%rcx,4), %r15
leal -0x3(%rcx), %esi
movl %esi, (%rax)
movslq 0xc(%rax,%rcx,4), %r13
movq 0x288ef0(%rdi,%rdx,8), %rcx
leaq 0x4ffaf(%rip), %r14     # 0x54280
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x30b0
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
leaq (%rbx,%r13,4), %rsi
cmpq %rcx, %rdx
je 0x4303
movsbl (%rcx,%r14), %edi
movl %edi, (%rsi,%rcx,4)
incq %rcx
jmp 0x42f1
movslq 0x2043a4(%rbx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
leaq (%r12,%rcx), %rdx
movslq (%r12,%rcx), %rsi
leaq 0x1(%rsi), %rdi
movl %edi, (%r12,%rcx)
movl %eax, 0x18(%rdx,%rsi,4)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_write_bytes
V file_write_bytes(NgaState *vm) {
  CELL slot = stack_pop(vm);
  CELL size = stack_pop(vm);
  CELL src  = stack_pop(vm);
  for (CELL i = 0; i < size; i++) {
    char x = vm->memory[src + i];
    file_bytes[i] = x;
  }
  CELL z = fwrite(&file_bytes, 1, size, vm->OpenFileHandles[slot]);
  stack_push(vm, z);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x200004(%rdi), %r14
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%rdi,%rax), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movslq (%rcx), %rsi
leaq -0x1(%rsi), %rax
movl %eax, (%rcx)
movslq 0x14(%rcx,%rsi,4), %rax
leaq -0x2(%rsi), %rdx
movl %edx, (%rcx)
movslq 0x10(%rcx,%rsi,4), %rdx
leal -0x3(%rsi), %edi
movl %edi, (%rcx)
movslq 0xc(%rcx,%rsi,4), %rdi
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %esi
cmovgl %edx, %esi
leaq (%rbx,%rdi,4), %rdi
leaq 0x4fef0(%rip), %r8      # 0x54280
cmpq %rcx, %rsi
je 0x43a2
movb (%rdi,%rcx,4), %r9b
movb %r9b, (%rcx,%r8)
incq %rcx
jmp 0x4390
movq 0x288ef0(%rbx,%rax,8), %rcx
leaq 0x4fecf(%rip), %rdi     # 0x54280
pushq $0x1
popq %rsi
callq 0x33c0
movslq 0x2043a4(%rbx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
leaq (%r14,%rcx), %rdx
movslq (%r14,%rcx), %rsi
leaq 0x1(%rsi), %rdi
movl %edi, (%r14,%rcx)
movl %eax, 0x18(%rdx,%rsi,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_read_character
V file_read_character(NgaState *vm) {
  CELL c;
  CELL slot = stack_pop(vm);
  if (slot <= 0 || slot > MAX_OPEN_FILES || vm->OpenFileHandles[slot] == 0) {
    printf("\nERROR (nga/file_read): Invalid file handle\n");
    exit(1);
  }
  c = fread_character(vm->OpenFileHandles[slot]);
  stack_push(vm, feof(vm->OpenFileHandles[slot]) ? 0 : c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
addq %rdi, %rax
addq $0x200004, %rax         # imm = 0x200004
movslq (%rax), %rcx
leal -0x1(%rcx), %edx
movl %edx, (%rax)
movl 0x14(%rax,%rcx,4), %r14d
leal -0x21(%r14), %eax
cmpl $-0x20, %eax
jb 0x4476
movq %rdi, %rbx
movq 0x288ef0(%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x4476
leaq 0x200004(%rbx), %r15
callq 0x448a
movl %eax, %ebp
movq 0x288ef0(%rbx,%r14,8), %rdi
callq 0x3280
xorl %ecx, %ecx
testl %eax, %eax
cmovel %ebp, %ecx
movslq 0x2043a4(%rbx), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%r15,%rax), %rdx
movslq (%r15,%rax), %rsi
leaq 0x1(%rsi), %rdi
movl %edi, (%r15,%rax)
movl %ecx, 0x18(%rdx,%rsi,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f88(%rip), %rdi      # 0x9405
callq 0x30a0
pushq $0x1
popq %rdi
callq 0x33b0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_write_character
V file_write_character(NgaState *vm) {
  unsigned char utf8_bytes[4];
  int num_bytes;
  CELL slot, c, r;
  utf32_to_utf8(stack_pop(vm), utf8_bytes, &num_bytes);
  slot = stack_pop(vm);
  if (slot <= 0 || slot > MAX_OPEN_FILES || vm->OpenFileHandles[slot] == 0) {
    printf("\nERROR (nga/file_write): Invalid file handle\n");
    exit(1);
  }
  r = fwrite(&utf8_bytes, num_bytes, 1, vm->OpenFileHandles[slot]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %r14      # imm = 0x874
leaq (%rdi,%r14), %r15
movslq 0x200004(%rdi,%r14), %r12
leaq -0x1(%r12), %rax
movl %eax, 0x200004(%rdi,%r14)
movl 0x200018(%r15,%r12,4), %edi
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
callq 0x465c
leal -0x2(%r12), %eax
movl %eax, 0x200004(%rbx,%r14)
movl 0x200014(%r15,%r12,4), %eax
leal -0x21(%rax), %ecx
cmpl $-0x20, %ecx
jb 0x4648
movq 0x288ef0(%rbx,%rax,8), %rcx
testq %rcx, %rcx
je 0x4648
movslq (%rsp), %rsi
leaq 0x4(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x33c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4d89(%rip), %rdi      # 0x93d8
callq 0x30a0
pushq $0x1
popq %rdi
callq 0x33b0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/vm/nga-c/./dev-files.c
// Function: file_read_line
V file_read_line(NgaState *vm) {
  CELL slot = stack_pop(vm);
  CELL targ = stack_pop(vm);
  CELL c;
  if (slot <= 0 || slot > MAX_OPEN_FILES || vm->OpenFileHandles[slot] == 0) {
    printf("\nERROR (nga/file_read): Invalid file handle\n");
    exit(1);
  }
  c = fread_character(vm->OpenFileHandles[slot]);
  vm->memory[targ] = c;
  targ++;
  while (c != 10 && c != 13 && c != 0) {
    c = fread_character(vm->OpenFileHandles[slot]);
    vm->memory[targ] = c;
    targ++;
  }
  vm->memory[targ - 1] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x2043a4(%rdi), %rax
imulq $0x874, %rax, %rdx      # imm = 0x874
leaq (%rdi,%rdx), %rax
movslq 0x200004(%rdi,%rdx), %rcx
leaq -0x1(%rcx), %rsi
movl %esi, 0x200004(%rdi,%rdx)
movl 0x200018(%rax,%rcx,4), %r14d
leal -0x2(%rcx), %esi
movl %esi, 0x200004(%rdi,%rdx)
leal -0x21(%r14), %edx
cmpl $-0x20, %edx
jb 0x47b1
movq %rdi, %rbx
movq 0x288ef0(%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x47b1
movslq 0x200014(%rax,%rcx,4), %r15
callq 0x448a
leaq (%rbx,%r15,4), %r12
shlq $0x20, %r15
movabsq $0x100000000, %r13      # imm = 0x100000000
movl $0x2401, %ebp           # imm = 0x2401
movl %eax, (%r12)
cmpl $0xd, %eax
ja 0x4783
btl %eax, %ebp
jb 0x4799
movq 0x288ef0(%rbx,%r14,8), %rdi
callq 0x448a
addq %r13, %r15
addq $0x4, %r12
jmp 0x4775
sarq $0x1e, %r15
andl $0x0, (%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4c4d(%rip), %rdi      # 0x9405
callq 0x30a0
pushq $0x1
popq %rdi
callq 0x33b0