LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: InitCriteria(CRITERIA*, int)
void InitCriteria(struct CRITERIA * oldCrit, int size){

	int i;

	oldCrit->PLACE=(int *) malloc((2*size-3+1)*sizeof(int));
	oldCrit->PLACEI=(int *) malloc((2*size-3+1)*sizeof(int));
	oldCrit->B=(int **) malloc((2*size-3+1)*sizeof(int*));
	oldCrit->BI=(int **) malloc((2*size-3+1)*sizeof(int*));

	for (i=0;i<=2*size-3;i++)
	{
		oldCrit->B[i]=(int *) malloc((size+1)*sizeof(int));
		oldCrit->BI[i]=(int *) malloc((size+1)*sizeof(int));
	}

	oldCrit->BD=0;
	oldCrit->LS=0.0;
	oldCrit->RF=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
subl $0x3, %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0xc(%rbp), %eax
shll %eax
subl $0x3, %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movl -0xc(%rbp), %eax
shll %eax
subl $0x3, %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0xc(%rbp), %eax
shll %eax
subl $0x3, %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jg 0x14622
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1110
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1110
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x145be
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: FreeCriteria(CRITERIA*, int)
void FreeCriteria(struct CRITERIA * Crit,int size){

	int i;

	free(Crit->PLACE);
	free(Crit->PLACEI);
	
	for(i=0;i<=2*size-3;i++){
		free(Crit->B[i]);
		free(Crit->BI[i]);
	}
	free(Crit->B);
	free(Crit->BI);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x10e0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jg 0x146c4
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14680
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x10e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: isInside(DescTree, DescTree)
int isInside(struct DescTree DT1,struct DescTree DT2){

	int i;

	for(i=1;i<=DT1.nbSommet;i++){
		if(DT2.Tableau[1] == DT1.Tableau[i]) return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl (%rcx), %eax
jg 0x17fe8
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movq 0x10(%rcx), %rcx
movslq -0x8(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x17fdb
movl $0x1, -0x4(%rbp)
jmp 0x17fef
jmp 0x17fdd
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x17fab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printTransfer(_IO_FILE*, int, char**, int, int, int, int, int)
void printTransfer(FILE *out,int sortie,char ** noms,int n,int source_A,int source_B,int dest_A,int dest_B){

	if(sortie == 0)
		fprintf(out,"\nFrom branch %d--%d to branch %d--%d",source_A,source_B,dest_A,dest_B);
	else{
		if(source_A	<= n)
			fprintf(out,"\nFrom branch %s--%d",noms[source_A],source_B);
		else if(source_B <= n)
			fprintf(out,"\nFrom branch %d--%s",source_A,noms[source_B]);
		else
			fprintf(out,"\nFrom branch %d--%d",source_A,source_B);

		if(dest_A <= n)
			fprintf(out," to branch %s--%d",noms[dest_A],dest_B);
		else if(dest_B <= n)
			fprintf(out," to branch %d--%s",dest_A,noms[dest_B]);
		else
			fprintf(out," to branch %d--%d",dest_A,dest_B);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x192df
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
movl 0x10(%rbp), %r8d
movl 0x18(%rbp), %r9d
leaq 0xcf26(%rip), %rsi      # 0x261f9
movb $0x0, %al
callq 0x1140
jmp 0x193c1
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x1930a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl -0x24(%rbp), %ecx
leaq 0xcf1d(%rip), %rsi      # 0x2621e
movb $0x0, %al
callq 0x1140
jmp 0x1934f
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x19335
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xcf06(%rip), %rsi      # 0x26232
movb $0x0, %al
callq 0x1140
jmp 0x1934d
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
leaq 0xcf00(%rip), %rsi      # 0x26246
movb $0x0, %al
callq 0x1140
jmp 0x1934f
movl 0x10(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x1937a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl 0x18(%rbp), %ecx
leaq 0xcee9(%rip), %rsi      # 0x2625a
movb $0x0, %al
callq 0x1140
jmp 0x193bf
movl 0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x193a5
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %edx
movq -0x18(%rbp), %rax
movslq 0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xced0(%rip), %rsi      # 0x2626c
movb $0x0, %al
callq 0x1140
jmp 0x193bd
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %edx
movl 0x18(%rbp), %ecx
leaq 0xce56(%rip), %rsi      # 0x2620c
movb $0x0, %al
callq 0x1140
jmp 0x193bf
jmp 0x193c1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printBestHGT_F(_IO_FILE*, int, InputTree, HGT, int*, int, int)
void printBestHGT_F(FILE *out,int noHGT,struct InputTree SpeciesTree,struct HGT bestHGT,int *tmp,int nbTree, int boot){
	
	if((bestHGT.valide == 1) || (bestHGT.valide == 6))
	{

		/*printf("\n\n======== Transfer %d ==========",noHGT-(*tmp));
		printf("\n%d--%d -> %d--%d",bestHGT.source_A,bestHGT.source_B,bestHGT.dest_A,bestHGT.dest_B);
		printf("\nRF = %d \nLS = %lf \nBD = %lf",bestHGT.crit.RF,bestHGT.crit.LS,bestHGT.crit.BD);*/

		fprintf(out,"\n\n================ \n= HGT #%d \n==============",noHGT-(*tmp));
		if(boot != -1)
			fprintf(out,"\n Boottrap value : %lf%%",(double)boot/nbTree*100.0);
		printTransfer(out,1,SpeciesTree.SpeciesName, SpeciesTree.size,bestHGT.source_A,bestHGT.source_B,bestHGT.dest_A,bestHGT.dest_B);
		//printf("\n%d--%d -> %d--%d",SpeciesTree.ARETE[2*(bestHGT.source)-1],SpeciesTree.ARETE[2*(bestHGT.source)-2],SpeciesTree.ARETE[2*(bestHGT.destination)-1],SpeciesTree.ARETE[2*(bestHGT.destination)-2]);
		fprintf(out,"\nRF = %d \nLS = %lf \nBD = %lf",bestHGT.crit.RF,bestHGT.crit.LS,bestHGT.crit.BD);
/*
		fprintf(out,"\n%d",bestHGT.listSource[0]);
		for(j=1;j<=bestHGT.listSource[0];j++)
			fprintf(out," %d",bestHGT.listSource[j]);
		fprintf(out,"\n%d",bestHGT.listDestination[0]);
		for(j=1;j<=bestHGT.listDestination[0];j++)
			fprintf(out," %d",bestHGT.listDestination[j]);
*/	}
	else
		(*tmp) += 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %r9
movq %r9, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpl $0x1, (%rax)
je 0x1a26c
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x1a31d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
subl (%rax), %edx
leaq 0xc126(%rip), %rsi      # 0x263a6
movb $0x0, %al
callq 0x1140
cmpl $-0x1, -0x20(%rbp)
je 0x1a2b9
movq -0x8(%rbp), %rdi
cvtsi2sdl -0x20(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0xada9(%rip), %xmm1     # 0x25050
mulsd %xmm1, %xmm0
leaq 0xc122(%rip), %rsi      # 0x263d4
movb $0x1, %al
callq 0x1140
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq 0x18(%rcx), %rdx
movl (%rcx), %ecx
movl 0x80(%rax), %r8d
movl 0x84(%rax), %r9d
movl 0x88(%rax), %r10d
movl 0x8c(%rax), %eax
movl $0x1, %esi
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x19290
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movl 0x50(%rax), %edx
movsd 0x20(%rax), %xmm0
movsd 0x30(%rax), %xmm1
leaq 0xc0d9(%rip), %rsi      # 0x263ed
movb $0x2, %al
callq 0x1140
jmp 0x1a328
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: compareLeaves(int*, int*, int)
int compareLeaves(int *listLeaves,int *tab,int n){
	int i,/*val,*/cpt1=0,cpt2=0;
	
	for(i=1;i<=n;i++){
		if(listLeaves[i] != tab[i]) cpt1++;
		tab[i] = (tab[i]+1) % 2;
	}
	for(i=1;i<=n;i++){
		if(listLeaves[i] != tab[i]) cpt2++;
	}

	if (cpt1 < cpt2) return cpt1;
	else return cpt2;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x1a3a9
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x1a37d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1a354
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x1a3e6
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x1a3d9
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1a3db
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1a3b0
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1a3f6
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a3fc
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: findApproxRootBranch(int*, InputTree*, int)
int findApproxRootBranch(int * listLeaves,struct InputTree *aTree, int maxDiff){
	
	int choix =-1,i,j,/*k,*/val,valmax = maxDiff;

	int * tab = (int *) malloc((aTree->size+1)*sizeof(int));

	//= recherche de la branche equivalente a listLeaves

	for(i=1;i<=2*aTree->size-3-aTree->kt;i++){
		for(j=1;j<=aTree->size;j++)
			if(aTree->ADD[j][aTree->ARETE[2*i-1]] < aTree->ADD[j][aTree->ARETE[2*i-2]])
				tab[j] = 0;
			else
				tab[j] = 1;
		/*printf("\n (%d)\t: ",i);
		for(int k=1;k<=aTree->size;k++){
				printf("%d ",tab[k]);
		}*/
		val = compareLeaves(listLeaves,tab,aTree->size);
		if(val <= valmax){
			valmax = val;
			choix = i;
		}
		for(int k=1;k<=aTree->size;k++){
				tab[k] = -1;
		}
	}
	//printf("\nHGT-DETECTION : no branch selectionne = %d , similarite = %d",choix,valmax);
	free(tab);

	return choix;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1110
movq %rax, -0x30(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
shll %ecx
subl $0x3, %ecx
movq -0x10(%rbp), %rdx
subl 0x48(%rdx), %ecx
cmpl %ecx, %eax
jg 0x1a577
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x1a511
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl -0x1c(%rbp), %edx
shll %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl -0x1c(%rbp), %edx
shll %edx
subl $0x2, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1a4f2
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x1a501
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0x1a503
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1a474
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x1a330
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0x1a53b
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x1a567
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1a542
jmp 0x1a569
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a450
movq -0x30(%rbp), %rdi
callq 0x10e0
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: compareBranches(int*, int*, int)
int compareBranches(int * tab1,int * tab2,int size){
	int score1=0,score2=0,i;
	
	for(int i=1;i<=size;i++){
		score1 = (tab1[i] != tab2[i])?1:0;
		score2 = (tab1[i] == tab2[i])?1:0;
	}
	
	return (score1<score2)?score1:score2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x1af41
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovnel %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1aee4
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1af51
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1af57
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: bestRFBranch(InputTree*, InputTree*)
int bestRFBranch(struct InputTree *geneTree, struct InputTree *speciesTree){

	int indiceBranche;
	struct InputTree tmpTree;	//= arbre temporaire qui va etre modifier pour calculer RF
	struct CRITERIA aCrit;		//== struture of all the criteria
	int choix=-1;
	int min= (int) INFINI;

	initInputTree(&tmpTree);	

	printf("\nTaille = %d",geneTree->size);
	for(indiceBranche=1;indiceBranche<=2*geneTree->size-3-geneTree->kt;indiceBranche++){
		
		copyInputTree(&tmpTree,(*geneTree),1,1);
		printf("%d",indiceBranche);
		addLeafAndUpdate(&tmpTree,indiceBranche);
		exit(0);
		tmpTree.Root = tmpTree.size;
		
		InitCriteria(&aCrit,tmpTree.size);
		computeCriteria(speciesTree->ADD,tmpTree.ADD,tmpTree.size,&aCrit,speciesTree->LONGUEUR,speciesTree->ARETE,tmpTree.LONGUEUR,tmpTree.ARETE);

		printf("\n(%d), %ld--%ld = %d",indiceBranche,geneTree->ARETE[2*indiceBranche-1],geneTree->ARETE[2*indiceBranche-2],aCrit.RF);
		if(aCrit.RF < min){
			min=aCrit.RF;
			choix = indiceBranche;
		}
		FreeCriteria(&aCrit,tmpTree.size);
	}

	return choix;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0xd4(%rbp) # imm = 0xFFFFFFFF
movl $0xf423f, -0xd8(%rbp)   # imm = 0xF423F
leaq -0x70(%rbp), %rdi
callq 0xd040
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0xb46d(%rip), %rdi      # 0x2640a
movb $0x0, %al
callq 0x1030
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shll %ecx
subl $0x3, %ecx
movq -0x8(%rbp), %rdx
subl 0x48(%rdx), %ecx
cmpl %ecx, %eax
jg 0x1b055
movq -0x8(%rbp), %rsi
leaq -0x130(%rbp), %rdi
movl $0x58, %edx
callq 0x1070
movq -0xe0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x50(%rax)
movups -0xf0(%rbp), %xmm0
movups %xmm0, 0x40(%rax)
movups -0x130(%rbp), %xmm0
movups -0x120(%rbp), %xmm1
movups -0x110(%rbp), %xmm2
movups -0x100(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x70(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x12530
movl -0x14(%rbp), %esi
leaq 0xb244(%rip), %rdi      # 0x2627f
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0xbc50
xorl %edi, %edi
callq 0x10f0
movl -0xd4(%rbp), %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: file_exists(char const*)
bool file_exists(const char * filename)
{
	FILE *file;

    if ((file=fopen(filename, "r"))==NULL)
    {
		return false;
    }
	else{
        fclose(file);
        return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb390(%rip), %rsi      # 0x26417
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1b09c
movb $0x0, -0x1(%rbp)
jmp 0x1b0a9
movq -0x18(%rbp), %rdi
callq 0x1090
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printMatrix(char**, double**, int)
void printMatrix(char** Name, double **Matrix,int size){

	int i,j;
	
	for(i=1;i<=size;i++){
//		printf("\n%s",Name[i]);
		printf("\n%d",i);
		for(j=1;j<=size;j++){
			if(Matrix[i][j] >= INFINI)
				printf("  INFINI ");
			else
				printf(" %3.5lf",Matrix[i][j]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x1bdd9
movl -0x18(%rbp), %esi
leaq 0xa52e(%rip), %rdi      # 0x2627e
movb $0x0, %al
callq 0x1030
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x1bdc9
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x92a5(%rip), %xmm1     # 0x25028
ucomisd %xmm1, %xmm0
jb 0x1bd99
leaq 0xa71d(%rip), %rdi      # 0x264ad
movb $0x0, %al
callq 0x1030
jmp 0x1bdbc
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xa702(%rip), %rdi      # 0x264b7
movb $0x1, %al
callq 0x1030
jmp 0x1bdbe
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bd5e
jmp 0x1bdcb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1bd3a
addq $0x20, %rsp
popq %rbp
retq
nop
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printMatrix2(char**, double**, int)
void printMatrix2(char** Name, double **Matrix,int size){

	int i,j;
	
	for(i=1;i<=size;i++){
		//printf("\n%s",Name[i]);
		printf("\n%d",i);
		for(j=1;j<=size;j++){
			if(Matrix[i][j] < epsilon )
				printf("  NULL ");
			else
				printf(" %3.5lf",Matrix[i][j]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x1be95
movl -0x18(%rbp), %esi
leaq 0xa46e(%rip), %rdi      # 0x2627e
movb $0x0, %al
callq 0x1030
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x1be85
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x91f2(%rip), %xmm0     # 0x25030
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x1be55
leaq 0xa673(%rip), %rdi      # 0x264bf
movb $0x0, %al
callq 0x1030
jmp 0x1be78
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0xa646(%rip), %rdi      # 0x264b7
movb $0x1, %al
callq 0x1030
jmp 0x1be7a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1be1e
jmp 0x1be87
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1bdfa
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printBranches(_IO_FILE*, InputTree, char const*, int*, int)
void printBranches(FILE *out,struct InputTree aTree,const char * Message,int * BSARETE,int nbTree){

	if(out==NULL)
		printf("%s",Message);
	else
		fprintf(out,"\n\n%s",Message);
	printEdges(out,1,aTree.ARETE,aTree.LONGUEUR,aTree.SpeciesName,aTree.size,BSARETE,nbTree,aTree.kt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1beda
movq -0x10(%rbp), %rsi
leaq 0xa5f8(%rip), %rdi      # 0x264c9
movb $0x0, %al
callq 0x1030
jmp 0x1bef0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa5de(%rip), %rsi      # 0x264c7
movb $0x0, %al
callq 0x1140
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rcx
movq 0x18(%rax), %r8
movl (%rax), %r9d
movq -0x18(%rbp), %r11
movl -0x1c(%rbp), %r10d
movl 0x48(%rax), %eax
movl $0x1, %esi
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x2c20
addq $0x40, %rsp
popq %rbp
retq
nop
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: ExtraireDonnees(char const*, char*, char*)
int ExtraireDonnees(const char * chaine, char *champs, char * contenu){

	int cpt=0,i;
	int egale=false;
	int tailleChaine;

	if(chaine[0] != '-')
		return false;
	tailleChaine = (int)strlen(chaine);

	for(i=1;i<tailleChaine;i++){

		if (chaine[i] == '='){
			egale = true;
			champs[cpt] = '\0';
			cpt=0;
			continue;
		}
		if(egale)
			contenu[cpt++] = chaine[i];
		else
			champs[cpt++] = chaine[i];
	}
	contenu[cpt] = '\0';

	if (!egale)
		return false;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x1bf6a
movl $0x0, -0x4(%rbp)
jmp 0x1c030
movq -0x10(%rbp), %rdi
callq 0x1050
movl %eax, -0x30(%rbp)
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x1c00e
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x1bfb6
movl $0x1, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x24(%rbp)
jmp 0x1c000
cmpl $0x0, -0x2c(%rbp)
je 0x1bfde
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1bffe
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1c000
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1bf7d
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x2c(%rbp)
jne 0x1c029
movl $0x0, -0x4(%rbp)
jmp 0x1c030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: supprimerSousEnsemble(DescTree*, int)
void supprimerSousEnsemble(struct DescTree *tabDetect,int nbTableau){
	
	int i,j/*,k*/;
	
	for(i=1;i<=nbTableau;i=i+2){
		for(j=i+1;j<=nbTableau;j++){
			deleteSommet(tabDetect,i,j);
		}	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x1d6e6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x1d6d9
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1d3d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d6b7
jmp 0x1d6db
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x1d6a6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: dcarrey[P]hgt-detection/hgt3.4.cpp
// Function: traiterSignal(int)
void traiterSignal(int sig){
	printf("\nMESSAGE : SEGMENTATION FAULT #%d DETECTED",sig);
	printf("\nUse valgrind or gdb to fix the problem");
	printf("\n");
	exit(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x8872(%rip), %rdi      # 0x26ab7
movb $0x0, %al
callq 0x1030
leaq 0x888f(%rip), %rdi      # 0x26ae2
movb $0x0, %al
callq 0x1030
leaq 0x7f96(%rip), %rdi      # 0x261f7
movb $0x0, %al
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10f0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_06.cc
// Function: populate(std::vector<int, std::allocator<int>>*)
vector<int>* populate(vector<int>* vec)
{
	int item;

	while (cin >> item) {
		vec->push_back(item);
	}

	return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2d1d(%rip), %rdi      # 0x3fe0
leaq -0xc(%rbp), %rsi
callq 0x1080
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x10f0
testb $0x1, %al
jne 0x12e1
jmp 0x12f0
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x1420
jmp 0x12bc
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_06.cc
// Function: main
int main(int argc, char const *argv[])
{
	auto pvec = alloc();

	populate(pvec);

	print(pvec) << endl;

	delete pvec;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1270
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12b0
movq -0x18(%rbp), %rdi
callq 0x1300
movq %rax, %rdi
movq 0x2bf5(%rip), %rsi      # 0x3fc0
callq 0x10e0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x13f5
movq -0x20(%rbp), %rdi
callq 0x1570
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x10d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_simple_sst.cpp
// Function: test_get_update_2(bool)
void test_get_update_2(bool recursive) {
    // Test edge case with a tree of size 1.
    simple_static_search_tree tree(1, recursive);
    tree.update(0, 2);
    if (tree.get(2) != 0) {
        cout << "test_get_update_2 failed: expected 2 at index 0." << endl;
        return;
    }
    tree.update(0, 5);
    if (tree.get(5) != 0) {
        cout << "test_get_update_2 failed: expected 5 at index 0." << endl;
        return;
    }
    tree.update(0, 501);
    if (tree.get(501) != 0) {
        cout << "test_get_update_2 failed: expected 501 at index 0." << endl;
        return;
    }
    cout << "test_get_update_2: OK" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %edx
andl $0x1, %edx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x1, %esi
callq 0x2bb0
movq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2fc0
jmp 0x575e
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x3030
movl %eax, -0x44(%rbp)
jmp 0x5771
movl -0x44(%rbp), %eax
cmpl $0x0, %eax
je 0x57ca
movq 0x4858(%rip), %rdi      # 0x9fd8
leaq 0x1a6f(%rip), %rsi      # 0x71f6
callq 0x10d0
movq %rax, -0x50(%rbp)
jmp 0x5792
movq -0x50(%rbp), %rdi
movq 0x482b(%rip), %rsi      # 0x9fc8
callq 0x1110
jmp 0x57a4
movl $0x1, -0x38(%rbp)
jmp 0x58c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2c40
jmp 0x58d3
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x2fc0
jmp 0x57dc
leaq -0x28(%rbp), %rdi
movl $0x5, %esi
callq 0x3030
movl %eax, -0x54(%rbp)
jmp 0x57ef
movl -0x54(%rbp), %eax
cmpl $0x0, %eax
je 0x582e
movq 0x47da(%rip), %rdi      # 0x9fd8
leaq 0x1a22(%rip), %rsi      # 0x7227
callq 0x10d0
movq %rax, -0x60(%rbp)
jmp 0x5810
movq -0x60(%rbp), %rdi
movq 0x47ad(%rip), %rsi      # 0x9fc8
callq 0x1110
jmp 0x5822
movl $0x1, -0x38(%rbp)
jmp 0x58c1
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x2fc0
jmp 0x5840
leaq -0x28(%rbp), %rdi
movl $0x1f5, %esi            # imm = 0x1F5
callq 0x3030
movl %eax, -0x64(%rbp)
jmp 0x5853
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0x588f
movq 0x4776(%rip), %rdi      # 0x9fd8
leaq 0x19ef(%rip), %rsi      # 0x7258
callq 0x10d0
movq %rax, -0x70(%rbp)
jmp 0x5874
movq -0x70(%rbp), %rdi
movq 0x4749(%rip), %rsi      # 0x9fc8
callq 0x1110
jmp 0x5886
movl $0x1, -0x38(%rbp)
jmp 0x58c1
movq 0x4742(%rip), %rdi      # 0x9fd8
leaq 0x19ee(%rip), %rsi      # 0x728b
callq 0x10d0
movq %rax, -0x78(%rbp)
jmp 0x58a8
movq -0x78(%rbp), %rdi
movq 0x4715(%rip), %rsi      # 0x9fc8
callq 0x1110
jmp 0x58ba
movl $0x0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2c40
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1190
nopl (%rax)
// File: 6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_simple_sst.cpp
// Function: main
int main() {
    srand(10);
    chrono::steady_clock::time_point begin = chrono::steady_clock::now();
    test_get_update_1(false);
    test_get_update_2(false);
    test_get_update_3(false);
    test_get_update_4(false);
    test_get_update_5(false);
    test_get_update_1(true);
    test_get_update_2(true);
    test_get_update_3(true);
    test_get_update_4(true);
    test_get_update_5(true);
    chrono::steady_clock::time_point end = chrono::steady_clock::now();
    cout << "Time difference = " << chrono::duration_cast<chrono::microseconds>(end - begin).count() << "[µs]" << std::endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0xa, %edi
callq 0x10c0
callq 0x1130
movq %rax, -0x10(%rbp)
xorl %edi, %edi
callq 0x5430
xorl %edi, %edi
callq 0x5720
xorl %edi, %edi
callq 0x58e0
xorl %edi, %edi
callq 0x5ab0
xorl %edi, %edi
callq 0x5cc0
movl $0x1, %edi
callq 0x5430
movl $0x1, %edi
callq 0x5720
movl $0x1, %edi
callq 0x58e0
movl $0x1, %edi
callq 0x5ab0
movl $0x1, %edi
callq 0x5cc0
callq 0x1130
movq %rax, -0x18(%rbp)
movq 0x3fa1(%rip), %rdi      # 0x9fd8
leaq 0x133c(%rip), %rsi      # 0x737a
callq 0x10d0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x60d0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x60a0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6120
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x11b0
movq %rax, %rdi
leaq 0x1309(%rip), %rsi      # 0x738d
callq 0x10d0
movq %rax, %rdi
movq 0x3f35(%rip), %rsi      # 0x9fc8
callq 0x1110
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: fei3189[P]PLSI/./plsi.hpp
// Function: PLSI::output()
void output() {
        vector<vector<float> > _p_wz = this->p_wz;
        for (int k = 0; k < k_z; ++k) {
            cout << "********************* topic " << k << endl;
            for (int i = 0; i < 10; ++i) {
                int idx = -1;
                float max = 0;
                for (int j = 0; j < c_word; ++j) {
                    if (_p_wz[j][k] > max) {
                        max = _p_wz[j][k];
                        idx = j;
                    }
                }
                cout << id2word[idx] << " " << max << endl;
                if (idx == -1)
                    break;
                _p_wz[idx][k] = 0;
            }
        }
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rsi
movq %rsi, 0x38(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x44e0
movl $0x0, 0x64(%rsp)
movq 0x38(%rsp), %rcx
movl 0x64(%rsp), %eax
cmpl 0x68(%rcx), %eax
jge 0x2b9b
movq 0x135f9(%rip), %rdi     # 0x15fd0
leaq 0xc775(%rip), %rsi      # 0xf153
callq 0x21d0
movq %rax, 0x30(%rsp)
jmp 0x29ea
movq 0x30(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x22d0
movq %rax, 0x28(%rsp)
jmp 0x29ff
movq 0x28(%rsp), %rdi
movq 0x135b5(%rip), %rsi     # 0x15fc0
callq 0x2210
jmp 0x2a12
movl $0x0, 0x50(%rsp)
cmpl $0xa, 0x50(%rsp)
jge 0x2b89
movl $0xffffffff, 0x4c(%rsp) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movss %xmm0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movq 0x38(%rsp), %rcx
movl 0x44(%rsp), %eax
cmpl 0x60(%rcx), %eax
jge 0x2ad6
movslq 0x44(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x46e0
movq %rax, %rdi
movslq 0x64(%rsp), %rsi
callq 0x4700
movss (%rax), %xmm0
ucomiss 0x48(%rsp), %xmm0
jbe 0x2ac4
movslq 0x44(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x46e0
movq %rax, %rdi
movslq 0x64(%rsp), %rsi
callq 0x4700
movss (%rax), %xmm0
movss %xmm0, 0x48(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x4c(%rsp)
jmp 0x2ac4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4990
jmp 0x2bad
jmp 0x2ac6
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x2a3e
movq 0x38(%rsp), %rdi
addq $0xa0, %rdi
leaq 0x4c(%rsp), %rsi
callq 0x5560
movq %rax, 0x20(%rsp)
jmp 0x2af3
movq 0x20(%rsp), %rsi
movq 0x134d1(%rip), %rdi     # 0x15fd0
callq 0x21a0
movq %rax, 0x18(%rsp)
jmp 0x2b0b
movq 0x18(%rsp), %rdi
leaq 0xc574(%rip), %rsi      # 0xf08b
callq 0x21d0
movq %rax, 0x10(%rsp)
jmp 0x2b23
movq 0x10(%rsp), %rdi
movss 0x48(%rsp), %xmm0
callq 0x2170
movq %rax, 0x8(%rsp)
jmp 0x2b3a
movq 0x8(%rsp), %rdi
movq 0x1347a(%rip), %rsi     # 0x15fc0
callq 0x2210
jmp 0x2b4d
cmpl $-0x1, 0x4c(%rsp)
jne 0x2b56
jmp 0x2b89
movslq 0x4c(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x46e0
movq %rax, %rdi
movslq 0x64(%rsp), %rsi
callq 0x4700
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x2a1a
jmp 0x2b8b
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x29be
leaq 0x68(%rsp), %rdi
callq 0x4990
addq $0x88, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x22e0
nopw (%rax,%rax)
// File: fei3189[P]PLSI/./plsi.hpp
// Function: PLSI::_likelihood()
float _likelihood() {
        float lh = 0;
        for (int i = 0; i < c_doc; ++i) {
            const vector<Index> &ns = n_wd[i];
            const int size = ns.size();
            for (int j = 0; j < size; ++j) {
                float n = ns[j].value;
                float z = 0;
                for (int k = 0; k < k_z; ++k) {
                    z += p_wz[ns[j].idx][k] * p_dz[i][k] * p_z[k];
                }
                lh += n * log(z);
            }
        }
        return lh;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movq 0x10(%rsp), %rcx
movl 0x38(%rsp), %eax
cmpl 0x64(%rcx), %eax
jge 0x491d
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
movslq 0x38(%rsp), %rsi
callq 0x4720
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4740
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x490b
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xdea0
cvtsi2ssl 0x4(%rax), %xmm0
movss %xmm0, 0x24(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x68(%rcx), %eax
jge 0x48cb
movq 0x30(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0xdea0
movq 0x10(%rsp), %rdi
movslq (%rax), %rsi
callq 0x46e0
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4700
movq 0x10(%rsp), %rdi
movss (%rax), %xmm0
movss %xmm0, 0x8(%rsp)
addq $0x18, %rdi
movslq 0x38(%rsp), %rsi
callq 0x46e0
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4700
movss 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdi
mulss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
addq $0x30, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4700
movss 0xc(%rsp), %xmm0
mulss (%rax), %xmm0
addss 0x20(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x481d
movss 0x24(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x20(%rsp), %xmm0
callq 0xdec0
movaps %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
mulss %xmm1, %xmm0
addss 0x3c(%rsp), %xmm0
movss %xmm0, 0x3c(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x47e4
jmp 0x490d
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x47a4
movss 0x3c(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: fei3189[P]PLSI/./plsi.hpp
// Function: PLSI::_split(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void _split(vector<string> &tokens, const string &str) {
        istringstream sin(str);
        string t;
        while (sin >> t)
            tokens.push_back(t);
    }

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x8, %edx
callq 0x22c0
leaq 0x20(%rsp), %rdi
callq 0x2260
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2250
movq %rax, 0x8(%rsp)
jmp 0x5296
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2240
movb %al, 0x7(%rsp)
jmp 0x52b0
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x52ba
jmp 0x52f4
movq 0x1c8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2890
jmp 0x52ce
jmp 0x5280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2130
leaq 0x40(%rsp), %rdi
callq 0x20f0
jmp 0x5310
leaq 0x20(%rsp), %rdi
callq 0x2130
leaq 0x40(%rsp), %rdi
callq 0x20f0
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x18(%rsp), %rdi
callq 0x22e0
nopw (%rax,%rax)
// File: fei3189[P]PLSI/./plsi.hpp
// Function: PLSI::_resize1d(std::vector<float, std::allocator<float>>&, int)
void _resize1d(vector<float> &array, int d) {
        array.resize(d, 0);
        float sum = 0;
        for (int i = 0; i < array.size(); ++i) {
            array[i] = ((float)rand()) / RAND_MAX;
            sum += array[i];
        }

        for (int i = 0; i < array.size(); ++i) {
            array[i] /= sum;
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x34(%rsp), %rsi
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rsp)
leaq 0x30(%rsp), %rdx
callq 0xb2c0
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movslq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xb380
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x5934
callq 0x2090
cvtsi2ss %eax, %xmm0
movss 0x973e(%rip), %xmm1     # 0xf020
divss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4700
movss 0x14(%rsp), %xmm0
movss %xmm0, (%rax)
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4700
movss (%rax), %xmm0
addss 0x2c(%rsp), %xmm0
movss %xmm0, 0x2c(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x58b0
movl $0x0, 0x24(%rsp)
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xb380
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5997
movss 0x2c(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4700
movss 0x4(%rsp), %xmm1
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x593c
addq $0x48, %rsp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/mi-scope.cc
// Function: main
int main()
{
	MI obj;
	obj.Base1::print(0);
	obj.Base2::print(3.14);
	obj.Derived::print("hi");
	obj.print(std::vector<double>());
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x14(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1350
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0x1390
leaq -0xc(%rbp), %rdi
movsd 0xd92(%rip), %xmm0      # 0x2008
callq 0x13e0
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10f0
movq -0x78(%rbp), %rdx
leaq 0xd7d(%rip), %rsi       # 0x2010
leaq -0x38(%rbp), %rdi
callq 0x10b0
jmp 0x129e
leaq -0x14(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1430
jmp 0x12ad
leaq -0x38(%rbp), %rdi
callq 0x1050
leaq -0x39(%rbp), %rdi
callq 0x10a0
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x14d0
movq -0x88(%rbp), %rsi
leaq -0x14(%rbp), %rdi
callq 0x1480
jmp 0x12f0
leaq -0x70(%rbp), %rdi
callq 0x14f0
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1327
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1050
leaq -0x39(%rbp), %rdi
callq 0x10a0
jmp 0x1347
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x14f0
movq -0x48(%rbp), %rdi
callq 0x10e0
// File: iZhangHui[P]CppPrimer/CH14_OverloadedOperationsAndConversions/examples/directcall.cc
// Function: main
int main()
{
	Sales_data data1, data2;
	std::cin >> data1 >> data2;    // read Sales_data transactions
	cout << data1 + data2 << endl; // write sum of Sales_data objects
	cout << 42 + 5 << endl;        // write sum of ints

	// equivalent calls to a nonmember operator function
	data1 + data2;            // normal expression
	operator+(data1, data2);  // equivalent function call
	cout << operator+(data1, data2) << endl;

	data1 += data2;           // expression-based ``call''
	data1.operator+=(data2);  // equivalent call to a member operator function
	cout << data1 << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x1510
leaq -0x68(%rbp), %rdi
callq 0x1510
movq -0x148(%rbp), %rsi
movq 0x2cd7(%rip), %rdi      # 0x3fe0
callq 0x15d0
movq %rax, -0x140(%rbp)
jmp 0x1317
movq -0x140(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x15d0
jmp 0x1329
leaq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1710
jmp 0x133f
movq 0x2c8a(%rip), %rdi      # 0x3fd0
leaq -0xa8(%rbp), %rsi
callq 0x1770
movq %rax, -0x150(%rbp)
jmp 0x135b
movq -0x150(%rbp), %rdi
movq 0x2c57(%rip), %rsi      # 0x3fc0
callq 0x10b0
jmp 0x1370
leaq -0xa8(%rbp), %rdi
callq 0x1550
movq 0x2c4d(%rip), %rdi      # 0x3fd0
movl $0x2f, %esi
callq 0x1120
movq %rax, -0x158(%rbp)
jmp 0x1396
movq -0x158(%rbp), %rdi
movq 0x2c1c(%rip), %rsi      # 0x3fc0
callq 0x10b0
jmp 0x13ab
leaq -0xd8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1710
jmp 0x13c1
leaq -0xd8(%rbp), %rdi
callq 0x1550
leaq -0x108(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1710
jmp 0x13e3
leaq -0x108(%rbp), %rdi
callq 0x1550
leaq -0x138(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1710
jmp 0x1405
movq 0x2bc4(%rip), %rdi      # 0x3fd0
leaq -0x138(%rbp), %rsi
callq 0x1770
movq %rax, -0x160(%rbp)
jmp 0x1421
movq -0x160(%rbp), %rdi
movq 0x2b91(%rip), %rsi      # 0x3fc0
callq 0x10b0
jmp 0x1436
leaq -0x138(%rbp), %rdi
callq 0x1550
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x16d0
jmp 0x1451
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x16d0
jmp 0x1460
movq 0x2b69(%rip), %rdi      # 0x3fd0
leaq -0x38(%rbp), %rsi
callq 0x1770
movq %rax, -0x168(%rbp)
jmp 0x1479
movq -0x168(%rbp), %rdi
movq 0x2b39(%rip), %rsi      # 0x3fc0
callq 0x10b0
jmp 0x148e
movl $0x0, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1550
leaq -0x38(%rbp), %rdi
callq 0x1550
movl -0x4(%rbp), %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x14f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1550
jmp 0x14f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x1550
leaq -0x68(%rbp), %rdi
callq 0x1550
leaq -0x38(%rbp), %rdi
callq 0x1550
movq -0x70(%rbp), %rdi
callq 0x1130
nop
// File: shammellee[P]mdl/mdl.cpp
// Function: command_init()
void command_init()
{
  command_add_flag(MDL_CMD_BASE);
  command_add_flag("--restrict-filenames");
  command_add_flag("--no-overwrites");
  command_add_flag("--ignore-errors");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq 0x1a166(%rip), %rsi     # 0x21378
leaq -0x20(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6140
movq -0xb0(%rbp), %rdi
callq 0x7190
jmp 0x7230
leaq -0x20(%rbp), %rdi
callq 0x6688
leaq -0x51(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x65d0
movq -0xb8(%rbp), %rdx
leaq 0xee67(%rip), %rsi      # 0x160be
leaq -0x50(%rbp), %rdi
callq 0x8e80
jmp 0x7262
leaq -0x50(%rbp), %rdi
callq 0x7190
jmp 0x726d
leaq -0x50(%rbp), %rdi
callq 0x6688
leaq -0x51(%rbp), %rdi
callq 0x6380
leaq -0x79(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x65d0
movq -0xc0(%rbp), %rdx
leaq 0xee36(%rip), %rsi      # 0x160d3
leaq -0x78(%rbp), %rdi
callq 0x8e80
jmp 0x72a8
leaq -0x78(%rbp), %rdi
callq 0x7190
jmp 0x72b3
leaq -0x78(%rbp), %rdi
callq 0x6688
leaq -0x79(%rbp), %rdi
callq 0x6380
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x65d0
movq -0xc8(%rbp), %rdx
leaq 0xedfd(%rip), %rsi      # 0x160e3
leaq -0xa0(%rbp), %rdi
callq 0x8e80
jmp 0x72f4
leaq -0xa0(%rbp), %rdi
callq 0x7190
jmp 0x7302
leaq -0xa0(%rbp), %rdi
callq 0x6688
leaq -0xa1(%rbp), %rdi
callq 0x6380
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6688
jmp 0x73cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x7360
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6688
leaq -0x51(%rbp), %rdi
callq 0x6380
jmp 0x73cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x738e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6688
leaq -0x79(%rbp), %rdi
callq 0x6380
jmp 0x73cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x73bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x6688
leaq -0xa1(%rbp), %rdi
callq 0x6380
movq -0x28(%rbp), %rdi
callq 0x65b0
nopw %cs:(%rax,%rax)
// File: shammellee[P]mdl/mdl.cpp
// Function: command_call()
void command_call()
{
  command_add_flag("--batch-file " + manifest_file_path);

  cout << "\e[33mCommand:\e[m " << final_command << endl;

  if(dry_run) return;

  cout << "Download initiated..." << endl;

  system(final_command.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0xed04(%rip), %rsi      # 0x160f3
leaq 0x1a1ca(%rip), %rdx     # 0x215c0
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x8fd0
movq -0x38(%rbp), %rdi
callq 0x7190
jmp 0x740e
leaq -0x20(%rbp), %rdi
callq 0x6688
movq 0x19ba2(%rip), %rdi     # 0x20fc0
leaq 0xecdc(%rip), %rsi      # 0x16101
callq 0x6320
movq %rax, %rdi
leaq 0x1a0cc(%rip), %rsi     # 0x21500
callq 0x6300
movq %rax, %rdi
movq 0x19b3d(%rip), %rsi     # 0x20f80
callq 0x6360
testb $0x1, 0x1a0a9(%rip)     # 0x214f8
je 0x746a
jmp 0x74a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6688
jmp 0x74a6
movq 0x19b4f(%rip), %rdi     # 0x20fc0
leaq 0xec9b(%rip), %rsi      # 0x16113
callq 0x6320
movq %rax, %rdi
movq 0x19af9(%rip), %rsi     # 0x20f80
callq 0x6360
leaq 0x1a06d(%rip), %rdi     # 0x21500
callq 0x6110
movq %rax, %rdi
callq 0x62c0
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x65b0
nop