LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: bConsonnE2
int bConsonnE2(char *sString,int *pnCodeCaractereRg){
	//sString[*pnCodeCaractereRg] ou Chaine[*pnCodeCaractereRg..*pnCodeCaractereRg+1] code une consonne;si vrai et 2 codes, passe au code suivant
	int nCar;
	char cCode;
    #define knConsonne1LiM 21
    #define knConsonne2LiM 04
	int nConsonne1[knConsonne1LiM]={64,65,66,67,69,70,71,73,74,75,76,77,79,80,81,82,83,85,86,87,89};//consonnes sans signe diacritique
	int nConsonne2[knConsonne2LiM]={79,89,111,121};//ççÑñ";
	int bConsonne2=0;
	Vrai2(sString!=0,pnCodeCaractereRg!=0);
	Croit(0,2,strlen(sString));
	Croit(0,*pnCodeCaractereRg,strlen(sString));
	cCode=sString[*pnCodeCaractereRg];
	bConsonne2=isalpha(cCode);//consonne ou voyelle sans signe diacritique (accents,cédille,tilde...)
	if (bConsonne2){//consonne?
		assert(0);//ie code actuellt non exécuté vu le contexte des appels à bConsonnE2()
		for (bConsonne2=0,nCar=0; nCar<knConsonne1LiM; nCar++)
			bConsonne2=bConsonne2||(cCode==-nConsonne1[nCar]);
		}
	else if (*pnCodeCaractereRg<strlen(sString)) {//l'accès à sString[nCodeCaractereRg+1] est valide
		if (cCode==kcEchappemenT1){
			cCode=sString[*pnCodeCaractereRg+1];
			for (nCar=0; nCar<knConsonne2LiM; nCar++)
				bConsonne2=bConsonne2||(cCode==-nConsonne2[nCar]);
			if (bConsonne2)
				(*pnCodeCaractereRg)++;
		}
	}
	return(bConsonne2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
xorl %edx, %edx
testq %rbx, %rbx
setne %dl
movl $0x1, (%rsp)
leaq 0x1ada(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
movq %r14, %rdi
callq 0x1090
xorl %ebp, %ebp
xorl %edi, %edi
movl $0x2, %esi
movl %eax, %edx
callq 0x48b8
movl (%rbx), %r15d
movq %r14, %rdi
callq 0x1090
xorl %edi, %edi
movl %r15d, %esi
movl %eax, %edx
callq 0x48b8
movslq (%rbx), %r15
movsbq (%r14,%r15), %r12
callq 0x1180
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r12,2)
jne 0x4899
movq %r14, %rdi
callq 0x1090
cmpb $-0x3d, %r12b
jne 0x488a
cmpq %r15, %rax
jbe 0x488a
movsbl 0x1(%r14,%r15), %eax
xorl %ecx, %ecx
leaq 0x2013(%rip), %rdx      # 0x6860
xorl %esi, %esi
testl %esi, %esi
je 0x4863
incq %rcx
movl $0x1, %esi
cmpq $0x4, %rcx
jne 0x484f
jmp 0x487f
xorl %edi, %edi
subl (%rdx,%rcx,4), %edi
xorl %esi, %esi
cmpl %edi, %eax
sete %sil
incq %rcx
cmpq $0x4, %rcx
jne 0x484f
xorl %ebp, %ebp
cmpl %edi, %eax
jne 0x488a
incl %r15d
movl %r15d, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2240(%rip), %rdi      # 0x6ae0
leaq 0x2098(%rip), %rsi      # 0x693f
leaq 0x22ea(%rip), %rcx      # 0x6b98
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sCouple
char *sCouple(int iEntierA,int iEntierB){
	//rend la chaîne (iEntierA,iEntierB)	
	char *sCouple=sP(sC3(sEntier(iEntierA),",",sEntier(iEntierB)));
	OctetGereR(sCouple);
	return(sCouple);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl $0x18, %edi
callq 0x1110
movq %rax, %r14
leaq 0x18d4(%rip), %r15      # 0x61e9
movq %rax, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
movl $0x18, %edi
callq 0x1110
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1150
leaq 0x226f(%rip), %rsi      # 0x6bb6
movq %r14, %rdi
callq 0x3f5d
movq %rax, %rdi
movq %r12, %rsi
callq 0x3f5d
movq %rax, %rdi
callq 0x4979
movq %rax, %rbx
movq %rax, %rdi
callq 0x3e0c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sP
char *sP(char *sEntreParenthese){
	//rend sEntreParenthese précédé de "(" et suivi de ")"
	assert(sEntreParenthese!=0);	
	char *sP=sC3("(",sEntreParenthese,")");
	OctetGereR(sP);
	return(sP);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x49ad
movq %rdi, %rsi
leaq 0x26e5(%rip), %rdi      # 0x706e
callq 0x3f5d
leaq 0x23f9(%rip), %rsi      # 0x6d8e
movq %rax, %rdi
callq 0x3f5d
movq %rax, %rbx
movq %rax, %rdi
callq 0x3e0c
movq %rbx, %rax
popq %rbx
retq
leaq 0x2695(%rip), %rdi      # 0x7049
leaq 0x1f84(%rip), %rsi      # 0x693f
leaq 0x269b(%rip), %rcx      # 0x705d
movl $0x362, %edx            # imm = 0x362
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sEntier
char *sEntier(int iEntier){
	//convertit iEntier en chaîne de chiffres décimaux: 24 donne "24", -5 donne "-5".
	char *sEntier=malloc(23+kuAntiSlashZerO);//2**64=4 milliards au carré = 16*(10**18) dc "4"+18 zéros=19 chiffres; ajouter 1 caractère pr le signe "-".
	sprintf(sEntier,"%d",iEntier);//iEntier tient forcément ds sEntier vu allocation généreuse: 4 octets alloués là où 21 suffisent.
	return(sEntier);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x18, %edi
callq 0x1110
movq %rax, %r14
leaq 0x1803(%rip), %rsi      # 0x61e9
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_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sFois
char *sFois(int nFois,char cMotif){
	//juxtapose nFois cMotif
	int uF;
	char *sFwa;
	char cFwa[2];
	Vrai2(nFois>=0,isprint(cMotif));//implique 1 code caractère par caractère,dc cMotif ne peut coder un "é" car il est occupe 2 codes caractères.
	sFwa=malloc(nFois+kuAntiSlashZerO);
	cFwa[0]=cMotif;
	cFwa[1]='\0';
	strcpy(sFwa,cFwa);
	for (uF=2;uF<=nFois;uF++)
		strcat(sFwa,cFwa);
	OctetGereR(sFwa);
	return(sFwa);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movl %edi, %ebx
movl %edi, %r14d
notl %r14d
shrl $0x1f, %r14d
callq 0x1180
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %edx
andl $0x4000, %edx           # imm = 0x4000
movl $0x1, (%rsp)
leaq 0x180e(%rip), %rdi      # 0x62a8
movl %r14d, %esi
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0x1110
movq %rax, %r14
leaq 0x16(%rsp), %rsi
movb %bpl, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rax, %rdi
callq 0x1050
cmpl $0x2, %ebx
jl 0x4af0
decl %ebx
leaq 0x16(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1140
decl %ebx
jne 0x4ae1
movq %r14, %rdi
callq 0x3e0c
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sEntierAvecSigne
char *sEntierAvecSigne(int iEntier){
	//// "+5" ou "-5" ou " 0"
	char *sEntier=malloc(23+kuAntiSlashZerO);//2**64=4 milliards au carré = 16*(10**18) dc "4"+18 zéros=19 chiffres; ajouter 1 caractère pr le signe "-".
	sprintf(sEntier,"%+d",iEntier);//iEntier tient forcément ds sEntier vu allocation généreuse: 4 octets alloués là où 21 suffisent.
	return(sEntier);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x18, %edi
callq 0x1110
movq %rax, %r14
leaq 0x216e(%rip), %rsi      # 0x6c8e
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_O3/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 0x4b66
movq %rbx, %rdi
callq 0x1090
movl $0x747365, (%rbx,%rax)  # imm = 0x747365
jmp 0x4b79
movabsq $0x617020747365276e, %rax # imm = 0x617020747365276E
movq %rax, (%rbx)
movw $0x73, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3e0c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: nHasard
int nHasard(int uBorneLim){
	//rend un nombre aléatoire ds [0..uBorneLim[
	int nHasard;
	Croit(1,uBorneLim,kuIntegerMaX-1);
	nHasard=rand()%uBorneLim;
	Croit(0,nHasard,uBorneLim-1);
	return(nHasard);
}

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x1, %edi
movl %ebx, %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
callq 0x48b8
callq 0x1170
cltd
idivl %ebx
leal 0x1(%rdx), %ebp
movl $0x1, %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x48b8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d38
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ebp
callq 0x1090
xorl %r13d, %r13d
xorl %edi, %edi
movl %ebp, %esi
movl %eax, %edx
callq 0x48b8
movslq (%rbx), %r15
movsbq (%r14,%r15), %r12
callq 0x1180
movq (%rax), %rax
testb $0x4, 0x1(%rax,%r12,2)
jne 0x4ce9
movq %r14, %rdi
callq 0x1090
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
jbe 0x4d14
cmpb $-0x3b, %r12b
je 0x4d23
movzbl %r12b, %ecx
cmpl $0xc3, %ecx
jne 0x4d14
movsbl 0x1(%r14,%r15), %ecx
xorl %eax, %eax
leaq 0x1c0b(%rip), %rdx      # 0x68c0
xorl %esi, %esi
testl %esi, %esi
je 0x4ccb
incq %rax
movl $0x1, %esi
cmpq $0x1d, %rax
jne 0x4cb7
jmp 0x4d2b
xorl %edi, %edi
subl (%rdx,%rax,4), %edi
xorl %esi, %esi
cmpl %edi, %ecx
sete %sil
incq %rax
cmpq $0x1d, %rax
jne 0x4cb7
xorl %eax, %eax
cmpl %edi, %ecx
jne 0x4d14
jmp 0x4d2b
leaq 0x1bd0(%rip), %rcx      # 0x68c0
xorl %edx, %edx
movl $0x1, %eax
testl %r13d, %r13d
jne 0x4d07
xorl %eax, %eax
movl (%rdx,%rcx), %esi
addl %r12d, %esi
sete %al
addq $0x4, %rdx
movl %eax, %r13d
cmpq $0x74, %rdx
jne 0x4cf2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $-0x48, 0x1(%r14,%r15)
jne 0x4d14
incl %r15d
movl %r15d, (%rbx)
movl $0x1, %eax
jmp 0x4d14
leaq 0x1c91(%rip), %rdi      # 0x69d0
leaq 0x1bf9(%rip), %rsi      # 0x693f
leaq 0x23a0(%rip), %rcx      # 0x70ed
movl $0x3c0, %edx            # imm = 0x3C0
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
movl %r14d, %edx
notl %edx
shrl $0x1f, %edx
movl $0x1, (%rsp)
leaq 0x14aa(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
testl %r14d, %r14d
jle 0x4f0e
movl %r14d, %eax
addl $0x3, %r14d
decq %rax
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %r14d
shlq $0x4, %r14
movdqa 0x19df(%rip), %xmm1     # 0x6820
movdqa 0x19e7(%rip), %xmm2     # 0x6830
xorl %eax, %eax
movdqa 0x19ed(%rip), %xmm3     # 0x6840
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x19ed(%rip), %xmm5     # 0x6850
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %ecx
notl %ecx
testb $0x1, %cl
je 0x4e9b
movl %ebx, (%r15,%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x4eae
movl %ebx, 0x4(%r15,%rax)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %ecx
testb $0x1, %cl
je 0x4eea
movl %ebx, 0x8(%r15,%rax)
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x4ef9
movl %ebx, 0xc(%r15,%rax)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x10, %rax
cmpq %rax, %r14
jne 0x4e63
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: 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
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
movl %r14d, %edx
notl %edx
shrl $0x1f, %edx
movl $0x1, (%rsp)
leaq 0x130f(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
testl %r14d, %r14d
jle 0x50a9
movl %r14d, %eax
addl $0x3, %r14d
decq %rax
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %r14d
shlq $0x4, %r14
movdqa 0x1844(%rip), %xmm1     # 0x6820
movdqa 0x184c(%rip), %xmm2     # 0x6830
xorl %eax, %eax
movdqa 0x1852(%rip), %xmm3     # 0x6840
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x1852(%rip), %xmm5     # 0x6850
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %ecx
notl %ecx
testb $0x1, %cl
je 0x5036
movl %ebx, (%r15,%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x5049
movl %ebx, 0x4(%r15,%rax)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %ecx
testb $0x1, %cl
je 0x5085
movl %ebx, 0x8(%r15,%rax)
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x5094
movl %ebx, 0xc(%r15,%rax)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x10, %rax
cmpq %rax, %r14
jne 0x4ffe
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: uModulo1
int uModulo1(int uDividende,int uDiviseur){
	//rend le modulo standard à ceci près que le résultat 0 éventuel est remplacé par uDiviseur: uModulo1(12,4)=4 
	int nModulo;
	Vrai2(uDividende>0,uDiviseur>0);
	nModulo=uDividende%uDiviseur;
	if (nModulo==0)
		nModulo=uDiviseur;
	if (0)//ou 1 pr que li+1 soit exécutée 
		seee("uModulo1",uDividende,uDiviseur,nModulo);
	Croit(1,nModulo,uDiviseur);
	return(nModulo);
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
xorl %edx, %edx
cmpl $0x2, %ebp
setb %dl
xorl %ecx, %ecx
testq %r15, %r15
setne %cl
xorl %r8d, %r8d
testq %rbx, %rbx
setne %r8b
movl $0x1, (%rsp)
leaq 0x1114(%rip), %rdi      # 0x62a8
movl $0x1, %r9d
callq 0x3550
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 0x520f
movq %r14, %rdi
xorl %esi, %esi
callq 0x525c
leaq 0x1b02(%rip), %rsi      # 0x6ceb
leaq 0x1afe(%rip), %rdx      # 0x6cee
movl %eax, %edi
callq 0x46eb
movq %r12, %rdi
movq %rax, %rsi
callq 0x1050
movq %r12, %rdi
movq %r14, %rsi
callq 0x1140
jmp 0x521d
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 0x3e0c
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_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: bVoyelle
int bVoyelle(char *sString,int nCodeCaractereRg){
	//sString[nCodeCaractereRg] ou Chaine[nCodeCaractereRg..nCodeCaractereRg+1] code une voyelle
	int nRg=nCodeCaractereRg;
	Vrai2(sString!=0,nCodeCaractereRg>=0);
	int bVoyelle=bVoyellE2(sString,&nRg);
	return(bVoyelle);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
movl %esi, (%r14)
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
notl %edx
shrl $0x1f, %edx
movl $0x1, (%rsp)
leaq 0x101c(%rip), %rdi      # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4c33
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xb5c4(%rip)      # 0x10880
jne 0x52c9
movl $0x1, 0xc6ec(%rip)      # 0x119b4
retq
pushq %rax
leaq 0x1aa1(%rip), %rdi      # 0x6d72
leaq 0x1667(%rip), %rsi      # 0x693f
leaq 0x1a9d(%rip), %rcx      # 0x6d7c
movl $0x31f, %edx            # imm = 0x31F
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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 0x57af
movq %r14, %rdi
xorl %esi, %esi
callq 0x525c
leaq 0x1576(%rip), %rsi      # 0x6ceb
leaq 0x1572(%rip), %rdx      # 0x6cee
movl %eax, %edi
callq 0x46eb
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 0x57ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
movq %rbx, %rdi
callq 0x3e0c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: Titrer
void Titrer(char *sTitre){
	//affiche sTitre centré sur une ligne de kuTitreLargeur caractères de type kcMotif
	const int kuTitreLargeur=60;//où ce que vous voulez
	const char kcMotif='*';//où ce que vous voulez
	assert(sTitre!=0);
	int nTitreLg=nCaractere(sTitre);
	assert(nTitreLg<kuTitreLargeur);
	int nEspace=(kuTitreLargeur-nTitreLg)/2;//quitte à perdre un caractère
	int bUnMotifEnSus=bImpair(nTitreLg);//ie un kcMotif sera ajouté pr récupérer le caractère perdu li-1
	assert(nEspace+nTitreLg+nEspace+bUnMotifEnSus==kuTitreLargeur);
	printf("%s%s%s\n",sFois(nEspace,kcMotif),sTitre,sFois(nEspace+bUnMotifEnSus,kcMotif));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5841
movq %rdi, %rbx
callq 0x44e5
cmpl $0x3c, %eax
jae 0x5860
movl $0x3c, %ebp
subl %eax, %ebp
movl %eax, %r15d
andl $0x1, %r15d
movl %ebp, %ecx
andl $-0x2, %ecx
addl %r15d, %eax
addl %ecx, %eax
cmpl $0x3c, %eax
jne 0x587f
shrl %ebp
movl %ebp, %edi
movl $0x2a, %esi
callq 0x4a5f
movq %rax, %r14
addl %r15d, %ebp
movl %ebp, %edi
movl $0x2a, %esi
callq 0x4a5f
leaq 0x18ba(%rip), %rdi      # 0x70e1
movq %r14, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
leaq 0x182c(%rip), %rdi      # 0x7074
leaq 0x10f0(%rip), %rsi      # 0x693f
leaq 0x1828(%rip), %rcx      # 0x707e
movl $0x395, %edx            # imm = 0x395
callq 0x10b0
leaq 0x182b(%rip), %rdi      # 0x7092
leaq 0x10d1(%rip), %rsi      # 0x693f
leaq 0x1809(%rip), %rcx      # 0x707e
movl $0x397, %edx            # imm = 0x397
callq 0x10b0
leaq 0x1824(%rip), %rdi      # 0x70aa
leaq 0x10b2(%rip), %rsi      # 0x693f
leaq 0x17ea(%rip), %rcx      # 0x707e
movl $0x39a, %edx            # imm = 0x39A
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/j4r0g[P]Projet_Labyrinthe/Boite_outils/Outil.c
// Function: sPluriel
char *sPluriel(int nEffectif,char *sSingulier){
	//si sSingulier est "pomme",rend "3 pommes","1 pomme" ou "0 pomme",selon nEffectif;sSingulier est supposé prendre un "s" au pluriel
	char *sPluriel;
	Vrai2(nEffectif>=0,sSingulier!=0);
	sPluriel=sC2b(sEntier(nEffectif),sSingulier);
	if (nEffectif>1)
		sPluriel=sC2(sPluriel,"s");
	return(sPluriel);//rend "3 s" si (nCardinal=3 et sSingulier est la chaîne vide)
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
testq %rdi, %rdi
setne %sil
xorl %edx, %edx
testq %r14, %r14
setne %dl
movl $0x1, (%rsp)
leaq 0x91c(%rip), %rdi       # 0x62a8
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x3550
xorl %edi, %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x48b8
movq %r15, %rdi
callq 0x37f3
cmpl %ebx, %ebp
jg 0x59e4
movslq %ebp, %rax
leaq (%r14,%rax,4), %r15
subl %ebp, %ebx
incl %ebx
leaq 0x171e(%rip), %r14      # 0x70e9
xorl %r12d, %r12d
movl (%r15,%r12,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10a0
incq %r12
cmpl %r12d, %ebx
jne 0x59ce
movl $0xa, %edi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/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 0x5a58
movslq 0xae49(%rip), %rax      # 0x10884
leal 0x1(%rax), %ecx
movl %ecx, 0xae40(%rip)      # 0x10884
cmpq $0x5, %rax
jge 0x5a77
leaq 0xbf6f(%rip), %rcx      # 0x119c0
movq %rdi, 0x8(%rcx,%rax,8)
popq %rax
retq
leaq 0x16ba(%rip), %rdi      # 0x7119
leaq 0xed9(%rip), %rsi       # 0x693f
leaq 0x16bd(%rip), %rcx      # 0x712a
movl $0x3fc, %edx            # imm = 0x3FC
callq 0x10b0
leaq 0x16bd(%rip), %rdi      # 0x713b
leaq 0xeba(%rip), %rsi       # 0x693f
leaq 0x169e(%rip), %rcx      # 0x712a
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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 0xade5(%rip), %esi      # 0x10884
xorl %edi, %edi
movl $0x5, %edx
callq 0x48b8
movslq 0xadd2(%rip), %rax      # 0x10884
leaq 0xbf07(%rip), %rcx      # 0x119c0
movq (%rcx,%rax,8), %rdx
leaq -0x1(%rdx), %rsi
movq %rsi, (%rcx,%rax,8)
testq %rdx, %rdx
jle 0x5ae7
testl %ebx, %ebx
jne 0x5ae3
movq $0x0, (%rcx,%rax,8)
leal -0x1(%rax), %ecx
movl %ecx, 0xada5(%rip)      # 0x10884
testl %eax, %eax
jle 0x5b06
movl %ebx, %eax
popq %rbx
retq
leaq 0x1661(%rip), %rdi      # 0x714f
leaq 0xe4a(%rip), %rsi       # 0x693f
leaq 0x1666(%rip), %rcx      # 0x7162
movl $0x407, %edx            # imm = 0x407
callq 0x10b0
leaq 0xf70(%rip), %rdi       # 0x6a7d
leaq 0xe2b(%rip), %rsi       # 0x693f
leaq 0x1647(%rip), %rcx      # 0x7162
movl $0x40b, %edx            # imm = 0x40B
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/crcx[P]retroforth/vm/nga-c/retro.c
// Function: verbose_details
V verbose_details(NgaState *vm, CELL opcode) {
  fprintf(stderr, "ip: %lld ", (long long)ACTIVE.ip);
  fprintf(stderr, "sp: %lld ", (long long)ACTIVE.sp);
  fprintf(stderr, "rp: %lld ", (long long)ACTIVE.rp);
  fprintf(stderr, "core: %lld ", (long long)vm->active);
  fprintf(stderr, "opcode: %lld\n", (long long)opcode);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0xab57(%rip), %r15      # 0xdff8
movq (%r15), %rdi
movslq 0x2043a4(%r14), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
movslq 0x20000c(%r14,%rax), %rdx
leaq 0x6de0(%rip), %rsi      # 0xa2a1
xorl %eax, %eax
callq 0x3270
movq (%r15), %rdi
movslq 0x2043a4(%r14), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
movslq 0x200004(%r14,%rax), %rdx
leaq 0x6dc3(%rip), %rsi      # 0xa2ab
xorl %eax, %eax
callq 0x3270
movq (%r15), %rdi
movslq 0x2043a4(%r14), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
movslq 0x200008(%r14,%rax), %rdx
leaq 0x6da6(%rip), %rsi      # 0xa2b5
xorl %eax, %eax
callq 0x3270
movq (%r15), %rdi
movslq 0x2043a4(%r14), %rdx
leaq 0x6d98(%rip), %rsi      # 0xa2bf
xorl %eax, %eax
callq 0x3270
movq (%r15), %rdi
movslq %ebx, %rdx
leaq 0x6d90(%rip), %rsi      # 0xa2cb
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x3270
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
movl (%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x3682
addq $0x4, %rdi
cmpl (%rsi), %ecx
jne 0x3680
addq $0x4, %rsi
movl (%rdi), %ecx
addq $0x4, %rdi
testl %ecx, %ecx
jne 0x366c
jmp 0x3682
movl %ecx, %eax
subl (%rsi), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movb (%rdi), %al
testb %al, %al
sete %cl
cmpl $0x2, %edx
setl %r8b
orb %cl, %r8b
jne 0x36b4
decl %edx
xorl %ecx, %ecx
movsbl %al, %eax
movl %eax, (%rsi,%rcx,4)
movb 0x1(%rdi,%rcx), %al
incq %rcx
testb %al, %al
je 0x36b6
cmpq %rdx, %rcx
jb 0x369c
jmp 0x36b6
xorl %ecx, %ecx
movl $0x0, (%rsi,%rcx,4)
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl (%rdi), %eax
testl %eax, %eax
sete %cl
cmpl $0x2, %edx
setl %r8b
orb %cl, %r8b
jne 0x36f9
decl %edx
xorl %ecx, %ecx
movl $0x3f, %r8d
cmpl $0x80, %eax
cmovgel %r8d, %eax
movb %al, (%rsi,%rcx)
movl 0x4(%rdi,%rcx,4), %eax
incq %rcx
testl %eax, %eax
je 0x36fb
cmpq %rdx, %rcx
jb 0x36db
jmp 0x36fb
xorl %ecx, %ecx
movb $0x0, (%rsi,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3850
movq %rdi, %rbx
leaq 0x6851(%rip), %rdi      # 0xa080
movq %r14, %rsi
xorl %eax, %eax
callq 0x3150
movl 0x2079c4(%rbx,%r14,4), %esi
movq %rbx, %rdi
callq 0x3a33
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_O3/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, %rdx
movl (%rdi,%rdx,4), %ecx
testl %ecx, %ecx
je 0x3ef4
leaq (%rax,%rdx,4), %rdx
addq $0x4, %rdx
xorl %edi, %edi
leaq 0x1(%rdi), %rsi
movb %cl, 0x2045b8(%rax,%rdi)
movl (%rdx,%rdi,4), %ecx
testl %ecx, %ecx
je 0x3ef6
cmpq $0x1fff, %rdi           # imm = 0x1FFF
movq %rsi, %rdi
jb 0x3ed4
jmp 0x3ef6
xorl %esi, %esi
movb $0x0, 0x2045b8(%rax,%rsi)
addq $0x2045b8, %rax         # imm = 0x2045B8
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x0, 0x288ef8(%rbx,%r14,8)
je 0x3fdb
incq %r14
cmpq $0x1f, %r14
jne 0x3fc2
xorl %r14d, %r14d
jmp 0x3fde
incl %r14d
movslq 0x2043a4(%rbx), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
leaq (%rbx,%rax), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movslq (%rcx), %rdx
leaq -0x1(%rdx), %rax
movl %eax, (%rcx)
movslq 0x14(%rcx,%rdx,4), %rax
leal -0x2(%rdx), %esi
movl %esi, (%rcx)
movslq 0x10(%rcx,%rdx,4), %rcx
movl (%rbx,%rcx,4), %edx
testl %edx, %edx
je 0x4040
leaq (%rbx,%rcx,4), %rcx
addq $0x4, %rcx
xorl %edi, %edi
leaq 0x1(%rdi), %rsi
movb %dl, 0x2045b8(%rbx,%rdi)
cmpq $0x1ffe, %rdi           # imm = 0x1FFE
ja 0x4042
movl (%rcx,%rdi,4), %edx
movq %rsi, %rdi
testl %edx, %edx
jne 0x4020
jmp 0x4042
xorl %esi, %esi
movb $0x0, 0x2045b8(%rbx,%rsi)
testl %r14d, %r14d
jle 0x4076
leaq 0x2045b8(%rbx), %rdi
leaq 0x5fd7(%rip), %rcx      # 0xa034
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
callq 0x3360
movl %r14d, %ecx
movq %rax, 0x288ef0(%rbx,%rcx,8)
jmp 0x4081
movslq %r14d, %rcx
movq 0x288ef0(%rbx,%rcx,8), %rax
leaq 0x200004(%rbx), %rdx
testq %rax, %rax
jne 0x409c
movq $0x0, 0x288ef0(%rbx,%rcx,8)
xorl %r14d, %r14d
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 %r14d, 0x18(%rcx,%rsi,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x414e
movq %rdi, %rbx
movq 0x288ef0(%rdi,%rax,8), %r14
testq %r14, %r14
je 0x414e
leaq 0x200004(%rbx), %r15
movq %r14, %rdi
callq 0x3290
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x4126
movq %r14, %rdi
callq 0x31c0
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 0x62b0(%rip), %rdi      # 0xa405
callq 0x30a0
movl $0x1, %edi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/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 0x4236
movq %rdi, %rbx
movq 0x288ef0(%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x4236
callq 0x3110
movq $0x0, 0x288ef0(%rbx,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x60a9(%rip), %rdi      # 0xa2e6
callq 0x30a0
movl $0x1, %edi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/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 0x42c1
movq %rdi, %rbx
movq 0x288ef0(%rdi,%rax,8), %rdi
testq %rdi, %rdi
je 0x42c1
leaq 0x200004(%rbx), %r14
callq 0x3280
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 0x604b(%rip), %rdi      # 0xa313
callq 0x30a0
movl $0x1, %edi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/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), %r14
leal -0x3(%rcx), %esi
movl %esi, (%rax)
movslq 0xc(%rax,%rcx,4), %r13
movq 0x288ef0(%rdi,%rdx,8), %rcx
leaq 0x50cfa(%rip), %r15     # 0x55290
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0x30b0
testq %r14, %r14
jle 0x45c1
leaq (%rbx,%r13,4), %rcx
xorl %edx, %edx
movsbl (%rdx,%r15), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r14
jne 0x45b1
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_O3/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
leal -0x2(%rsi), %edx
movl %edx, (%rcx)
movslq 0x10(%rcx,%rsi,4), %rdx
leal -0x3(%rsi), %edi
movl %edi, (%rcx)
testq %rdx, %rdx
jle 0x4658
movslq 0xc(%rcx,%rsi,4), %rcx
leaq (%rbx,%rcx,4), %rcx
xorl %esi, %esi
leaq 0x50c48(%rip), %rdi     # 0x55290
movb (%rcx,%rsi,4), %r8b
movb %r8b, (%rsi,%rdi)
incq %rsi
cmpq %rsi, %rdx
jne 0x4648
movq 0x288ef0(%rbx,%rax,8), %rcx
leaq 0x50c29(%rip), %rdi     # 0x55290
movl $0x1, %esi
callq 0x33e0
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_O3/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 0x472e
movq %rdi, %rbx
movq 0x288ef0(%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x472e
leaq 0x200004(%rbx), %r15
callq 0x4744
movl %eax, %ebp
movq 0x288ef0(%rbx,%r14,8), %rdi
callq 0x3290
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 0x5cd0(%rip), %rdi      # 0xa405
callq 0x30a0
movl $0x1, %edi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/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 0x4922
leal -0x2(%r12), %eax
movl %eax, 0x200004(%rbx,%r14)
movl 0x200014(%r15,%r12,4), %eax
leal -0x21(%rax), %ecx
cmpl $-0x20, %ecx
jb 0x490c
movq 0x288ef0(%rbx,%rax,8), %rcx
testq %rcx, %rcx
je 0x490c
movslq (%rsp), %rsi
leaq 0x4(%rsp), %rdi
movl $0x1, %edx
callq 0x33e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5ac5(%rip), %rdi      # 0xa3d8
callq 0x30a0
movl $0x1, %edi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/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 0x4a85
movq %rdi, %rbx
movq 0x288ef0(%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x4a85
movslq 0x200014(%rax,%rcx,4), %r15
callq 0x4744
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 0x4a54
btl %eax, %ebp
jb 0x4a6a
movq 0x288ef0(%rbx,%r14,8), %rdi
callq 0x4744
addq %r13, %r15
addq $0x4, %r12
jmp 0x4a46
sarq $0x1e, %r15
movl $0x0, (%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5979(%rip), %rdi      # 0xa405
callq 0x30a0
movl $0x1, %edi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/crcx[P]retroforth/vm/nga-c/./dev-float.c
// Function: float_guard
void float_guard(NgaState *vm) {
  if (vm->fsp < 0 || vm->fsp > 255) {
    printf("\nERROR (nga/float_guard): Float Stack Limits Exceeded!\n");
    printf("At %lld, fsp = %lld\n", (long long)vm->cpu[vm->active].ip, (long long)vm->fsp);
    exit(1);
  }
  if (vm->afsp < 0 || vm->afsp > 255) {
    printf("\nERROR (nga/float_guard): Alternate Float Stack Limits Exceeded!\n");
    printf("At %lld, afsp = %lld\n", (long long)vm->cpu[vm->active].ip, (long long)vm->afsp);
    exit(1);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x100, 0x2075b8(%rdi)  # imm = 0x100
jae 0x4d58
cmpl $0x100, 0x2075bc(%rbx)  # imm = 0x100
jae 0x4d8a
popq %rbx
retq
leaq 0x5713(%rip), %rdi      # 0xa472
callq 0x30a0
movslq 0x2043a4(%rbx), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
movslq 0x20000c(%rbx,%rax), %rsi
movslq 0x2075b8(%rbx), %rdx
leaq 0x532a(%rip), %rdi      # 0xa0b2
jmp 0x4dba
leaq 0x56a0(%rip), %rdi      # 0xa431
callq 0x30a0
movslq 0x2043a4(%rbx), %rax
imulq $0x874, %rax, %rax      # imm = 0x874
movslq 0x20000c(%rbx,%rax), %rsi
movslq 0x2075bc(%rbx), %rdx
leaq 0x530d(%rip), %rdi      # 0xa0c7
xorl %eax, %eax
callq 0x3150
movl $0x1, %edi
callq 0x33d0