LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: findAllHGT_no_criterion(InputTree, InputTree, Parameters, HGT*)
int findAllHGT_no_criterion(struct InputTree SpeciesTree, struct InputTree GeneTree,struct Parameters param,struct HGT *tabHGT){
	
	int nbHGT=0;	
	struct InputTree tmpTree;
	int i,j,ktSpecies;
	int size = SpeciesTree.size;
	struct CRITERIA aCrit;
	struct DescTree *DTSpecies,*DTGene;

	initInputTree(&tmpTree);

	//== compute criteria
	InitCriteria(&aCrit,size);

	DTSpecies = (struct DescTree*)malloc((2*SpeciesTree.size)*sizeof(struct DescTree));
	RechercherBipartition(SpeciesTree.ARETE,SpeciesTree.ADD,SpeciesTree.Root,SpeciesTree.Adjacence,DTSpecies,SpeciesTree.size,SpeciesTree.kt);

	for(i=1;i<2*size-3-SpeciesTree.kt;i++)
		for(j=i+1;j<2*size-3-SpeciesTree.kt;j++){
		
			//== is it a valid hgt ?
			if(isAValidHGT(SpeciesTree,i,j)==1){
				
				nbHGT++;
				tabHGT[nbHGT].source = i;
				tabHGT[nbHGT].destination = j;
				tabHGT[nbHGT].valide = 1;

			}
		}
	
	FreeCriteria(&aCrit,size);

	for(i=1;i<=nbHGT;i++)
		findListSpecies(&tabHGT[i],DTSpecies,SpeciesTree);

	
	//printf("\nfin de la fonction");

	return nbHGT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movslq 0x10(%rbp), %r12
leaq -0xa0(%rbp), %rdi
movl %r12d, %esi
callq 0xb8ba
leal (%r12,%r12), %r13d
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
callq 0x1140
movq %rax, %r15
movq 0x40(%rbp), %rdi
movq 0x18(%rbp), %rsi
movl 0x30(%rbp), %edx
movq 0x38(%rbp), %rcx
movl 0x58(%rbp), %r14d
movl %r14d, (%rsp)
movq %rax, %r8
movl %r12d, %r9d
callq 0x4e01
subl %r14d, %r13d
addl $-0x3, %r13d
cmpl $0x2, %r13d
jl 0xbb33
movq %r12, -0x40(%rbp)
movq %r15, -0x38(%rbp)
movl $0x1, %eax
xorl %r12d, %r12d
movl %eax, %r15d
leal 0x1(%r15), %r14d
cmpl %r13d, %r14d
movl %r14d, -0x2c(%rbp)
jge 0xbadd
movl $0xb, %ecx
movq %rsp, %rdi
leaq 0x10(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %r15d, %edi
movl %r14d, %esi
callq 0xa42b
testl %eax, %eax
je 0xbad5
incl %r12d
movslq %r12d, %rax
imulq $0xa8, %rax, %rax
movl %r15d, 0x4(%rbx,%rax)
movl %r14d, 0x8(%rbx,%rax)
movl $0x1, (%rbx,%rax)
incl %r14d
cmpl %r13d, %r14d
jl 0xba99
movl -0x2c(%rbp), %eax
cmpl %r13d, %eax
jne 0xba89
leaq -0xa0(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xb982
testl %r12d, %r12d
jle 0xbb45
movl %r12d, %r14d
addq $0xa8, %rbx
movq -0x38(%rbp), %r15
leaq 0x10(%rbp), %r13
movl $0xb, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa143
addq $0xa8, %rbx
decq %r14
jne 0xbb0c
jmp 0xbb45
leaq -0xa0(%rbp), %rdi
movl %r12d, %esi
callq 0xb982
xorl %r12d, %r12d
movl %r12d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x10(%rbp), %ecx
xorl %eax, %eax
testl %ecx, %ecx
jle 0xd766
leaq 0x28(%rbp), %rdx
leaq 0x10(%rbp), %rsi
movq 0x10(%rdx), %rdx
movl 0x4(%rdx), %edx
movq 0x10(%rsi), %rsi
incq %rcx
movl $0x1, %edi
cmpl (%rsi,%rdi,4), %edx
je 0xd761
incq %rdi
cmpq %rdi, %rcx
jne 0xd752
jmp 0xd766
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: CreateSubStructures(InputTree*, int, int)
void CreateSubStructures(struct InputTree * aTree,int inc,int binaire){
	
	int n = aTree->size;
	int i,j;
	int kt=0;
	inc = 10;
	
	
	//printf("n=%d",n);
	if(aTree->ARETE == NULL){
		aTree->ARETE    =(long int*)malloc(4*(2*(n+inc))*sizeof(long int));
		aTree->LONGUEUR	=(double*)malloc((4*(n+inc))*sizeof(double));
		aTree->Adjacence=(double**)malloc((2*(n+inc)+1)*sizeof(double*));
		for(i=0;i<2*(n+inc);i++)
			aTree->Adjacence[i]=(double*)malloc((2*(n+inc)+1)*sizeof(double));
	}
//	printf("\nbinaire = %d",binaire);
	kt = aTree->kt = Tree_edges (aTree->ADD,aTree->ARETE,aTree->LONGUEUR,n,binaire);
	
	//printf("\n\n");
	//printEdges(0,aTree->ARETE,aTree->LONGUEUR,aTree->SpeciesName,aTree->size);
	//for(i=1;i<=2*n-3-kt;i++)
	//	printf("\n%d-%d : %lf",aTree->ARETE[2*i-1],aTree->ARETE[2*i-2],aTree->LONGUEUR[i-1]);
	//scanf("%d",&i);
	loadAdjacenceMatrix(aTree->Adjacence,aTree->ARETE, aTree->LONGUEUR,n,aTree->kt);
	Floyd(aTree->Adjacence,aTree->ADD,n,aTree->kt); // 4eme fois
//  global_cpt4++;
	
  //===creation de degre
	aTree->degre = (int*)malloc(2*(n+inc)*sizeof(int));
	for(i=1;i<=2*n-2-kt;i++){
		aTree->degre[i]=0;
		for(j=1;j<=2*n-2-kt;j++)
			if(aTree->Adjacence[i][j] < INFINI) aTree->degre[i]++;
	}
	/*for(i=1;i<=2*n-2-kt;i++)
		printf("%d ",aTree->degre[i]);*/
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rdi, %rbx
movslq (%rdi), %r14
movq 0x30(%rdi), %r12
testq %r12, %r12
jne 0xd80e
leaq 0xa(%r14), %r15
movq %r15, %rdi
shlq $0x6, %rdi
movl %r8d, -0x2c(%rbp)
callq 0x1140
movq %rax, %r12
movq %rax, 0x30(%rbx)
leal (,%r15,4), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x38(%rbx)
leal 0x1(,%r15,2), %eax
movslq %eax, %r13
shlq $0x3, %r13
movq %r13, %rdi
callq 0x1140
movl -0x2c(%rbp), %r8d
movq %rax, 0x28(%rbx)
cmpl $-0x9, %r14d
jl 0xd80e
leal (%r15,%r15), %eax
movl %eax, %r15d
xorl %r12d, %r12d
movq %r13, %rdi
callq 0x1140
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xd7ee
movq 0x30(%rbx), %r12
movl -0x2c(%rbp), %r8d
movq 0x8(%rbx), %rdi
movq 0x38(%rbx), %rdx
movq %r12, %rsi
movl %r14d, %ecx
callq 0x23f9
movl %eax, %r15d
movl %eax, 0x48(%rbx)
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl %r14d, %ecx
movl %eax, %r8d
callq 0x2215
movq 0x8(%rbx), %rsi
movq 0x28(%rbx), %rdi
movl 0x48(%rbx), %ecx
movl %r14d, %edx
callq 0x1cad
movl %r14d, %r12d
addl %r12d, %r12d
leal 0x14(,%r14,2), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1140
movq %rax, 0x50(%rbx)
movl %r12d, %ecx
subl %r15d, %ecx
addl $-0x2, %ecx
testl %ecx, %ecx
jle 0xd8c3
notl %r15d
addl %r15d, %r12d
movq 0x28(%rbx), %rcx
movl $0x1, %edx
movsd 0x77b5(%rip), %xmm0     # 0x15048
movl $0x0, (%rax,%rdx,4)
movq (%rcx,%rdx,8), %rsi
xorl %edi, %edi
movl $0x1, %r8d
ucomisd (%rsi,%r8,8), %xmm0
jbe 0xd8b3
incl %edi
movl %edi, (%rax,%rdx,4)
incq %r8
cmpq %r8, %r12
jne 0xd8a6
incq %rdx
cmpq %r12, %rdx
jne 0xd893
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl 0x18(%rbp), %ebx
movl 0x10(%rbp), %r14d
testl %esi, %esi
je 0xe355
movl %ecx, %r13d
movq %rdx, %r12
cmpl %ecx, %r8d
jle 0xe380
cmpl %r13d, %r9d
jle 0xe39d
leaq 0x7e5e(%rip), %rsi      # 0x161a1
movq %r15, %rdi
movl %r8d, %edx
movl %r9d, %ecx
xorl %eax, %eax
callq 0x1180
jmp 0xe3b8
leaq 0x7df8(%rip), %rsi      # 0x16154
movq %r15, %rdi
movl %r8d, %edx
movl %r9d, %ecx
movl %r14d, %r8d
movl %ebx, %r9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1180
movslq %r8d, %rax
movq (%r12,%rax,8), %rdx
leaq 0x7deb(%rip), %rsi      # 0x16179
movq %r15, %rdi
movl %r9d, %ecx
xorl %eax, %eax
callq 0x1180
jmp 0xe3b8
movslq %r9d, %rax
movq (%r12,%rax,8), %rcx
leaq 0x7de2(%rip), %rsi      # 0x1618d
movq %r15, %rdi
movl %r8d, %edx
xorl %eax, %eax
callq 0x1180
cmpl %r13d, %r14d
jle 0xe3e6
cmpl %r13d, %ebx
jle 0xe40e
leaq 0x7d9e(%rip), %rsi      # 0x16167
movq %r15, %rdi
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1180
movslq %r14d, %rax
movq (%r12,%rax,8), %rdx
leaq 0x7dc1(%rip), %rsi      # 0x161b5
movq %r15, %rdi
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1180
movslq %ebx, %rax
movq (%r12,%rax,8), %rcx
leaq 0x7dab(%rip), %rsi      # 0x161c7
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1180
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printListSpecies(HGT*, int, double*, int)
void printListSpecies(struct HGT * bestHGT, int nbHGT, double *tabBoot, int bootmin){

		FILE * out = fopen ("result.txt","w+");
		for(int i=1; i<= nbHGT && (bestHGT[i].valide == 1 || (bestHGT[i].valide == 6)); i++){
			if((tabBoot != NULL && tabBoot[i] >= bootmin) || (tabBoot == NULL)){
				fprintf(out,"\n%d",bestHGT[i].listSource[0]);
				for(int j=1;j<=bestHGT[i].listSource[0];j++)
					fprintf(out," %d",bestHGT[i].listSource[j]);
				fprintf(out,"\n%d",bestHGT[i].listDestination[0]);
				for(int j=1;j<=bestHGT[i].listDestination[0];j++)
					fprintf(out," %d",bestHGT[i].listDestination[j]);
			}
		}
		fclose(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r13d
movq %rdx, -0x38(%rbp)
movl %esi, %ebx
movq %rdi, -0x40(%rbp)
leaq 0x6f6a(%rip), %rdi      # 0x153c6
leaq 0x7332(%rip), %rsi      # 0x15795
callq 0x10e0
movq %rax, %r12
movq %rbx, -0x30(%rbp)
testl %ebx, %ebx
jle 0xe569
cvtsi2sd %r13d, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x30(%rbp), %rax
incl %eax
movq %rax, -0x30(%rbp)
movl $0x1, %r14d
leaq 0x7275(%rip), %r13      # 0x1570d
imulq $0xa8, %r14, %rbx
movq -0x40(%rbp), %rax
movl (%rax,%rbx), %eax
cmpl $0x1, %eax
je 0xe4b4
cmpl $0x6, %eax
jne 0xe569
cmpq $0x0, -0x38(%rbp)
je 0xe4d0
movq -0x38(%rbp), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd -0x48(%rbp), %xmm0
jb 0xe55c
addq -0x40(%rbp), %rbx
movq 0x10(%rbx), %rax
movl (%rax), %edx
movq %r12, %rdi
leaq 0x7cf5(%rip), %rsi      # 0x161d9
xorl %eax, %eax
callq 0x1180
movq 0x10(%rbx), %rax
cmpl $0x0, (%rax)
jle 0xe518
xorl %r15d, %r15d
movl 0x4(%rax,%r15,4), %edx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1180
movq 0x10(%rbx), %rax
movslq (%rax), %rcx
incq %r15
cmpq %rcx, %r15
jl 0xe4f7
movq 0x18(%rbx), %rax
movl (%rax), %edx
movq %r12, %rdi
leaq 0x7cb1(%rip), %rsi      # 0x161d9
xorl %eax, %eax
callq 0x1180
movq 0x18(%rbx), %rax
cmpl $0x0, (%rax)
jle 0xe55c
xorl %r15d, %r15d
movl 0x4(%rax,%r15,4), %edx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1180
movq 0x18(%rbx), %rax
movslq (%rax), %rcx
incq %r15
cmpq %rcx, %r15
jl 0xe53b
incq %r14
cmpq -0x30(%rbp), %r14
jne 0xe498
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %r14d
movl %esi, %eax
movq %rdi, %rbx
movl 0x68(%rbp), %ecx
cmpl $0x6, %ecx
je 0xebfb
cmpl $0x1, %ecx
jne 0xecb3
leaq 0x68(%rbp), %r12
leaq 0x10(%rbp), %r13
subl (%rdx), %eax
leaq 0x76f5(%rip), %rsi      # 0x16301
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1180
cmpl $-0x1, %r15d
je 0xec45
cvtsi2sd %r15d, %xmm0
cvtsi2sd %r14d, %xmm1
divsd %xmm1, %xmm0
mulsd 0x6444(%rip), %xmm0     # 0x15078
leaq 0x76f4(%rip), %rsi      # 0x1632f
movq %rbx, %rdi
movb $0x1, %al
callq 0x1180
movq 0x18(%r13), %rdx
movl (%r13), %ecx
movl 0x80(%r12), %r8d
movl 0x84(%r12), %r9d
movl 0x88(%r12), %eax
movl 0x8c(%r12), %r10d
movq %rbx, %rdi
movl $0x1, %esi
pushq %r10
pushq %rax
callq 0xe310
addq $0x10, %rsp
movl 0x50(%r12), %edx
movsd 0x20(%r12), %xmm0
movsd 0x30(%r12), %xmm1
leaq 0x76ad(%rip), %rsi      # 0x16348
movq %rbx, %rdi
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1180
incl (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %edx, %edx
jle 0xed39
leal 0x1(%rdx), %r8d
xorl %ecx, %ecx
movl $0x1, %eax
movl (%rsi,%rax,4), %r9d
xorl %r10d, %r10d
cmpl %r9d, (%rdi,%rax,4)
setne %r10b
addl %r10d, %ecx
movl %r9d, %r10d
incl %r10d
shrl $0x1f, %r10d
addl %r9d, %r10d
incl %r10d
andl $-0x2, %r10d
negl %r10d
addl %r10d, %r9d
incl %r9d
movl %r9d, (%rsi,%rax,4)
incq %rax
cmpq %rax, %r8
jne 0xecd7
testl %edx, %edx
jle 0xed3b
xorl %eax, %eax
movl $0x1, %edx
movl (%rdi,%rdx,4), %r9d
xorl %r10d, %r10d
cmpl (%rsi,%rdx,4), %r9d
setne %r10b
addl %r10d, %eax
incq %rdx
cmpq %rdx, %r8
jne 0xed1d
jmp 0xed3d
xorl %ecx, %ecx
xorl %eax, %eax
cmpl %eax, %ecx
cmovbl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, -0x50(%rbp)
movl (%rsi), %r12d
leal 0x1(%r12), %r14d
movslq %r14d, %rdi
shlq $0x2, %rdi
callq 0x1140
movq %rax, %r13
leal (%r12,%r12), %ebx
movq %r15, -0x48(%rbp)
subl 0x48(%r15), %ebx
leal -0x3(%rbx), %eax
testl %eax, %eax
jle 0xee49
movq %r13, %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
leaq (,%r12,4), %rax
movq %rax, -0x38(%rbp)
addl $-0x2, %ebx
movl %r14d, %r14d
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, %r15d
testl %r12d, %r12d
jle 0xee00
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x30(%rcx), %rdx
movq %r15, %rsi
shlq $0x4, %rsi
movq -0x10(%rdx,%rsi), %rcx
movq -0x8(%rdx,%rsi), %rdx
movl $0x1, %esi
movq (%rax,%rsi,8), %rdi
movsd (%rdi,%rcx,8), %xmm0
xorl %r8d, %r8d
ucomisd (%rdi,%rdx,8), %xmm0
setbe %r8b
movl %r8d, (%r13,%rsi,4)
incq %rsi
cmpq %rsi, %r14
jne 0xedde
movq -0x50(%rbp), %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0xecc4
movl -0x30(%rbp), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmovlel %r15d, %eax
movl %eax, -0x2c(%rbp)
testl %r12d, %r12d
jle 0xee3b
movq -0x40(%rbp), %rdi
movl $0xff, %esi
movq -0x38(%rbp), %rdx
callq 0x1060
incq %r15
cmpq %rbx, %r15
jne 0xedb7
jmp 0xee50
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq %r13, %rdi
callq 0x1100
movl -0x2c(%rbp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, -0x58(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x38(%rbp)
movq %rax, -0x28(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x40(%rbp)
movl %eax, -0x60(%rbp)
movl $0x0, -0x18(%rbp)
movups %xmm0, -0x50(%rbp)
movl (%rdi), %esi
leaq 0x6ffb(%rip), %rdi      # 0x16365
xorl %eax, %eax
callq 0x1030
movl (%rbx), %eax
leal -0x3(,%rax,2), %eax
cmpl 0x48(%rbx), %eax
jg 0xf38e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xb8, %rsp
popq %rbx
popq %rbp
retq
movl $0xb, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xa587
leaq 0x6e21(%rip), %rdi      # 0x161da
movl $0x1, %esi
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movl $0x1, %esi
callq 0x711c
xorl %edi, %edi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: chargerFichier(InputTree*, char const*, char const*)
void chargerFichier(struct InputTree *aTree,const char* branchesFile,const char* rootFile){
	
	FILE *branch = fopen(branchesFile,"r");
	FILE *root =  fopen(rootFile,"r");
	int aa,bb,i,noBranch=0;
	double ll;

	for(i=1;i<=2*(aTree->size)-3;i++){
		fscanf(branch,"%d %d %lf",&aa,&bb,&ll);
		aTree->ARETE[2*i-1] = aa;
		aTree->ARETE[2*i-2] = bb;
		aTree->LONGUEUR[i-1] = ll;
		//printf("\n%d %d %lf",ARETE[2*i-1],ARETE[2*i-2],LONGUEUR[i-1]);
	}
	fscanf(root,"%d %d",&aa,&bb);

	for(i=1;i<=2*(aTree->size)-3;i++)
		if((aTree->ARETE[2*i-1] == aa && aTree->ARETE[2*i-2] == bb) || (aTree->ARETE[2*i-1] == bb && aTree->ARETE[2*i-2] == aa))
			noBranch = i;
	printf("-->nobranch=%d<--",i);
	addLeafAndUpdate(aTree,noBranch);
	aTree->Root = aTree->size;

	fclose(branch);
	fclose(root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x6a30(%rip), %r15      # 0x16372
movq %rsi, %rdi
movq %r15, %rsi
callq 0x10e0
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0x10e0
movq %rax, -0x38(%rbp)
cmpl $0x2, (%rbx)
jl 0xf9c8
movl $0x8, %r12d
leaq -0x40(%rbp), %r15
xorl %r13d, %r13d
movq %r14, %rdi
leaq 0x6a71(%rip), %rsi      # 0x163ec
leaq -0x30(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x11e0
movslq -0x30(%rbp), %rax
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r12)
movslq -0x2c(%rbp), %rax
movq %rax, -0x8(%rcx,%r12)
movsd -0x40(%rbp), %xmm0
movq 0x38(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
movslq (%rbx), %rax
leaq -0x3(,%rax,2), %rax
addq $0x10, %r12
incq %r13
cmpq %rax, %r13
jl 0xf971
leaq 0x7160(%rip), %rsi      # 0x16b2f
xorl %r12d, %r12d
leaq -0x30(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
movq -0x38(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x11e0
movl (%rbx), %eax
movl $0x1, %esi
cmpl $0x2, %eax
jl 0xfa4a
leal -0x3(,%rax,2), %esi
movq 0x30(%rbx), %rax
movslq -0x30(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl $0x2, %esi
movl $0x1, %edi
cmovll %edi, %esi
movq %rsi, %r8
shlq $0x4, %r8
xorl %r9d, %r9d
xorl %r12d, %r12d
movq 0x8(%rax,%r9), %r10
cmpq %rcx, %r10
jne 0xfa2f
cmpq %rdx, (%rax,%r9)
je 0xfa3a
cmpq %rdx, %r10
jne 0xfa3d
cmpq %rcx, (%rax,%r9)
jne 0xfa3d
movl %edi, %r12d
incl %edi
addq $0x10, %r9
cmpq %r9, %r8
jne 0xfa1f
incl %esi
leaq 0x69a5(%rip), %rdi      # 0x163f6
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movl %r12d, %esi
callq 0x711c
movl (%rbx), %eax
movl %eax, 0x20(%rbx)
movq %r14, %rdi
callq 0x10a0
movq %r15, %rdi
callq 0x10a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edx, %edx
jle 0xfdf2
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
incl %ebx
movl $0x1, %r15d
leaq 0x6679(%rip), %r12      # 0x16408
leaq 0x6443(%rip), %rdi      # 0x161d9
movl %r15d, %esi
xorl %eax, %eax
callq 0x1030
movl $0x1, %r13d
movq (%r14,%r15,8), %rax
movsd (%rax,%r13,8), %xmm0
ucomisd 0x5290(%rip), %xmm0     # 0x15048
jae 0xfdca
leaq 0x6651(%rip), %rdi      # 0x16412
movb $0x1, %al
callq 0x1030
jmp 0xfdd4
movq %r12, %rdi
xorl %eax, %eax
callq 0x1030
incq %r13
cmpq %r13, %rbx
jne 0xfda6
incq %r15
cmpq %rbx, %r15
jne 0xfd8f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edx, %edx
jle 0xfe84
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
incl %ebx
movl $0x1, %r15d
leaq 0x65f5(%rip), %r12      # 0x16412
leaq 0x63b5(%rip), %rdi      # 0x161d9
movl %r15d, %esi
xorl %eax, %eax
callq 0x1030
movl $0x1, %r13d
movq (%r14,%r15,8), %rax
movsd (%rax,%r13,8), %xmm0
movsd 0x51e2(%rip), %xmm1     # 0x15028
ucomisd %xmm0, %xmm1
jbe 0xfe5c
leaq 0x65c7(%rip), %rdi      # 0x1641a
xorl %eax, %eax
callq 0x1030
jmp 0xfe66
movq %r12, %rdi
movb $0x1, %al
callq 0x1030
incq %r13
cmpq %r13, %rbx
jne 0xfe34
incq %r15
cmpq %rbx, %r15
jne 0xfe1d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
testq %rdi, %rdi
je 0xfeb2
leaq 0x657c(%rip), %rsi      # 0x16422
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1180
jmp 0xfec3
leaq 0x656b(%rip), %rdi      # 0x16424
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1030
movq 0x30(%r14), %rdx
movq 0x38(%r14), %rcx
movq 0x18(%r14), %r8
movl (%r14), %r9d
movl 0x48(%r14), %eax
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1e3d
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorl %ecx, %ecx
cmpb $0x2d, (%rdi)
jne 0xff73
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1050
cmpl $0x2, %eax
jl 0xff61
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movl $0x1, %edx
xorl %esi, %esi
movb (%r15,%rdx), %dil
movslq %esi, %r8
cmpb $0x3d, %dil
jne 0xff3d
movb $0x0, (%r14,%r8)
movl $0x1, %ecx
xorl %esi, %esi
jmp 0xff54
incl %esi
testl %ecx, %ecx
je 0xff4e
movb %dil, (%rbx,%r8)
movl $0x1, %ecx
jmp 0xff54
movb %dil, (%r14,%r8)
xorl %ecx, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0xff22
movslq %esi, %rax
jmp 0xff65
xorl %eax, %eax
xorl %ecx, %ecx
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: deleteSommet(DescTree*, int, int)
void deleteSommet(struct DescTree *tab, int t1, int t2){

	int i,j,k=0,toDel=1,tmp;
	
	// si les elements de tab1 se trouve dans tab2 on les supprimes dans tab2
	for(i=0;i<tab[t1].nbSommet;i++){
		tmp=0;
		for(j=0;j<tab[t2].nbSommet;j++){
			if(tab[t1].Tableau[i] == tab[t2].Tableau[j]){
				//printf("\n=>%d (%d)",tab[t1].Tableau[i],tab[t1].nbSommet);
				tmp=1;
			}
		}
		if(tmp==0) toDel=0;
	}
	for(i=0;i<tab[t1-1].nbSommet;i++){
		tmp=0;
		for(j=0;j<tab[t2].nbSommet;j++){
			if(tab[t1-1].Tableau[i] == tab[t2].Tableau[j]){
				//printf("\n=>%d (%d)",tab[t1-1].Tableau[i],tab[t1-1].nbSommet);
				tmp=1;
			}
		}
		if(tmp==0) toDel=0;
	}
	

	// suppression des sommets
	if(toDel == 1){
		for(i=0;i<tab[t1].nbSommet;i++){
			for(j=0;j<tab[t2].nbSommet;j++){
				if(tab[t1].Tableau[i] == tab[t2].Tableau[j]){
					tab[t2].Tableau[j]=-1;
					k=j;
				}
			}

			for(j=k;j<tab[t2].nbSommet-1;j++){
				tab[t2].Tableau[j] = tab[t2].Tableau[j+1];
			}
			tab[t2].nbSommet--;
		
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %rax
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,8), %rax
movslq (%rax), %rsi
movslq %edx, %rcx
testq %rsi, %rsi
jle 0x11196
leaq (%rcx,%rcx,2), %rdx
leaq (%rdi,%rdx,8), %r8
movl (%r8), %r9d
movl $0x1, %r10d
xorl %r11d, %r11d
movl $0x1, %ebx
movl $0x0, %edx
testl %r9d, %r9d
jle 0x1118a
movq 0x10(%rax), %rdx
movl (%rdx,%r11,4), %edx
movq 0x10(%r8), %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpl (%r14,%r12,4), %edx
cmovel %r10d, %r15d
incq %r12
cmpq %r12, %r9
jne 0x11171
testl %r15d, %r15d
cmovel %r15d, %ebx
movl %ebx, %edx
incq %r11
movl %edx, %ebx
cmpq %rsi, %r11
jne 0x11155
jmp 0x1119b
movl $0x1, %edx
movslq -0x18(%rax), %r8
testq %r8, %r8
jle 0x111fb
leaq (%rcx,%rcx,2), %r9
leaq (%rdi,%r9,8), %r9
movl (%r9), %r10d
xorl %r11d, %r11d
movl $0x1, %ebx
movl $0x0, %r14d
testl %r10d, %r10d
jle 0x111ee
movq -0x8(%rax), %r14
movl (%r14,%r11,4), %r14d
movq 0x10(%r9), %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpl (%r15,%r13,4), %r14d
cmovel %ebx, %r12d
incq %r13
cmpq %r13, %r10
jne 0x111d4
testl %r12d, %r12d
cmovel %r12d, %edx
movl %edx, %r14d
incq %r11
movl %r14d, %edx
cmpq %r8, %r11
jne 0x111b7
jmp 0x111fe
movl %edx, %r14d
cmpl $0x1, %r14d
jne 0x1127c
testl %esi, %esi
jle 0x1127c
leaq (%rcx,%rcx,2), %rcx
leaq (%rdi,%rcx,8), %rcx
movl (%rcx), %edi
xorl %edx, %edx
xorl %esi, %esi
testl %edi, %edi
jle 0x11247
movq 0x10(%rax), %r8
movq 0x10(%rcx), %r9
xorl %r10d, %r10d
movl (%r8,%rdx,4), %r11d
cmpl (%r9,%r10,4), %r11d
jne 0x1123c
movl $0xffffffff, (%r9,%r10,4) # imm = 0xFFFFFFFF
movl (%rcx), %edi
movl %r10d, %esi
incq %r10
movslq %edi, %r11
cmpq %r11, %r10
jl 0x11225
decl %edi
cmpl %edi, %esi
jge 0x1126f
movq 0x10(%rcx), %r8
movslq %esi, %r9
movl 0x4(%r8,%r9,4), %edi
movl %edi, (%r8,%r9,4)
leaq 0x1(%r9), %r10
movslq (%rcx), %rdi
decq %rdi
movq %r10, %r9
cmpq %rdi, %r10
jl 0x11254
movl %edi, (%rcx)
incq %rdx
movslq (%rax), %r8
cmpq %r8, %rdx
jl 0x11216
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %esi, %esi
jle 0x112f6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl %esi, %r13d
negl %r13d
movl $0x1, %r15d
movl $0x2, %ebx
movl %esi, -0x2c(%rbp)
cmpl %esi, %r15d
jge 0x112d9
movl %ebx, %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x11119
leal (%r12,%r13), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x112b8
addl $0x2, %r15d
addl $0x2, %ebx
movl -0x2c(%rbp), %esi
cmpl %esi, %r15d
jle 0x112b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %edi, %esi
leaq 0x5224(%rip), %rdi      # 0x169ea
xorl %eax, %eax
callq 0x1030
leaq 0x5241(%rip), %rdi      # 0x16a15
xorl %eax, %eax
callq 0x1030
movl $0xa, %edi
callq 0x1160
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %edx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x224e
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2454
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x247e
movl $0x30, %ebx
testl %eax, %eax
je 0x2b37
leaq 0x1711(%rip), %rsi      # 0x4246
jmp 0x2ba6
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x2454
leaq 0x8(%rsp), %rdi
movl $0x5, %esi
callq 0x247e
testl %eax, %eax
je 0x2b64
leaq 0x1715(%rip), %rsi      # 0x4277
jmp 0x2ba6
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x2454
leaq 0x8(%rsp), %rdi
movl $0x1f5, %esi            # imm = 0x1F5
callq 0x247e
testl %eax, %eax
leaq 0x174e(%rip), %rax      # 0x42db
leaq 0x1714(%rip), %rsi      # 0x42a8
cmoveq %rax, %rsi
movl $0x15, %eax
movl $0x32, %ebx
cmoveq %rax, %rbx
movq 0x442b(%rip), %r14      # 0x6fd8
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1130
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq 0x4402(%rip), %rdi      # 0x6fd8
callq 0x1030
movq %rax, %rdi
callq 0x10a0
leaq 0x8(%rsp), %rdi
callq 0x22b6
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22b6
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl $0xa, %edi
callq 0x10e0
callq 0x1150
movq %rax, %rbx
xorl %edi, %edi
callq 0x28fc
xorl %edi, %edi
callq 0x2aec
xorl %edi, %edi
callq 0x2c0a
xorl %edi, %edi
callq 0x2dc4
xorl %edi, %edi
callq 0x2fad
movl $0x1, %edi
callq 0x28fc
movl $0x1, %edi
callq 0x2aec
movl $0x1, %edi
callq 0x2c0a
movl $0x1, %edi
callq 0x2dc4
movl $0x1, %edi
callq 0x2fad
callq 0x1150
movq %rax, %r14
movq 0x3d75(%rip), %r15      # 0x6fd8
leaq 0x1160(%rip), %rsi      # 0x43ca
movl $0x12, %edx
movq %r15, %rdi
callq 0x1130
subq %rbx, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x10d0
movq %rax, %rbx
leaq 0x1133(%rip), %rsi      # 0x43dd
movl $0x5, %edx
movq %rax, %rdi
callq 0x1130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movslq 0x64(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
jle 0x3a08
movq 0x48(%rdi), %rax
movq %rax, 0x18(%rsp)
movl 0x68(%rdi), %r15d
movq (%rdi), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rdi), %rbp
xorps %xmm0, %xmm0
xorl %eax, %eax
movq %rax, 0x28(%rsp)
leaq (%rax,%rax,2), %rax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rbx
movq 0x8(%rcx,%rax,8), %r14
subq %rbx, %r14
shrq $0x3, %r14
testl %r14d, %r14d
jle 0x39f3
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %r13
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movss %xmm0, 0xc(%rsp)
testl %r15d, %r15d
jle 0x39c0
movslq (%rbx,%r12,8), %rax
leaq (%rax,%rax,2), %rax
movq 0x30(%rsp), %rcx
movq (%rcx,%rax,8), %rax
movq (%r13), %rcx
xorps %xmm0, %xmm0
xorl %edx, %edx
movss (%rcx,%rdx,4), %xmm1
mulss (%rax,%rdx,4), %xmm1
mulss (%rbp,%rdx,4), %xmm1
addss %xmm1, %xmm0
incq %rdx
cmpq %rdx, %r15
jne 0x39a2
jmp 0x39c3
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x4(%rbx,%r12,8), %xmm1
movss %xmm1, 0x8(%rsp)
callq 0x2300
mulss 0x8(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
incq %r12
cmpq %r14, %r12
jne 0x397d
movq 0x28(%rsp), %rax
incq %rax
cmpq 0x20(%rsp), %rax
jne 0x3943
jmp 0x3a0b
xorps %xmm0, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x22b0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3b2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2838
jmp 0x3b09
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b46
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x547b(%rip), %rsi      # 0x8fc8
leaq 0x28(%rsp), %rdi
callq 0x2240
leaq 0xa0(%rsp), %rdi
callq 0x20a0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b8d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x5434(%rip), %rsi      # 0x8fc8
leaq 0x28(%rsp), %rdi
callq 0x2240
leaq 0xa0(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edx, %rsi
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
movq %rbx, %rdi
callq 0x4cea
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0x3d6b
xorps %xmm1, %xmm1
xorl %r14d, %r14d
movss %xmm1, (%rsp)
callq 0x2080
movss (%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x22c7(%rip), %xmm0     # 0x6010
movq (%rbx), %rax
movss %xmm0, (%rax,%r14,4)
addss %xmm0, %xmm1
incq %r14
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
ja 0x3d2b
jmp 0x3d72
sarq $0x2, %rcx
xorps %xmm1, %xmm1
testq %rcx, %rcx
je 0x3d9b
movss 0x2289(%rip), %xmm0     # 0x6008
divss %xmm1, %xmm0
xorl %edx, %edx
movss (%rax,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x3d85
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cyamonide[P]md2html/./src/main.cpp
// Function: main
int main(int argc, char const *argv[])
{
    Md2html m;

    if (argc >= 3)
    {
        m.setInputPath(argv[1]);
        m.setOutputPath(argv[2]);
    }
    else if (argc == 2)
    {
        m.setInputPath(argv[1]);
        m.setOutputPath("out.html");
    }
    else
    {
        return 1;
    }

    m.start();

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x570, %rsp            # imm = 0x570
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x88(%rsp), %rdi
callq 0x14f70
cmpl $0x3, %r14d
jl 0x5555
movq 0x8(%rbx), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5724
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x15186
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5514
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x10(%rbx), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5724
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x151b6
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55ee
movq 0x58(%rsp), %rsi
jmp 0x55e6
movl $0x1, %ebp
cmpl $0x2, %r14d
jne 0x55fd
movq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5724
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x15186
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55a4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x15c62(%rip), %rsi     # 0x1b216
leaq 0x15c63(%rip), %rdx     # 0x1b21e
leaq 0x8(%rsp), %rdi
callq 0xa2a4
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x151b6
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x55ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
xorl %ebp, %ebp
leaq 0x88(%rsp), %rdi
callq 0x155d8
leaq 0x88(%rsp), %rdi
callq 0x1540a
movl %ebp, %eax
addq $0x570, %rsp            # imm = 0x570
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5687
movq 0x18(%rsp), %rsi
jmp 0x5678
jmp 0x5684
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5687
movq 0x38(%rsp), %rsi
jmp 0x5678
jmp 0x5684
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5687
movq 0x58(%rsp), %rsi
jmp 0x5678
jmp 0x5684
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5687
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x5687
jmp 0x5684
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x1540a
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O3/cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::~Md2html()
Md2html::~Md2html()
{
    buffer.push_front("");
    closeAllTags();
    flushBuffer();
    fin.close();
    fout.close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x5e41(%rip), %rdx      # 0x1b265
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xa2a4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19a66
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x15455
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x16cb2
testb %al, %al
jne 0x15455
movq %rbx, %rdi
callq 0x15536
leaq 0xe0(%rbx), %r14
movq %r14, %rdi
callq 0x4070
leaq 0x2e8(%rbx), %rdi
callq 0x43c0
movq 0xfb0d(%rip), %rax      # 0x24f98
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x2e8(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x2e8(%rbx,%rcx)
leaq 0x2f0(%rbx), %rdi
callq 0x4230
leaq 0x3e0(%rbx), %rdi
callq 0x40d0
movq %r14, %rdi
callq 0x4080
movq 0xc0(%rbx), %rdi
leaq 0xd0(%rbx), %rax
cmpq %rax, %rdi
je 0x154e3
movq (%rax), %rsi
incq %rsi
callq 0x42a0
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x15501
movq (%rax), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rbx), %rdi
callq 0x19550
movq %rbx, %rdi
callq 0x19132
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x1551c
movq %rax, %rdi
callq 0x5761
// File: /workspace/github_cpp_makefile_star2_O3/cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::start()
void Md2html::start()
{
    buffer.push_front("");

    while (getNextLine())
    {
        resolveNextLine();
        writeBuffer();
    }

    buffer.push_front("");
    closeAllTags();
    flushBuffer();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x5c73(%rip), %rdx      # 0x1b265
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xa2a4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19a66
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x15635
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x15635
movq %rbx, %rdi
callq 0x1577e
movq %rbx, %rdi
callq 0x16b12
movq %rbx, %rdi
callq 0x156c4
testb %al, %al
jne 0x15625
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x5c15(%rip), %rdx      # 0x1b265
movq %rdx, %rsi
callq 0xa2a4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19a66
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1567c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x16cb2
testb %al, %al
jne 0x1567c
movq %rbx, %rdi
callq 0x15536
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x1569c
jmp 0x156b8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x156bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x156bb
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O3/cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::getNextLine()
bool Md2html::getNextLine()
{
    string line_buf;
    if (getline(fin, line_buf))
    {
        buffer.push_front(line_buf);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0xe0(%rdi), %r14
movq 0xe0(%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4280
movsbl %al, %edx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x44c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %ebp
testb $0x5, %bpl
jne 0x15733
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1917c
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1574a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb $0x5, %bpl
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15776
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O3/linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::iteration_proxy_value<nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>>::key() const
const string_type& key() const
    {
        assert(anchor.m_object != nullptr);

        switch (anchor.m_object->type())
        {
            // use integer array index as key
            case value_t::array:
            {
                if (array_index != array_index_last)
                {
                    int_to_string( array_index_str, array_index );
                    array_index_last = array_index;
                }
                return array_index_str;
            }

            // use key from the object
            case value_t::object:
                return anchor.key();

            // use an empty key for all primitive types
            default:
                return empty_str;
        }
    }

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x4490
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x447e
cmpl $0x2, %eax
jne 0x4487
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x4478
leaq 0x30(%rbx), %rdi
callq 0xedd3
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
addq $0x30, %rbx
jmp 0x448b
movq %rbx, %rdi
popq %rbx
jmp 0xee94
addq $0x50, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0xea88(%rip), %rdi      # 0x12f1f
leaq 0xc2da(%rip), %rsi      # 0x10778
leaq 0xea95(%rip), %rcx      # 0x12f3a
movl $0xd18, %edx            # imm = 0xD18
callq 0x3180
nop