LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: printNoeudDT(DescTree*, int, int, int)
void printNoeudDT(struct DescTree *DT,int position,int n1,int n2){		
		int j,k;
		printf("\ncouple (%d,%d) position (%d): ",n1,n2,position);
		for(j=1;j<=DT[position].nbSommet;j++)
			printf("%d ",DT[position].Tableau[j]);
	/*for(j=1;j<=DT[position].nbSommet;j++){
			printf("\n%d\t",DT[position].Tableau[j]);
			for(k=1;k<=DT[position].nbSommet;k++){
				printf("%lf\t",DT[position].Matrice[j][k]);
			}
		}*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xe9a0(%rip), %rdi      # 0x15809
movl %edx, %esi
movl %ecx, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1030
movslq %r14d, %rax
leaq (%rax,%rax,2), %rax
cmpl $0x0, (%rbx,%rax,8)
jle 0x6eb0
leaq (%rbx,%rax,8), %r14
leaq 0xe99a(%rip), %rbx      # 0x15829
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movl 0x4(%rax,%r15,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
movslq (%r14), %rax
incq %r15
cmpq %rax, %r15
jl 0x6e92
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: trier(HGT*, int)
void trier(struct HGT *bestHGTRed, int nbHgtFound){
	struct HGT tmp;
	int inversion;
	int i;
	do
	{
		inversion=0;

		for(i=0;i<nbHgtFound-1;i++)
		{
			if (bestHGTRed[i].crit.RF>bestHGTRed[i+1].crit.RF)
			{
				tmp = bestHGTRed[i];
				bestHGTRed[i] = bestHGTRed[i+1];
				bestHGTRed[i+1] = tmp;
				inversion=1;
			}
		}
	}
	while(inversion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, -0x30(%rbp)
cmpl $0x2, %esi
jl 0x71cf
movq %rdi, %r14
movq -0x30(%rbp), %rax
decl %eax
movl %eax, %eax
imulq $0xa8, %rax, %rdx
movq %rdx, -0x38(%rbp)
xorl %r15d, %r15d
xorl %eax, %eax
movl 0x50(%r14,%r15), %ecx
cmpl 0xf8(%r14,%r15), %ecx
jle 0x71b9
leaq (%r14,%r15), %r12
leaq (%r14,%r15), %r13
addq $0xa8, %r13
movl $0xa8, %edx
leaq -0xe0(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1080
movl $0xa8, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1080
movl $0xa8, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1080
movq -0x38(%rbp), %rdx
movl $0x1, %eax
addq $0xa8, %r15
cmpq %r15, %rdx
jne 0x715b
testl %eax, %eax
je 0x71cf
cmpl $0x1, -0x30(%rbp)
jg 0x7156
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: ListeSommets_taille_0(double**, int*, int)
void ListeSommets_taille_0(double ** matrix,int * tab_sommet,int size){
	
	int cpt=1;
	int cpt_init;
	int nouveau_cas=0;
	
	//== recherche du premier element admissible
	while(cpt <= size){
		if(tab_sommet[cpt] == 0)
			break;
		else
			cpt++;
	}
	
	if(cpt < size){
		//== recherche des distances nulles
		cpt_init = cpt++;
		while(cpt <= size){
			if(matrix[cpt_init][cpt] < epsilon ){
				tab_sommet[cpt] = 1;
				nouveau_cas = 1;
			}		
			cpt++;
		}
		if(nouveau_cas == 1){
			tab_sommet[cpt_init] = 1;
		}
		else
			tab_sommet[cpt_init] = 2;
	}
	else
		tab_sommet[0] = TRUE; //== aucun elements trouves
}

// Assembly:
testl %edx, %edx
jle 0x7360
leal 0x1(%rdx), %eax
movl $0x1, %ecx
cmpl $0x0, (%rsi,%rcx,4)
je 0x7367
incq %rcx
cmpq %rcx, %rax
jne 0x7350
jmp 0x7369
movl $0x1, %eax
jmp 0x7369
movl %ecx, %eax
cmpl %edx, %eax
jge 0x73c6
pushq %rbp
movq %rsp, %rbp
movl %eax, %eax
movq (%rdi,%rax,8), %rdi
leaq (%rsi,%rax,4), %rcx
addq $0x4, %rcx
leaq (%rdi,%rax,8), %rdi
addq $0x8, %rdi
xorl %r8d, %r8d
movsd 0xdc96(%rip), %xmm0     # 0x15028
xorl %r9d, %r9d
ucomisd (%rdi,%r8,8), %xmm0
jbe 0x73ab
movl $0x1, (%rcx,%r8,4)
movl $0x1, %r9d
incq %r8
leal (%rax,%r8), %r10d
cmpl %edx, %r10d
jl 0x7395
cmpl $0x1, %r9d
popq %rbp
jne 0x73cd
movl $0x1, (%rsi,%rax,4)
retq
movl $0x1, (%rsi)
retq
movl $0x2, (%rsi,%rax,4)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: Est_un_sous_ensemble_exact(int*, int*)
int Est_un_sous_ensemble_exact(int * sous_ensemble,int * ensemble){
	
	int temoin;
	
	if(sous_ensemble[0] > ensemble[0]){
		return 0;
	}
	else{
		temoin=0;
		for(int i=1;i<=sous_ensemble[0];i++){
			for(int j=1;j<=ensemble[0];j++){
				if(sous_ensemble[i] == ensemble[j]){
					temoin++;
				}
			}
		}
		if(temoin == sous_ensemble[0]) return 1;
	}
	return 0;
}

// Assembly:
movl (%rdi), %ecx
movl (%rsi), %edx
xorl %eax, %eax
cmpl %edx, %ecx
jg 0x7436
testl %ecx, %ecx
jle 0x742b
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leal 0x1(%rdx), %eax
leaq 0x1(%rcx), %r9
xorl %r8d, %r8d
movl $0x1, %r10d
testl %edx, %edx
jle 0x741d
movl (%rdi,%r10,4), %r11d
movl $0x1, %ebx
xorl %r14d, %r14d
cmpl (%rsi,%rbx,4), %r11d
sete %r14b
addl %r14d, %r8d
incq %rbx
cmpq %rbx, %rax
jne 0x7407
incq %r10
cmpq %r9, %r10
jne 0x73fa
popq %rbx
popq %r14
popq %rbp
jmp 0x742e
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %ecx, %r8d
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: ListesBranchesPourHGT(int*, long*, int, DescTree*, int*, int*)
void ListesBranchesPourHGT(int *tab_sommets,long int * ARETE, int taille,struct DescTree *DT,int *tab_branches,int *nb_branches){
	
	(*nb_branches) = 0;
	for(int i=1;i<=2*taille-3;i++){
		DT[ARETE[2*i-1]].Tableau[0] = DT[ARETE[2*i-1]].nbSommet;
		DT[ARETE[2*i-2]].Tableau[0] = DT[ARETE[2*i-2]].nbSommet;
		
		if( ((Est_un_sous_ensemble_exact(DT[ARETE[2*i-1]].Tableau,tab_sommets)==1) || (Est_un_sous_ensemble_exact(DT[ARETE[2*i-2]].Tableau,tab_sommets)==1)) ||
		    ((Est_un_sous_ensemble_exact(DT[ARETE[2*i-2]].Tableau,tab_sommets)==1) || (Est_un_sous_ensemble_exact(DT[ARETE[2*i-1]].Tableau,tab_sommets)==1)) ){
			(*nb_branches) ++;
			
			tab_branches[(*nb_branches)] = i;
					
		}	
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %r9, -0x40(%rbp)
movl $0x0, (%r9)
cmpl $0x2, %edx
jl 0x74f7
movq %rcx, %r15
movq %rsi, %r12
leal -0x3(,%rdx,2), %eax
cmpl $0x2, %eax
movl $0x1, %r14d
cmovll %r14d, %eax
shlq $0x4, %rax
movq %rax, -0x48(%rbp)
xorl %r13d, %r13d
movq 0x8(%r12,%r13), %rax
leaq (%rax,%rax,2), %rax
movl (%r15,%rax,8), %ecx
movq 0x10(%r15,%rax,8), %rdx
movl %ecx, (%rdx)
movq (%r12,%r13), %rcx
leaq (%rcx,%rcx,2), %rbx
movl (%r15,%rbx,8), %ecx
movq 0x10(%r15,%rbx,8), %rdx
movl %ecx, (%rdx)
movq 0x10(%r15,%rax,8), %rdi
movq -0x30(%rbp), %rsi
callq 0x73d5
testl %eax, %eax
jne 0x74d4
movq 0x10(%r15,%rbx,8), %rdi
movq -0x30(%rbp), %rsi
callq 0x73d5
testl %eax, %eax
je 0x74ea
movq -0x40(%rbp), %rdx
movslq (%rdx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%rdx)
movq -0x38(%rbp), %rcx
movl %r14d, 0x4(%rcx,%rax,4)
addq $0x10, %r13
incl %r14d
cmpq %r13, -0x48(%rbp)
jne 0x7489
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: deleteBipartition(DescTree*, InputTree)
void deleteBipartition(DescTree *DT,InputTree aTree){
	int i,j,k;
	for(i=1;i<=2*aTree.size-2-aTree.kt;i++){
		if(i!=aTree.size){
			for(j=0;j<=DT[i].nbSommet+1;j++)
				free(DT[i].Matrice[j]);
			free(DT[i].Matrice);
		}
		free(DT[i].Tableau);
	}
	free(DT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movl 0x10(%rbp), %r14d
movl 0x58(%rbp), %eax
leal (%r14,%r14), %r15d
movl %r15d, %ecx
subl %eax, %ecx
addl $-0x2, %ecx
testl %ecx, %ecx
jle 0x7af6
notl %eax
addl %eax, %r15d
movl $0x1, %r12d
movq %r15, -0x30(%rbp)
cmpq %r14, %r12
je 0x7ae0
movq %r14, %r15
leaq (%r12,%r12,2), %rax
movq %r13, %rbx
leaq (%r13,%rax,8), %r13
cmpl $-0x1, (%r13)
jl 0x7acd
movq $-0x1, %r14
movq 0x8(%r13), %rax
movq 0x8(%rax,%r14,8), %rdi
callq 0x1100
movslq (%r13), %rax
incq %r14
cmpq %rax, %r14
jle 0x7ab3
movq 0x8(%r13), %rdi
callq 0x1100
movq %r15, %r14
movq -0x30(%rbp), %r15
movq %rbx, %r13
leaq (%r12,%r12,2), %rax
movq 0x10(%r13,%rax,8), %rdi
callq 0x1100
incq %r12
cmpq %r15, %r12
jne 0x7a91
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: PrintHeader(_IO_FILE*, Parameters)
void PrintHeader(FILE *out,Parameters param){
	char criterion[50];
	if(strcmp(param.criterion,"rf")==0)
		strcpy(criterion,"Robinson and Foulds distance");
	if(strcmp(param.criterion,"ls")==0)
		strcpy(criterion,"least-squares");
	if(strcmp(param.criterion,"bd")==0)
		strcpy(criterion,"bipartition dissimilarity");
	if(strcmp(param.criterion,"qd")==0)
		strcpy(criterion,"quartet distance");

	fprintf(out,"%s",description);
	fprintf(out,"\n");
	//fprintf(out,"\nScenario             :%s",param.scenario);
	fprintf(out,"\nSubtree constraint   :%s",param.subtree);
	fprintf(out,"\nCriterion            :%s",criterion);
	fprintf(out,"\nBootstrap            :%s",param.bootstrap);
	fprintf(out,"\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movl $0x6672, %eax           # imm = 0x6672
xorl 0x3fc(%r14), %eax
movzbl 0x3fe(%r14), %ecx
orw %ax, %cx
jne 0x7b4d
movups 0xdd37(%rip), %xmm0     # 0x15875
movups %xmm0, -0x43(%rbp)
movups 0xdd1f(%rip), %xmm0     # 0x15868
movaps %xmm0, -0x50(%rbp)
movzwl 0x3fc(%r14), %eax
xorl $0x736c, %eax           # imm = 0x736C
movzbl 0x3fe(%r14), %ecx
orw %ax, %cx
jne 0x7b83
movabsq $0x73657261757173, %rax # imm = 0x73657261757173
movq %rax, -0x4a(%rbp)
movabsq $0x71732d747361656c, %rax # imm = 0x71732D747361656C
movq %rax, -0x50(%rbp)
movzwl 0x3fc(%r14), %eax
xorl $0x6462, %eax           # imm = 0x6462
movzbl 0x3fe(%r14), %ecx
orw %ax, %cx
jne 0x7bb3
movups 0xdcfc(%rip), %xmm0     # 0x158a0
movups %xmm0, -0x46(%rbp)
movups 0xdce7(%rip), %xmm0     # 0x15896
movaps %xmm0, -0x50(%rbp)
movzwl 0x3fc(%r14), %eax
xorl $0x6471, %eax           # imm = 0x6471
movzbl 0x3fe(%r14), %ecx
orw %ax, %cx
jne 0x7bdc
movups 0xdcdf(%rip), %xmm0     # 0x158b3
movaps %xmm0, -0x50(%rbp)
movb $0x0, -0x40(%rbp)
movq 0x12545(%rip), %rdi     # 0x1a128
movq %rbx, %rsi
callq 0x10c0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1130
leaq 0xe9e(%r14), %rdx
leaq 0xdcbe(%rip), %rsi      # 0x158c4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1180
leaq 0xdcc7(%rip), %rsi      # 0x158de
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1180
addq $0xf0c, %r14            # imm = 0xF0C
leaq 0xdcc5(%rip), %rsi      # 0x158f8
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1180
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1130
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: initInputTree(InputTree*)
void initInputTree(struct InputTree *aTree){
	aTree->Adjacence = NULL;
	aTree->ARETE = NULL;
	aTree->LONGUEUR = NULL;
	aTree->ADD = NULL;
	aTree->Root = -1;
	aTree->size = -1;
	aTree->SpeciesName = NULL;
	aTree->Input = NULL;
	aTree->kt = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x20(%rdi)
movl %eax, (%rdi)
movl $0x0, 0x48(%rdi)
movups %xmm0, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printRoot(char*, int, int)
void printRoot(char *fichier, int R1, int R2){
	
	FILE *out;
	
	if((out=fopen(fichier,"w+"))==NULL){
		printf("\nCan't open root file (%s)",fichier);
		exit(-1);
	}
	fprintf(out,"%d %d",R1,R2);
	fclose(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0xdaf9(%rip), %rsi      # 0x15795
callq 0x10e0
testq %rax, %rax
je 0x7ccf
movq %rax, %r12
leaq 0xee7f(%rip), %rsi      # 0x16b2f
movq %rax, %rdi
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1180
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
leaq 0xdc3c(%rip), %rdi      # 0x15912
movq %r15, %rsi
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printRootByLeaves(char*, int, InputTree*)
void printRootByLeaves(char *fichier,int choix,struct InputTree *aTree){

	FILE *out;
	int i;
	if((out=fopen(fichier,"w+"))==NULL){
		printf("\nCan't open root file (%s)",fichier);
		exit(-1);
	}
	
	for(i=1;i<=aTree->size;i++)
		if(aTree->ADD[i][aTree->ARETE[2*choix-1]] < aTree->ADD[i][aTree->ARETE[2*choix-2]])
			fprintf(out,"%s ",aTree->SpeciesName[i]);
	
	fprintf(out,"\n<>\n");
	
	for(i=1;i<=aTree->size;i++)
		if(aTree->ADD[i][aTree->ARETE[2*choix-1]] > aTree->ADD[i][aTree->ARETE[2*choix-2]])
			fprintf(out,"%s ",aTree->SpeciesName[i]);
	
	fclose(out);
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, -0x30(%rbp)
movq %rdi, %r12
leaq 0xda8c(%rip), %rsi      # 0x15795
callq 0x10e0
testq %rax, %rax
je 0x7e01
movq %rax, %r14
cmpl $0x0, (%rbx)
jle 0x7d76
movq -0x30(%rbp), %rax
addl %eax, %eax
movslq %eax, %r13
leaq 0xdbfe(%rip), %r12      # 0x1592d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rcx
movq 0x8(%rax,%r15,8), %rax
movq -0x10(%rcx,%r13,8), %rdx
movq -0x8(%rcx,%r13,8), %rcx
movsd (%rax,%rdx,8), %xmm0
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x7d6b
movq 0x18(%rbx), %rax
movq 0x8(%rax,%r15,8), %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1180
movslq (%rbx), %rax
incq %r15
cmpq %rax, %r15
jl 0x7d32
leaq 0xdbb4(%rip), %rdi      # 0x15931
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x11f0
cmpl $0x0, (%rbx)
jle 0x7deb
movq -0x30(%rbp), %rax
addl %eax, %eax
movslq %eax, %r12
leaq 0xdb89(%rip), %r15      # 0x1592d
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rcx
movq 0x8(%rax,%r13,8), %rax
movq -0x10(%rcx,%r12,8), %rdx
movq -0x8(%rcx,%r12,8), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd (%rax,%rdx,8), %xmm0
jbe 0x7de0
movq 0x18(%rbx), %rax
movq 0x8(%rax,%r13,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1180
movslq (%rbx), %rax
incq %r13
cmpq %rax, %r13
jl 0x7da7
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
leaq 0xdb0a(%rip), %rdi      # 0x15912
movq %r12, %rsi
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: allocMemmory(InputTree*, int)
void allocMemmory(struct InputTree *aTree, int n){
	
	int i;

	if(aTree->ARETE == NULL){
		aTree->degre = (int*)malloc(2*n*sizeof(int));
		aTree->ADD = (double**)malloc(2*n*sizeof(double*));
		aTree->Adjacence = (double**)malloc(2*n*sizeof(double*));
		aTree->Input = (double**)malloc(2*n*sizeof(double*));
		aTree->W = (double**)malloc((n+1)*sizeof(double*));
		
		for(i=0;i<2*n;i++){
			aTree->ADD[i] = (double*)malloc(2*n*sizeof(double));
			aTree->Adjacence[i] = (double*)malloc(2*n*sizeof(double));
			aTree->Input[i] = (double*)malloc(2*n*sizeof(double));
			if(i<=n)
				aTree->W[i] = (double*)malloc(2*n*sizeof(double));
		}

		aTree->ARETE    =(long int*)malloc(4*(2*(n))*sizeof(long int));
		aTree->LONGUEUR	=(double*)malloc((4*(n))*sizeof(double));
		aTree->SpeciesName = (char**)malloc(2*n*sizeof(char*));
		
		for(i=0;i<=n;i++)
			aTree->SpeciesName[i] = (char*)malloc(50);
	}

}

// Assembly:
cmpq $0x0, 0x30(%rdi)
je 0x7e24
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leal (%rbx,%rbx), %r13d
movslq %r13d, %r15
leaq (,%r15,4), %rdi
callq 0x1140
movq %rax, 0x50(%r14)
shlq $0x3, %r15
movq %r15, %rdi
callq 0x1140
movq %rax, 0x8(%r14)
movq %r15, %rdi
callq 0x1140
movq %rax, 0x28(%r14)
movq %r15, %rdi
callq 0x1140
movq %rax, 0x10(%r14)
movq %rbx, -0x30(%rbp)
movslq %ebx, %rbx
leaq 0x8(,%rbx,8), %rdi
callq 0x1140
movq %rax, 0x40(%r14)
testl %ebx, %ebx
jle 0x7ef7
movl -0x30(%rbp), %r12d
cmpl $0x2, %r13d
movl %r13d, %eax
movl $0x1, %r13d
cmovgel %eax, %r13d
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x1140
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq %r15, %rdi
callq 0x1140
movq 0x28(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
movq %r15, %rdi
callq 0x1140
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
cmpq %r12, %rbx
ja 0x7eef
movq %r15, %rdi
callq 0x1140
movq 0x40(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq %rbx, %r13
jne 0x7eaa
movq -0x30(%rbp), %r12
leal (,%r12,8), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x30(%r14)
leal (,%r12,4), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x38(%r14)
movq %r15, %rdi
callq 0x1140
movq %rax, 0x18(%r14)
testl %r12d, %r12d
js 0x7f5b
incl %r12d
xorl %ebx, %ebx
movl $0x32, %edi
callq 0x1140
movq 0x18(%r14), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq %rbx, %r12
jne 0x7f41
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: freeReducedTree(InputTree*, int)
void freeReducedTree(struct InputTree *aTree,int n){
	int i,j;
	
	for(i=0;i<2*n;i++){
		free(aTree->ADD[i]);
		free(aTree->Adjacence[i]);
		free(aTree->Input[i]);
		free(aTree->W[i]);
		free(aTree->SpeciesName[i]);
	}
	free(aTree->ADD);
	free(aTree->Adjacence);
	free(aTree->Input);
	free(aTree->W);
	free(aTree->ARETE);
	free(aTree->SpeciesName);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x7fd6
addl %esi, %esi
cmpl $0x2, %esi
movl $0x1, %r14d
cmovgel %esi, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
cmpq %r15, %r14
jne 0x7f8d
movq 0x8(%rbx), %rdi
callq 0x1100
movq 0x28(%rbx), %rdi
callq 0x1100
movq 0x10(%rbx), %rdi
callq 0x1100
movq 0x40(%rbx), %rdi
callq 0x1100
movq 0x30(%rbx), %rdi
callq 0x1100
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: loadCriteria(CRITERIA, HGT*)
void loadCriteria(struct CRITERIA aCrit, struct HGT *aHGT){

	aHGT->crit.LS = aCrit.LS;
	aHGT->crit.RF = aCrit.RF;
	aHGT->crit.BD = aCrit.BD;
	aHGT->crit.QD = aCrit.QD;
	aHGT->valide = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x10(%rbp), %xmm0
movsd %xmm0, 0x20(%rdi)
movl 0x40(%rbp), %eax
movl %eax, 0x50(%rdi)
movsd 0x20(%rbp), %xmm0
movsd %xmm0, 0x30(%rdi)
movl 0x44(%rbp), %eax
movl %eax, 0x54(%rdi)
movl $0x1, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: computeCriteria(double**, double**, int, CRITERIA*, double*, long*, double*, long*)
void computeCriteria(double ** Matrix1, double ** Matrix2, int size,struct CRITERIA *aCrit,double *L1, long int *A1,double *L2, long int *A2){

	int mI,m,i,j,RF,QD;
	double LS,BD=0;

	//= robinson and foulds
	m=Bipartition_Table(Matrix1,aCrit->B,aCrit->PLACE,size);
	mI=Bipartition_Table(Matrix2,aCrit->BI,aCrit->PLACEI,size);
	RF = Table_Comparaison(aCrit->B,aCrit->BI,aCrit->PLACE,aCrit->PLACEI,m,mI,size); 

	//= least-squares
	LS = 0.0;
	for (i=1;i<=size-1;i++)
	{
		for (j=i+1;j<=size;j++){
			LS=LS + (Matrix1[i][j]-Matrix2[i][j])*(Matrix1[i][j]-Matrix2[i][j]);
		}
	}

	//= Bipartition Distance
	BD = BipartitionDistance(aCrit->B,aCrit->BI,size);
	
	aCrit->LS = LS;
	aCrit->BD = BD;
	aCrit->RF = RF;
	aCrit->QD = QD;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movq 0x40(%rcx), %rsi
movq 0x50(%rcx), %rdx
movl %r14d, %ecx
callq 0x2bcf
movl %eax, %r13d
movq 0x48(%rbx), %rsi
movq 0x58(%rbx), %rdx
movq %r15, %rdi
movl %r14d, %ecx
callq 0x2bcf
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq 0x58(%rbx), %rcx
movl %r14d, (%rsp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movl %r13d, %r8d
movl %eax, %r9d
callq 0x3238
movl %eax, %r13d
xorpd %xmm1, %xmm1
cmpl $0x2, %r14d
jl 0x8e46
leal 0x1(%r14), %eax
movl %r14d, %ecx
movl $0x1, %esi
xorl %edx, %edx
movq (%r15,%rsi,8), %rdi
movq (%r12,%rsi,8), %r8
incq %rsi
addq %rdx, %rdi
addq %rdx, %r8
movl $0x2, %r9d
movsd (%r8,%r9,8), %xmm0
subsd (%rdi,%r9,8), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %r9
cmpq %r9, %rax
jne 0x8e1e
addq $0x8, %rdx
decq %rax
cmpq %rcx, %rsi
jne 0x8e07
movsd %xmm1, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %r14d, %edx
callq 0x12fc
movsd -0x30(%rbp), %xmm1
movsd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
movl %r13d, 0x30(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: findListSpecies(HGT*, DescTree*, InputTree)
void findListSpecies(struct HGT *bestHGT, struct DescTree *DTSpecies,struct InputTree aTree){

	int source,dest,i;
//	exit(0);

  //printf("\n%d-%d",bestHGT->source,aTree.Root);
	//== find the node inf for the source branch
	if(aTree.ADD[aTree.ARETE[2*(bestHGT->source)-1]][aTree.Root] <  aTree.ADD[aTree.ARETE[2*(bestHGT->source)-2]][aTree.Root])
		source = aTree.ARETE[2*(bestHGT->source)-2];
	else
		source = aTree.ARETE[2*(bestHGT->source)-1];

	//== find the node inf for the dest branch
	if(aTree.ADD[aTree.ARETE[2*(bestHGT->destination)-1]][aTree.Root] <  aTree.ADD[aTree.ARETE[2*(bestHGT->destination)-2]][aTree.Root])
		dest = aTree.ARETE[2*(bestHGT->destination)-2];
	else
		dest = aTree.ARETE[2*(bestHGT->destination)-1];
	
	if(bestHGT->listSource != NULL)
		free(bestHGT->listSource);
	bestHGT->listSource = (int *)malloc((DTSpecies[source].nbSommet+1)*sizeof(int));
	bestHGT->listSource[0] = DTSpecies[source].nbSommet;
	for(i=1;i<=DTSpecies[source].nbSommet;i++) bestHGT->listSource[i] = DTSpecies[source].Tableau[i];

	if(bestHGT->listDestination != NULL)
		free(bestHGT->listDestination);
	bestHGT->listDestination = (int *)malloc((DTSpecies[dest].nbSommet+1)*sizeof(int));
	bestHGT->listDestination[0] = DTSpecies[dest].nbSommet;
	for(i=1;i<=DTSpecies[dest].nbSommet;i++) bestHGT->listDestination[i] = DTSpecies[dest].Tableau[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rbp), %rax
movq 0x40(%rbp), %rcx
movslq 0x4(%rdi), %rdx
shlq $0x4, %rdx
movq -0x10(%rcx,%rdx), %rdi
movq -0x8(%rcx,%rdx), %r12
movq (%rax,%r12,8), %rdx
movslq 0x30(%rbp), %r8
movq (%rax,%rdi,8), %r9
movsd (%r9,%r8,8), %xmm0
ucomisd (%rdx,%r8,8), %xmm0
cmovaq %rdi, %r12
movslq 0x8(%rbx), %rdx
shlq $0x4, %rdx
movq -0x10(%rcx,%rdx), %rdi
movq -0x8(%rcx,%rdx), %r15
movq (%rax,%r15,8), %rcx
movq (%rax,%rdi,8), %rax
movsd (%rax,%r8,8), %xmm0
ucomisd (%rcx,%r8,8), %xmm0
cmovaq %rdi, %r15
movq %rsi, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa27a
callq 0x1100
movslq %r12d, %rax
leaq (%rax,%rax,2), %r12
movslq (%r14,%r12,8), %r13
leaq 0x4(,%r13,4), %rdi
callq 0x1140
movq %rax, 0x10(%rbx)
movl %r13d, (%rax)
cmpl $0x0, (%r14,%r12,8)
jle 0xa2c7
leaq (%r14,%r12,8), %rdx
movq 0x10(%rdx), %rcx
movl (%rdx), %esi
cmpl $0x2, %esi
movl $0x1, %edx
cmovgel %esi, %edx
xorl %esi, %esi
movl 0x4(%rcx,%rsi,4), %edi
movl %edi, 0x4(%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0xa2b7
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xa2d5
callq 0x1100
movslq %r15d, %rax
leaq (%rax,%rax,2), %r15
movslq (%r14,%r15,8), %r12
leaq 0x4(,%r12,4), %rdi
callq 0x1140
movq %rax, 0x18(%rbx)
movl %r12d, (%rax)
cmpl $0x0, (%r14,%r15,8)
jle 0xa322
leaq (%r14,%r15,8), %rdx
movq 0x10(%rdx), %rcx
movl (%rdx), %esi
cmpl $0x2, %esi
movl $0x1, %edx
cmovgel %esi, %edx
xorl %esi, %esi
movl 0x4(%rcx,%rsi,4), %edi
movl %edi, 0x4(%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0xa312
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: UpdateCriterion(int*, char const*, CRITERIA, HGT*, int, int, int)
void UpdateCriterion(int *first,const char *CRITERION, struct CRITERIA aCrit, struct HGT * aHGT,int i,int j,int flag_bootstrap){

		aHGT->destination = j;
		aHGT->source = i;
		aHGT->crit.BD = aCrit.BD;
		aHGT->crit.LS = aCrit.LS;
		aHGT->crit.RF = aCrit.RF;
		aHGT->crit.QD = aCrit.QD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %r8d, 0x8(%rdx)
movl %ecx, 0x4(%rdx)
movsd 0x20(%rbp), %xmm0
movsd %xmm0, 0x30(%rdx)
movsd 0x10(%rbp), %xmm0
movsd %xmm0, 0x20(%rdx)
movl 0x40(%rbp), %eax
movl %eax, 0x50(%rdx)
movl 0x44(%rbp), %eax
movl %eax, 0x54(%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printLeaves(char*, int, HGT*, int, char**)
void printLeaves(char *fichier,int nbHGT,struct HGT *outHGT,int noTree,char **NomsSpecies){

	FILE *out;
	int i,j;

	out = fopen(fichier,"a+");
/*	fprintf(out,"#detection %d",noTree);
	for(i=1;i<=nbHGT;i++){
		if(outHGT[i].valide == 1) {
			fprintf(out,"\n%d ",outHGT[i].listSource[0]);
			for(j=1;j<=outHGT[i].listSource[0];j++)
				fprintf(out,"%s ",NomsSpecies[outHGT[i].listSource[j]]);
			fprintf(out,"\n%d ",outHGT[i].listDestination[0]);
			for(j=1;j<=outHGT[i].listDestination[0];j++)
				fprintf(out,"%s ",NomsSpecies[outHGT[i].listDestination[j]]);
		}
	}
	fprintf(out,"\n");*/
	for(i=1;i<=nbHGT;i++){
		
		if((outHGT[i].valide == 1) || (outHGT[i].valide == 6)) {
			fprintf(out,"\ndetection %d : ",noTree);
			//fprintf(out,"\n%d ",outHGT[i].listSource[0]);
			for(j=1;j<=outHGT[i].listSource[0];j++){
				fprintf(out,"%s",NomsSpecies[outHGT[i].listSource[j]]);
				if(j<outHGT[i].listSource[0])
					fprintf(out,";");
				else
					fprintf(out," ");
			}
			//fprintf(out,"\n%d ",outHGT[i].listDestination[0]);
			for(j=1;j<=outHGT[i].listDestination[0];j++){
				fprintf(out,"%s",NomsSpecies[outHGT[i].listDestination[j]]);
				if(j<outHGT[i].listDestination[0])
					fprintf(out,";");
			}
		}
	}
	fprintf(out,"\n");
	fclose(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movl %ecx, -0x34(%rbp)
movq %rdx, -0x40(%rbp)
movl %esi, %r14d
leaq 0xae87(%rip), %rsi      # 0x15740
callq 0x10e0
movq %rax, %r13
movq %r14, -0x30(%rbp)
testl %r14d, %r14d
jle 0xa9c8
movq -0x30(%rbp), %rax
incl %eax
movq %rax, -0x30(%rbp)
movl $0x1, %r14d
imulq $0xa8, %r14, %r15
movq -0x40(%rbp), %rax
movl (%rax,%r15), %eax
cmpl $0x6, %eax
je 0xa8fb
cmpl $0x1, %eax
jne 0xa9bb
movq %r14, -0x48(%rbp)
addq -0x40(%rbp), %r15
movq %r13, %rdi
leaq 0xb06e(%rip), %rsi      # 0x1597b
movl -0x34(%rbp), %edx
xorl %eax, %eax
callq 0x1180
movq 0x10(%r15), %rax
cmpl $0x0, (%rax)
movl $0x3b, %r14d
jle 0xa96b
movl $0x1, %r12d
movslq (%rax,%r12,4), %rax
movq (%rbx,%rax,8), %rdi
movq %r13, %rsi
callq 0x10c0
movq 0x10(%r15), %rax
movslq (%rax), %rax
cmpq %rax, %r12
movl $0x20, %edi
cmovll %r14d, %edi
movq %r13, %rsi
callq 0x1130
leaq 0x1(%r12), %rcx
movq 0x10(%r15), %rax
movslq (%rax), %rdx
cmpq %rdx, %r12
movq %rcx, %r12
jl 0xa92c
movq 0x18(%r15), %rax
cmpl $0x0, (%rax)
movq -0x48(%rbp), %r14
jle 0xa9bb
movl $0x1, %r12d
movslq (%rax,%r12,4), %rax
movq (%rbx,%rax,8), %rdi
movq %r13, %rsi
callq 0x10c0
movq 0x18(%r15), %rax
movslq (%rax), %rax
cmpq %rax, %r12
jge 0xa9a7
movl $0x3b, %edi
movq %r13, %rsi
callq 0x1130
leaq 0x1(%r12), %rcx
movq 0x18(%r15), %rax
movslq (%rax), %rdx
cmpq %rdx, %r12
movq %rcx, %r12
jl 0xa97e
incq %r14
cmpq -0x30(%rbp), %r14
jne 0xa8de
movl $0xa, %edi
movq %r13, %rsi
callq 0x1130
movq %r13, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: sameHGT(HGT, HGT)
int sameHGT(struct HGT HGT1, struct HGT HGT2){
	int i;

	if(HGT1.listSource[0] == HGT2.listSource[0] && HGT1.listDestination[0] == HGT2.listDestination[0]){
		
		for(i=1;i<=HGT1.listSource[0];i++){
			if(HGT1.listSource[i] != HGT2.listSource[i])
				return 0;
		}
		for(i=1;i<=HGT1.listDestination[0];i++){
			if(HGT1.listDestination[i] != HGT2.listDestination[i])
				return 0;
		}
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rbp), %rdi
movl (%rdi), %r8d
movq 0xc8(%rbp), %r9
xorl %eax, %eax
cmpl (%r9), %r8d
jne 0xaa60
leaq 0xb8(%rbp), %rsi
leaq 0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl (%rcx), %edx
movq 0x18(%rsi), %rsi
cmpl (%rsi), %edx
jne 0xaa60
testl %r8d, %r8d
jle 0xaa3d
incq %r8
movl $0x1, %r10d
movl (%rdi,%r10,4), %r11d
cmpl (%r9,%r10,4), %r11d
jne 0xaa60
incq %r10
cmpq %r10, %r8
jne 0xaa2b
testl %edx, %edx
jle 0xaa5b
incq %rdx
movl $0x1, %edi
movl (%rcx,%rdi,4), %r8d
cmpl (%rsi,%rdi,4), %r8d
jne 0xaa60
incq %rdi
cmpq %rdi, %rdx
jne 0xaa49
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: sameHGT2(HGT, HGT)
int sameHGT2(struct HGT HGT1, struct HGT HGT2){
	int i,h1=0,h2=0;

	if(HGT1.listSource[0] == HGT2.listSource[0]){ 
		h1 = 1;
		for(i=1;i<=HGT1.listSource[0];i++){
			if(HGT1.listSource[i] != HGT2.listSource[i])
				h1=0;
		}
	}

	if(HGT1.listDestination[0] == HGT2.listDestination[0]){
		h2=1;
		for(i=1;i<=HGT1.listDestination[0];i++){
			if(HGT1.listDestination[i] != HGT2.listDestination[i])
				h2 = 0;
		}
	}

	if(h2 == 1 && h1 == 1) return 1;


	if(HGT1.listSource[0] == HGT2.listDestination[0]){ 
		h1=1;
		for(i=1;i<=HGT1.listSource[0];i++){
			if(HGT1.listSource[i] != HGT2.listDestination[i])
				h1=0;
		}
	}

	if(HGT1.listDestination[0] == HGT2.listSource[0]){
		h2=1;
		for(i=1;i<=HGT1.listDestination[0];i++){
			if(HGT1.listDestination[i] != HGT2.listSource[i])
				h2 = 0;
		}
	}

	if(h2 == 1 && h1 == 1) return 1;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xb8(%rbp), %rax
leaq 0x10(%rbp), %r10
movq 0x10(%r10), %r8
movl (%r8), %r9d
movq 0x10(%rax), %rcx
movl (%rcx), %edi
xorl %edx, %edx
movl $0x0, %esi
cmpl %edi, %r9d
jne 0xaac4
testl %r9d, %r9d
jle 0xaabf
leaq 0x1(%r9), %r11
movl $0x1, %esi
movl $0x1, %ebx
xorl %r14d, %r14d
movl (%r8,%rbx,4), %r15d
cmpl (%rcx,%rbx,4), %r15d
cmovnel %r14d, %esi
incq %rbx
cmpq %rbx, %r11
jne 0xaaa9
jmp 0xaac4
movl $0x1, %esi
movq 0x18(%r10), %r10
movl (%r10), %r11d
movq 0x18(%rax), %rbx
movl (%rbx), %r14d
cmpl %r14d, %r11d
jne 0xab09
testl %r11d, %r11d
jle 0xab04
leaq 0x1(%r11), %rax
movl $0x1, %edx
movl $0x1, %r15d
xorl %r12d, %r12d
movl (%r10,%r15,4), %r13d
cmpl (%rbx,%r15,4), %r13d
cmovnel %r12d, %edx
incq %r15
cmpq %r15, %rax
jne 0xaaee
jmp 0xab09
movl $0x1, %edx
cmpl $0x1, %edx
jne 0xab18
movl $0x1, %eax
cmpl $0x1, %esi
je 0xab8d
cmpl %r14d, %r9d
jne 0xab4d
testl %r9d, %r9d
jle 0xab48
incl %r9d
movl $0x1, %esi
movl $0x1, %eax
xorl %r14d, %r14d
movl (%r8,%rax,4), %r15d
cmpl (%rbx,%rax,4), %r15d
cmovnel %r14d, %esi
incq %rax
cmpq %rax, %r9
jne 0xab32
jmp 0xab4d
movl $0x1, %esi
cmpl %edi, %r11d
jne 0xab80
testl %r11d, %r11d
jle 0xab7b
incl %r11d
movl $0x1, %edx
movl $0x1, %eax
xorl %edi, %edi
movl (%r10,%rax,4), %r8d
cmpl (%rcx,%rax,4), %r8d
cmovnel %edi, %edx
incq %rax
cmpq %rax, %r11
jne 0xab66
jmp 0xab80
movl $0x1, %edx
xorl $0x1, %edx
xorl $0x1, %esi
xorl %eax, %eax
orl %edx, %esi
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: copyHGT(HGT, HGT*)
void copyHGT(struct HGT source,struct HGT *dest){
	int j;
	dest->trivial = source.trivial;
	dest->valide = source.valide;
	dest->source_A = source.source_A;
	dest->source_B = source.source_B;
	dest->dest_A = source.dest_A;
	dest->dest_B = source.dest_B;
	dest->crit.LS = source.crit.LS;
	dest->crit.RF = source.crit.RF;
	dest->crit.BD = source.crit.BD;
	dest->crit.rLS = source.crit.rLS;
	dest->crit.rRF = source.crit.rRF;
	dest->crit.rBD = source.crit.rBD;
	dest->crit.QD = source.crit.QD;
	dest->listSource = (int*) malloc((source.listSource[0]+1)*sizeof(int));
	dest->listDestination = (int*) malloc((source.listDestination[0]+1)*sizeof(int));
	dest->listSource[0] = source.listSource[0];
	for(j=1;j<=dest->listSource[0];j++){
		dest->listSource[j] = source.listSource[j];
	}
	dest->listDestination[0] = source.listDestination[0];
	for(j=1;j<=dest->listDestination[0];j++){
		dest->listDestination[j] = source.listDestination[j];
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xa0(%rbp), %eax
movl %eax, 0x90(%rdi)
movl 0x10(%rbp), %eax
movl %eax, (%rdi)
movl 0x90(%rbp), %eax
movl %eax, 0x80(%rdi)
movl 0x94(%rbp), %eax
movl %eax, 0x84(%rdi)
movl 0x98(%rbp), %eax
movl %eax, 0x88(%rdi)
movl 0x9c(%rbp), %eax
movl %eax, 0x8c(%rdi)
movsd 0x30(%rbp), %xmm0
movsd %xmm0, 0x20(%rdi)
movl 0x60(%rbp), %eax
movl %eax, 0x50(%rdi)
movsd 0x40(%rbp), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x38(%rbp), %xmm0
movsd %xmm0, 0x28(%rdi)
movl 0x50(%rbp), %eax
movl %eax, 0x40(%rdi)
movsd 0x48(%rbp), %xmm0
movsd %xmm0, 0x38(%rdi)
movl 0x64(%rbp), %eax
movl %eax, 0x54(%rdi)
movq 0x20(%rbp), %r12
movslq (%r12), %r13
leaq 0x4(,%r13,4), %rdi
callq 0x1140
movq %rax, %r14
movq %rax, 0x10(%rbx)
movq 0x28(%rbp), %r15
movslq (%r15), %rax
leaq 0x4(,%rax,4), %rdi
callq 0x1140
movq %rax, 0x18(%rbx)
movl %r13d, (%r14)
testq %r13, %r13
jle 0xac7b
movl %r13d, %ecx
incq %rcx
movl $0x1, %edx
movl (%r12,%rdx,4), %esi
movl %esi, (%r14,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0xac6b
movl (%r15), %ecx
movl %ecx, (%rax)
testl %ecx, %ecx
jle 0xac9b
incq %rcx
movl $0x1, %edx
movl (%r15,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0xac8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: updateBootHGT(int, HGT*, int, HGT*, int*, double*)
void updateBootHGT(int first,struct HGT *bestHGT,int cpt_hgt,struct HGT *bootHGT, int *nbHGT_boot, double *tabBoot){
	
	int i,cpt=0,j;

	if(first==1){
		for(i=1;i<=cpt_hgt;i++){
			if((bestHGT[i].valide == 1) || (bestHGT[i].valide == 6)){
				cpt++;
				tabBoot[cpt] = 1;
				copyHGT(bestHGT[i],&bootHGT[cpt]);
			}
		}
		(*nbHGT_boot) = cpt;
	}
	else{
		for(i=1;i<=(*nbHGT_boot);i++){
			for(j=1;j<=cpt_hgt;j++){
				if((bestHGT[j].valide == 1) || (bestHGT[i].valide == 6))
					if (sameHGT(bootHGT[i],bestHGT[j])==1)
						tabBoot[i]+=1;
			}
		}
	}
	


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, -0x38(%rbp)
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r15
cmpl $0x1, %edi
jne 0xad3f
testl %edx, %edx
jle 0xae2e
movl %edx, %r12d
addq $0xa8, %r15
xorl %r13d, %r13d
movl (%r15), %eax
cmpl $0x6, %eax
je 0xacf2
cmpl $0x1, %eax
jne 0xad2e
movslq %r13d, %rax
incl %r13d
movq -0x38(%rbp), %rcx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rdx, 0x8(%rcx,%rax,8)
incq %rax
imulq $0xa8, %rax, %rax
addq %rbx, %rax
movl $0x15, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0xab98
addq $0xa8, %r15
decq %r12
jne 0xace5
jmp 0xae31
movq %rbx, -0x40(%rbp)
movl (%r14), %eax
movq %rax, -0x30(%rbp)
testl %eax, %eax
jle 0xae34
leal 0x1(%rdx), %ecx
incq -0x30(%rbp)
movl $0x1, %esi
movsd 0xa302(%rip), %xmm0     # 0x15068
movq %rdx, -0x48(%rbp)
testl %edx, %edx
jle 0xae1b
imulq $0xa8, %rsi, %rdi
leaq (%r15,%rdi), %r8
addq -0x40(%rbp), %rdi
movl $0x1, %r9d
imulq $0xa8, %r9, %r11
cmpl $0x1, (%r15,%r11)
je 0xad9b
cmpl $0x6, (%r8)
jne 0xae0f
addq %r15, %r11
movq 0x10(%rdi), %r13
movq 0x10(%r11), %r14
movl (%r13), %eax
cmpl (%r14), %eax
jne 0xae0f
movq 0x18(%rdi), %r10
movq 0x18(%r11), %r11
movl (%r10), %r12d
cmpl (%r11), %r12d
jne 0xae0f
testl %eax, %eax
jle 0xadde
incq %rax
movl $0x1, %edx
movl (%r13,%rdx,4), %ebx
cmpl (%r14,%rdx,4), %ebx
jne 0xae0f
incq %rdx
cmpq %rdx, %rax
jne 0xadcb
testl %r12d, %r12d
jle 0xadfd
incq %r12
movl $0x1, %eax
movl (%r10,%rax,4), %edx
cmpl (%r11,%rax,4), %edx
jne 0xae0f
incq %rax
cmpq %rax, %r12
jne 0xadeb
movq -0x38(%rbp), %rax
movsd (%rax,%rsi,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rsi,8)
incq %r9
cmpq %rcx, %r9
jne 0xad87
incq %rsi
cmpq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
jne 0xad6a
jmp 0xae34
xorl %r13d, %r13d
movl %r13d, (%r14)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: FreeMemory_InputTreeReduced(InputTree*, int)
void FreeMemory_InputTreeReduced(struct InputTree *aTree,int size){
	
	int i;
	int n=size;
	
	if(aTree->ADD != NULL){
	
		free(aTree->LONGUEUR);
		free(aTree->ARETE);

		for(i=0;i<2*aTree->size-1;i++){
			free(aTree->ADD[i]);
			//free(aTree->Adjacence[i]);
			//free(aTree->Input[i]);
			free(aTree->W[i]);
		}
		for(i=0;i<2*n;i++)
			free(aTree->Adjacence[i]);

		if(aTree->SpeciesName != NULL){
			for(i=0;i<=n;i++){
				free(aTree->SpeciesName[i]);
			}
			free(aTree->SpeciesName);
		}
		
		free(aTree->ADD);
		free(aTree->Adjacence);
		//free(aTree->Input);
		free(aTree->W);
		free(aTree->degre);
	}
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0xb0f5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x1100
movq 0x30(%rbx), %rdi
callq 0x1100
cmpl $0x0, (%rbx)
jle 0xb06b
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
movslq (%rbx), %rax
leaq -0x1(,%rax,2), %rax
cmpq %rax, %r15
jl 0xb03e
testl %r14d, %r14d
jle 0xb099
leal (%r14,%r14), %eax
cmpl $0x2, %eax
movl $0x1, %r15d
cmovgel %eax, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x1100
incq %r12
cmpq %r12, %r15
jne 0xb084
cmpq $0x0, 0x18(%rbx)
je 0xb0c9
testl %r14d, %r14d
js 0xb0c0
incl %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
cmpq %r15, %r14
jne 0xb0ab
movq 0x18(%rbx), %rdi
callq 0x1100
movq 0x8(%rbx), %rdi
callq 0x1100
movq 0x28(%rbx), %rdi
callq 0x1100
movq 0x40(%rbx), %rdi
callq 0x1100
movq 0x50(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1100
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: FreeMemory_InputTree(InputTree*, int)
void FreeMemory_InputTree(struct InputTree *aTree,int size){
	
	int i;
	int n=size;
	
	if(aTree->ADD != NULL){
	
		free(aTree->LONGUEUR);
		free(aTree->ARETE);

		for(i=0;i<2*n;i++){
			free(aTree->ADD[i]);
			free(aTree->Input[i]);
			if(i<=n)
				free(aTree->W[i]);
		}
		for(i=0;i<2*n;i++){		
			free(aTree->Adjacence[i]);
		}

		if(aTree->SpeciesName != NULL){
			for(i=0;i<=n;i++){
				free(aTree->SpeciesName[i]);
			}
			free(aTree->SpeciesName);
		}
		
		free(aTree->ADD);
		free(aTree->Adjacence);
		free(aTree->Input);
		free(aTree->W);
		free(aTree->degre);
	}
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0xb215
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x1100
movq 0x30(%rbx), %rdi
callq 0x1100
leal (%r14,%r14), %eax
movl %eax, -0x2c(%rbp)
testl %r14d, %r14d
jle 0xb17d
movl %r14d, %r12d
movl -0x2c(%rbp), %eax
cmpl $0x2, %eax
movl $0x1, %r13d
cmovgel %eax, %r13d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
cmpq %r12, %r15
ja 0xb175
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
cmpq %r15, %r13
jne 0xb149
testl %r14d, %r14d
jle 0xb1aa
movl -0x2c(%rbp), %eax
cmpl $0x2, %eax
movl $0x1, %r15d
cmovgel %eax, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x1100
incq %r12
cmpq %r12, %r15
jne 0xb195
cmpq $0x0, 0x18(%rbx)
je 0xb1da
testl %r14d, %r14d
js 0xb1d1
incl %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
cmpq %r15, %r14
jne 0xb1bc
movq 0x18(%rbx), %rdi
callq 0x1100
movq 0x8(%rbx), %rdi
callq 0x1100
movq 0x28(%rbx), %rdi
callq 0x1100
movq 0x10(%rbx), %rdi
callq 0x1100
movq 0x40(%rbx), %rdi
callq 0x1100
movq 0x50(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: nextTreeIsNewick(_IO_FILE*)
int nextTreeIsNewick(FILE *in){
	
	char c;

	while(fscanf(in,"%c",&c)!= EOF){
		if(c != ' ' && c !='\t' && c != '\n' && c !='\r'){
			fseek(in,-1,SEEK_CUR);
			if(c=='(') return 1;
			return 0;
		}
	}
	
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa75e(%rip), %rsi      # 0x1598c
leaq -0x29(%rbp), %rdx
xorl %eax, %eax
callq 0x11e0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0xb29f
movabsq $0x100002600, %r13      # imm = 0x100002600
leaq 0xa737(%rip), %r15      # 0x1598c
leaq -0x29(%rbp), %r12
movzbl -0x29(%rbp), %eax
cmpq $0x20, %rax
ja 0xb280
btq %rax, %r13
jae 0xb280
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x11e0
cmpl $-0x1, %eax
jne 0xb259
jmp 0xb29f
movq %rbx, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x10b0
xorl %r14d, %r14d
cmpb $0x28, -0x29(%rbp)
sete %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: readNewick(_IO_FILE*)
char * readNewick(FILE *in){
	
	int cpt=0;
	char c;
	char * newick = (char*)malloc(100000);

	do{
		c=(char)fgetc(in);
		newick[cpt] = c;
		cpt++;
	}while(c!=';');
	
	newick[cpt] = '\0';

	return newick;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x1140
movq %rax, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x11b0
movb %al, (%rbx,%r15)
incq %r15
cmpb $0x3b, %al
jne 0xb2ce
movl %r15d, %eax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: nbSpeciesNewick(char const*)
int nbSpeciesNewick(const char * newick){
	int i=0;
	int n = 0;
	char symbol,parent=' ';
	char symbolOld =' ';  	
	int temoin =0;

	do{
		symbol = newick[i];
		i++;
		//if (symbol == ':' && symbolOld != ')') n++;

		if(symbol == ':' && symbolOld !=')' && temoin != 1) n++;
		if(symbol >= '0' && symbol <= '9' && symbolOld==')') temoin=1;
		if(symbol==':' && temoin==1) temoin=0;
		symbolOld = symbol;
	}while(symbol != ';');

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x20, %dl
xorl %eax, %eax
movl $0x1, %ecx
xorl %r8d, %r8d
movl %r8d, %esi
movl %edx, %r10d
movb (%rdi), %dl
cmpl $0x1, %r8d
setne %r9b
leal -0x30(%rdx), %r11d
cmpb $0xa, %r11b
cmovbl %ecx, %esi
cmpb $0x29, %r10b
setne %r10b
cmovnel %r8d, %esi
movl $0x0, %r8d
cmpl $0x1, %esi
je 0xb33b
movl %esi, %r8d
andb %r9b, %r10b
cmpb $0x3a, %dl
sete %r9b
cmovel %r8d, %esi
andb %r10b, %r9b
movzbl %r9b, %r8d
addl %r8d, %eax
incq %rdi
movl %esi, %r8d
cmpb $0x3b, %dl
jne 0xb309
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: newickToMatrix(char const*, InputTree*)
void newickToMatrix(const char *newick,struct InputTree *aTree){
	
	int i,j;
	int pasBinaire=0;
  int pos_racine=-1;
//	double**DIST;


	aTree->size = nbSpeciesNewick(newick);
	allocMemmory(aTree,aTree->size+1);
	pos_racine = lectureNewick(newick,aTree->ARETE,aTree->LONGUEUR,aTree->SpeciesName,&aTree->kt);

	
	
 /* if(pos_racine != -1){
    addLeafAndUpdate(aTree,pos_racine);
	  aTree->Root = aTree->size;
  }
  else*/
  {
    loadAdjacenceMatrix(aTree->Adjacence,aTree->ARETE, aTree->LONGUEUR,aTree->size,aTree->kt);
    Floyd(aTree->Adjacence,aTree->ADD,aTree->Input,aTree->size,aTree->kt); //1ere fois
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb2f6
movl %eax, (%rbx)
leal 0x1(%rax), %esi
movq %rbx, %rdi
callq 0x7e1c
movq 0x18(%rbx), %rcx
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
leaq 0x48(%rbx), %r8
movq %r14, %rdi
callq 0x52a4
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl (%rbx), %ecx
movl 0x48(%rbx), %r8d
callq 0x22a4
movq 0x28(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl (%rbx), %ecx
movl 0x48(%rbx), %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x1de5
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: readMatrix(_IO_FILE*, InputTree*)
void readMatrix(FILE *in,struct InputTree *aTree){
	
	int n,i,j;
	char name[50];
	double value;

	fscanf(in,"%d",&n);
	aTree->size = n;
	allocMemmory(aTree,aTree->size+1);

	for(i=1;i<=n;i++){
		fscanf(in,"%s",name); strcpy(aTree->SpeciesName[i],name);
		for(j=1;j<=n;j++){
			fscanf(in,"%lf",&value);
			aTree->ADD[i][j] = aTree->Input[i][j] = value;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0xadf3(%rip), %rsi      # 0x161da
leaq -0x2c(%rbp), %r15
movq %r15, %rdx
xorl %eax, %eax
callq 0x11e0
movl (%r15), %esi
movl %esi, (%rbx)
incl %esi
movq %rbx, %rdi
callq 0x7e1c
cmpl $0x0, (%r15)
jle 0xb4bd
movl $0x1, %eax
movq %r12, %rdi
leaq 0xb007(%rip), %rsi      # 0x16424
leaq -0x80(%rbp), %r13
movq %rax, %r15
movq %r13, %rdx
xorl %eax, %eax
callq 0x11e0
movq 0x18(%rbx), %rax
movq %r15, -0x38(%rbp)
movq (%rax,%r15,8), %rdi
movq %r13, %rsi
callq 0x1090
cmpl $0x0, -0x2c(%rbp)
leaq 0x9fee(%rip), %rcx      # 0x1543b
leaq -0x40(%rbp), %r14
movq %rbx, %r15
jle 0xb4a5
movq %r14, %rbx
xorl %r13d, %r13d
movq %r12, %rdi
movq %rcx, %r14
movq %rcx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x11e0
movq %r14, %rcx
movsd -0x40(%rbp), %xmm0
movq 0x10(%r15), %rax
movq -0x38(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movsd %xmm0, 0x8(%rax,%r13,8)
movq 0x8(%r15), %rax
movq (%rax,%rdx,8), %rax
movsd %xmm0, 0x8(%rax,%r13,8)
movslq -0x2c(%rbp), %rax
incq %r13
cmpq %rax, %r13
jl 0xb45c
movq -0x38(%rbp), %rdx
leaq 0x1(%rdx), %rax
movslq -0x2c(%rbp), %rcx
cmpq %rcx, %rdx
movq %r15, %rbx
jl 0xb413
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: AdjustBranchLength(InputTree*, InputTree, int, int)
void AdjustBranchLength(struct InputTree *aTree1, struct InputTree aTree2,int binaire,int useFloyd){

	int i,j,iternumber=100;
	int kt = aTree1->kt;
	
	approx_arb(aTree2.ADD,aTree1->ADD,aTree1->ADD,aTree1->W,&iternumber,aTree1->ARETE,aTree1->LONGUEUR,1,&kt,binaire,aTree1->size);
  loadAdjacenceMatrix(aTree1->Adjacence,aTree1->ARETE, aTree1->LONGUEUR,aTree1->size,aTree1->kt);

	if(useFloyd == 1){
		Floyd(aTree1->Adjacence,aTree1->ADD,aTree1->size,aTree1->kt); // 3eme fois
	//	global_cpt3 ++;
  }
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %eax
movq %rdi, %rbx
leaq -0x18(%rbp), %r8
movl $0x64, (%r8)
movl 0x48(%rdi), %ecx
leaq -0x14(%rbp), %r10
movl %ecx, (%r10)
movq 0x18(%rbp), %rdi
movq 0x8(%rbx), %rdx
movq 0x30(%rbx), %r9
movl (%rbx), %ecx
subq $0x8, %rsp
movq %rdx, %rsi
pushq %rcx
pushq %rax
pushq %r10
pushq $0x1
pushq 0x38(%rbx)
callq 0x32e2
addq $0x30, %rsp
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl (%rbx), %ecx
movl 0x48(%rbx), %r8d
callq 0x22a4
cmpl $0x1, %r14d
jne 0xb892
movq 0x28(%rbx), %rdi
movq 0x8(%rbx), %rsi
movl (%rbx), %edx
movl 0x48(%rbx), %ecx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1d2c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq