LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: addLeafAndUpdate(InputTree*, int)
void addLeafAndUpdate(struct InputTree *aTree, int choix){
	
	int n = aTree->size;
	int i,j;


	for(i=1;i<=2*n-3-aTree->kt;i++){
		if(aTree->ARETE[2*i-1] > n) aTree->ARETE[2*i-1] += 1 ;
		if(aTree->ARETE[2*i-2] > n) aTree->ARETE[2*i-2] += 1 ;
	}
	

	//= ajout des 2 nouvelles branches
	aTree->ARETE[2*(2*n-2-aTree->kt)-1] = aTree->ARETE[2*choix-1];
	aTree->ARETE[2*(2*n-2-aTree->kt)-2] = 2*n-aTree->kt;
	aTree->LONGUEUR[(2*n-2-aTree->kt)-1] = ((aTree->LONGUEUR[choix-1]/2.0)>5*epsilon)?(aTree->LONGUEUR[choix-1]/2.0):5*epsilon;

	aTree->ARETE[2*(2*n-1-aTree->kt)-1] = aTree->ARETE[2*choix-2];
	aTree->ARETE[2*(2*n-1-aTree->kt)-2] = 2*n-aTree->kt;
	aTree->LONGUEUR[(2*n-1-aTree->kt)-1] = ((aTree->LONGUEUR[choix-1]/2.0)>5*epsilon)?(aTree->LONGUEUR[choix-1]/2.0):5*epsilon;
	
	aTree->ARETE[2*choix-1] = n+1;
	aTree->ARETE[2*choix-2] = 2*n-aTree->kt;
	aTree->LONGUEUR[choix-1]= 5*epsilon;  

	aTree->size = aTree->size+1;


	loadAdjacenceMatrix(aTree->Adjacence,aTree->ARETE, aTree->LONGUEUR,n+1,aTree->kt);

	Floyd(aTree->Adjacence,aTree->ADD,aTree->Input,n+1,aTree->kt);//5eme fois

	strcpy(aTree->SpeciesName[aTree->size],"Root");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movslq (%rdi), %rcx
leaq (%rcx,%rcx), %rdi
movslq 0x48(%rbx), %r8
movl %edi, %edx
subl %r8d, %edx
addl $-0x3, %edx
xorl %r9d, %r9d
testl %edx, %edx
cmovlel %r9d, %edx
movq 0x30(%rbx), %rsi
shlq $0x4, %rdx
cmpq %r9, %rdx
je 0x66f7
movq 0x8(%rsi,%r9), %r10
cmpq %rcx, %r10
jle 0x66e1
incq %r10
movq %r10, 0x8(%rsi,%r9)
movq (%rsi,%r9), %r10
cmpq %rcx, %r10
jle 0x66f1
incq %r10
movq %r10, (%rsi,%r9)
addq $0x10, %r9
jmp 0x66ca
leal (%rax,%rax), %edx
movslq %edx, %r9
movq -0x8(%rsi,%r9,8), %rdx
movq %rdi, %r11
addq $-0x2, %r11
movl %r8d, %r10d
notl %r10d
leal (%r11,%r10), %r14d
movq %r11, %r15
subq %r8, %r15
shlq $0x4, %r15
movq %rdx, -0x8(%rsi,%r15)
movl %edi, %edx
subl %r8d, %edx
movslq %edx, %r11
movq %r11, -0x10(%rsi,%r15)
movq 0x38(%rbx), %rdx
cltq
movsd 0xd8cb(%rip), %xmm0     # 0x14008
movsd -0x8(%rdx,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd 0xd8f1(%rip), %xmm2     # 0x14040
maxsd %xmm2, %xmm1
movslq %r14d, %r14
movsd %xmm1, (%rdx,%r14,8)
movq -0x10(%rsi,%r9,8), %r14
leal -0x1(%rdi), %r15d
subl %r8d, %r15d
addl %r15d, %r15d
movslq %r15d, %r15
movq %r14, -0x8(%rsi,%r15,8)
movq %r11, -0x10(%rsi,%r15,8)
mulsd -0x8(%rdx,%rax,8), %xmm0
maxsd %xmm2, %xmm0
addl %r10d, %edi
decl %edi
movslq %edi, %rdi
movsd %xmm0, (%rdx,%rdi,8)
incl %ecx
movslq %ecx, %r14
movq %r14, -0x8(%rsi,%r9,8)
movq %r11, -0x10(%rsi,%r9,8)
movabsq $0x3f0a36e2eb1c432d, %rcx # imm = 0x3F0A36E2EB1C432D
movq %rcx, -0x8(%rdx,%rax,8)
movl %r14d, (%rbx)
movq 0x28(%rbx), %rdi
movl %r14d, %ecx
callq 0x20bd
movq 0x28(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl 0x48(%rbx), %r8d
movl %r14d, %ecx
callq 0x1ce8
movq 0x18(%rbx), %rax
movslq (%rbx), %rcx
movq (%rax,%rcx,8), %rax
movb $0x0, 0x4(%rax)
movl $0x746f6f52, (%rax)     # imm = 0x746F6F52
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
leal 0x1(%rcx), %eax
negq %rcx
movabsq $0x1, %r8
leaq (%rcx,%r8), %r9
cmpq $0x1, %r9
je 0x6824
cmpl $0x0, (%rsi,%r8,4)
je 0x6821
incq %r8
jmp 0x680b
movl %r8d, %eax
cmpl %edx, %eax
jge 0x6863
pushq %rbp
movq %rsp, %rbp
movl %eax, %eax
movb $0x1, %cl
movsd 0xd7f0(%rip), %xmm0     # 0x14028
movq %rax, %r8
movq %r8, %r9
cmpl %edx, %r9d
jge 0x686a
leaq 0x1(%r9), %r8
movq (%rdi,%rax,8), %r10
ucomisd 0x8(%r10,%r9,8), %xmm0
movq %r8, %r9
jbe 0x683e
movl $0x1, (%rsi,%r8,4)
xorl %ecx, %ecx
jmp 0x683b
movl $0x1, (%rsi)
retq
testb $0x1, %cl
je 0x6878
movl $0x2, (%rsi,%rax,4)
jmp 0x687f
movl $0x1, (%rsi,%rax,4)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x68e5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
incl %edx
xorl %r8d, %r8d
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
incl %eax
movabsq $0x1, %r9
movq %r9, %r10
cmpq %rax, %r10
je 0x68d9
movq %r9, %r11
cmpq %r11, %rdx
je 0x68d4
movl (%rdi,%r10,4), %ebx
xorl %r14d, %r14d
cmpl (%rsi,%r11,4), %ebx
sete %r14b
addl %r14d, %r8d
incq %r11
jmp 0x68b8
incq %r10
jmp 0x68b0
xorl %eax, %eax
cmpl %ecx, %r8d
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %r9, %rbx
movq %r8, -0x38(%rbp)
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
andl $0x0, (%r9)
leal -0x3(,%rdx,2), %eax
cltq
movq %rax, -0x40(%rbp)
addq $0x8, %r12
pushq $0x1
popq %r13
cmpq -0x40(%rbp), %r13
jg 0x6981
imulq $0x18, (%r12), %rax
movl (%r15,%rax), %ecx
movq 0x10(%r15,%rax), %rdi
movl %ecx, (%rdi)
imulq $0x18, -0x8(%r12), %rax
movl (%r15,%rax), %ecx
movq 0x10(%r15,%rax), %r14
movl %ecx, (%r14)
movq -0x30(%rbp), %rsi
callq 0x6881
testl %eax, %eax
jne 0x6966
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x6881
testl %eax, %eax
je 0x6978
movslq (%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%rbx)
movq -0x38(%rbp), %rcx
movl %r13d, 0x4(%rcx,%rax,4)
incq %r13
addq $0x10, %r12
jmp 0x6921
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x10(%rbp), %r14d
leal (%r14,%r14), %ebx
subl 0x58(%rbp), %ebx
movq %rdi, -0x30(%rbp)
addl $-0x2, %ebx
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
incl %ebx
pushq $0x1
popq %r12
cmpq %rbx, %r12
je 0x6e7c
cmpq %r14, %r12
je 0x6e65
movq %r14, %r15
imulq $0x18, %r12, %r13
addq -0x30(%rbp), %r13
xorl %r14d, %r14d
movslq (%r13), %rax
incq %rax
movq 0x8(%r13), %rdi
cmpq %rax, %r14
jg 0x6e5d
movq (%rdi,%r14,8), %rdi
callq 0x10f0
incq %r14
jmp 0x6e3f
callq 0x10f0
movq %r15, %r14
imulq $0x18, %r12, %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx,%rax), %rdi
callq 0x10f0
incq %r12
jmp 0x6e27
movq -0x30(%rbp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x40c(%rbp), %r14
leaq 0xd9b4(%rip), %rsi      # 0x14865
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1090
testl %eax, %eax
jne 0x6ed6
movups 0xd9ae(%rip), %xmm0     # 0x14875
movups %xmm0, -0x43(%rbp)
movups 0xd996(%rip), %xmm0     # 0x14868
movaps %xmm0, -0x50(%rbp)
leaq 0xe5e0(%rip), %rsi      # 0x154bd
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1090
testl %eax, %eax
jne 0x6f08
movabsq $0x73657261757173, %rax # imm = 0x73657261757173
movq %rax, -0x4a(%rbp)
movabsq $0x71732d747361656c, %rax # imm = 0x71732D747361656C
movq %rax, -0x50(%rbp)
leaq 0xd984(%rip), %rsi      # 0x14893
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1090
testl %eax, %eax
jne 0x6f34
movups 0xd97b(%rip), %xmm0     # 0x148a0
movups %xmm0, -0x46(%rbp)
movups 0xd966(%rip), %xmm0     # 0x14896
movaps %xmm0, -0x50(%rbp)
leaq 0x10(%rbp), %r15
leaq 0xd971(%rip), %rsi      # 0x148b0
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1090
testl %eax, %eax
jne 0x6f5d
movups 0xd95e(%rip), %xmm0     # 0x148b3
movaps %xmm0, -0x50(%rbp)
movb $0x0, -0x40(%rbp)
movq 0x121b4(%rip), %rdi     # 0x19118
movq %rbx, %rsi
callq 0x10b0
pushq $0xa
popq %r14
movl %r14d, %edi
movq %rbx, %rsi
callq 0x1120
leaq 0xe9e(%r15), %rdx
leaq 0xd93b(%rip), %rsi      # 0x148c4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1170
leaq 0xd944(%rip), %rsi      # 0x148de
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1170
addq $0xf0c, %r15            # imm = 0xF0C
leaq 0xd942(%rip), %rsi      # 0x148f8
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1170
movl %r14d, %edi
movq %rbx, %rsi
callq 0x1120
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
orl $-0x1, 0x20(%rdi)
orl $-0x1, (%rdi)
andl $0x0, 0x48(%rdi)
movups %xmm0, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd77c(%rip), %rsi      # 0x14795
callq 0x10d0
testq %rax, %rax
je 0x704c
movq %rax, %r12
leaq 0xeb02(%rip), %rsi      # 0x15b2f
movq %rax, %rdi
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1170
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1080
leaq 0xd8bf(%rip), %rdi      # 0x14912
movq %r15, %rsi
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %r12d
movq %rdi, %r15
leaq 0xd712(%rip), %rsi      # 0x14795
callq 0x10d0
testq %rax, %rax
je 0x7163
movq %rax, %r14
addl %r12d, %r12d
movslq %r12d, %r13
pushq $0x1
popq %r12
leaq 0xd888(%rip), %r15      # 0x1492d
movslq (%rbx), %rax
cmpq %rax, %r12
jg 0x70e9
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rcx
movq (%rax,%r12,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 0x70e4
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1170
incq %r12
jmp 0x70a5
leaq 0xd841(%rip), %rdi      # 0x14931
pushq $0x4
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %r14, %rcx
callq 0x11d0
leaq 0xd824(%rip), %r12      # 0x1492d
movslq (%rbx), %rax
cmpq %rax, %r15
jg 0x714d
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rcx
movq (%rax,%r15,8), %rax
movq -0x10(%rcx,%r13,8), %rdx
movq -0x8(%rcx,%r13,8), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd (%rax,%rdx,8), %xmm0
jbe 0x7148
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1170
incq %r15
jmp 0x7109
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
leaq 0xd7a8(%rip), %rdi      # 0x14912
movq %r15, %rsi
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7184
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%r14), %eax
movslq %eax, %r13
leaq (,%r13,4), %rdi
callq 0x1130
movq %rax, 0x50(%rbx)
leaq (,%r13,8), %r15
movq %r15, %rdi
callq 0x1130
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x1130
movq %rax, 0x28(%rbx)
movq %r15, %rdi
callq 0x1130
movq %rax, 0x10(%rbx)
movq %r14, -0x30(%rbp)
movslq %r14d, %r12
leaq 0x8(,%r12,8), %rdi
callq 0x1130
movq %rax, 0x40(%rbx)
xorl %r14d, %r14d
testl %r13d, %r13d
cmovlel %r14d, %r13d
cmpq %r14, %r13
je 0x724d
movq %r15, %rdi
callq 0x1130
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq %r15, %rdi
callq 0x1130
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq %r15, %rdi
callq 0x1130
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
cmpq %r12, %r14
jg 0x7248
movq %r15, %rdi
callq 0x1130
movq 0x40(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0x71fe
movq -0x30(%rbp), %r14
leal (,%r14,8), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1130
movq %rax, 0x30(%rbx)
shll $0x2, %r14d
movslq %r14d, %rdi
shlq $0x3, %rdi
callq 0x1130
movq %rax, 0x38(%rbx)
movq %r15, %rdi
callq 0x1130
movq %rax, 0x18(%rbx)
xorl %r15d, %r15d
pushq $0x32
popq %r14
cmpq %r12, %r15
jg 0x72aa
movq %r14, %rdi
callq 0x1130
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x7290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %r14d
movq %rdi, %rbx
addl %r14d, %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
movq 0x8(%rbx), %rdi
cmpq %r15, %r14
je 0x7321
movq (%rdi,%r15,8), %rdi
callq 0x10f0
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x10f0
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x10f0
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x10f0
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x10f0
incq %r15
jmp 0x72d6
callq 0x10f0
movq 0x28(%rbx), %rdi
callq 0x10f0
movq 0x10(%rbx), %rdi
callq 0x10f0
movq 0x40(%rbx), %rdi
callq 0x10f0
movq 0x30(%rbx), %rdi
callq 0x10f0
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %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 0x288f
movl %eax, %r13d
movq 0x48(%rbx), %rsi
movq 0x58(%rbx), %rdx
movq %r15, %rdi
movl %r14d, %ecx
callq 0x288f
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
movq 0x58(%rbx), %rcx
movl %r14d, (%rsp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movl %r13d, %r8d
movl %eax, %r9d
callq 0x2dd8
movl %eax, %r13d
movslq %r14d, %rax
xorpd %xmm1, %xmm1
pushq $0x2
popq %rcx
pushq $0x1
popq %rdx
cmpq %rax, %rdx
jge 0x800a
movq %rcx, %rsi
cmpl %r14d, %esi
jg 0x8002
movq (%r12,%rdx,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%r15,%rdx,8), %rdi
subsd (%rdi,%rsi,8), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %rsi
jmp 0x7fde
incq %rdx
incq %rcx
jmp 0x7fd6
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %r14d, %edx
movsd %xmm1, -0x30(%rbp)
callq 0x12dc
movsd -0x30(%rbp), %xmm1
movsd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
movl %r13d, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rbp), %rax
movq 0x40(%rbp), %rcx
movslq 0x4(%rdi), %rdx
shlq $0x4, %rdx
movq -0x10(%rcx,%rdx), %rsi
movq -0x8(%rcx,%rdx), %r12
movq (%rax,%r12,8), %rdx
movslq 0x30(%rbp), %rdi
movq (%rax,%rsi,8), %r8
movsd (%r8,%rdi,8), %xmm0
ucomisd (%rdx,%rdi,8), %xmm0
cmovaq %rsi, %r12
movslq 0x8(%rbx), %rdx
shlq $0x4, %rdx
movq -0x10(%rcx,%rdx), %rsi
movq -0x8(%rcx,%rdx), %r15
movq (%rax,%r15,8), %rcx
movsd (%rcx,%rdi,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq (%rax,%rsi,8), %rax
movsd (%rax,%rdi,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x10(%rbx), %rdi
callq 0x10f0
movslq %r12d, %rax
imulq $0x18, %rax, %rax
leaq (%r14,%rax), %r13
movslq (%r14,%rax), %r12
leaq 0x4(,%r12,4), %rdi
callq 0x1130
movq %rax, 0x10(%rbx)
movl %r12d, (%rax)
pushq $0x1
popq %rcx
cmpq %r12, %rcx
jg 0x9410
movq 0x10(%r13), %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x93fc
movsd -0x30(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
cmovaq -0x40(%rbp), %r15
movq 0x18(%rbx), %rdi
callq 0x10f0
movslq %r15d, %rax
imulq $0x18, %rax, %rax
leaq (%r14,%rax), %r15
movslq (%r14,%rax), %r14
leaq 0x4(,%r14,4), %rdi
callq 0x1130
movq %rax, 0x18(%rbx)
movl %r14d, (%rax)
pushq $0x1
popq %rcx
cmpq %r14, %rcx
jg 0x9462
movq 0x10(%r15), %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x944e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: TestCriterionAndUpdate(int*, char const*, CRITERIA, HGT*, int, int, int, int)
int TestCriterionAndUpdate(int *first,const char *CRITERION, struct CRITERIA aCrit, struct HGT * aHGT,int i,int j,int flag,int flag_bootstrap){

	int best = 0;

	if (strcmp(CRITERION,"rf")==0){
		if (aHGT->crit.RF > aCrit.RF) {
			best = 1;			
			(*first)=0;
		}
		if (aHGT->crit.RF == aCrit.RF && aHGT->crit.LS > aCrit.LS && (*first) == 0)
			best = 1; 
	}
	else if (strcmp(CRITERION,"ls")==0){
		if (aHGT->crit.LS > aCrit.LS) best = 1;
	}
	else if (strcmp(CRITERION,"bd")==0){
		if (aHGT->crit.BD > aCrit.BD) best = 1;
		if (flag == 2){
			printf("LALA");
			best=1;
		}
		
	}
	else if (strcmp(CRITERION,"qd")==0){
		if (aHGT->crit.QD > aCrit.QD) best = 1;
	}
	else{
		printf("\nunknown criterion %s, try again...\n",CRITERION);
		exit(-1);
	}

	if (flag_bootstrap == 1){
		
		if(rand_bootstrap == 0){
			best = 0;
		}
		else{
			best = 1;
		}
		
		//printf("\n==> rand_bootstrap = %d, best = %d",rand_bootstrap,best);
	}
	
	if(best == 1){
  	//printf("FIN TCAU");
		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;
	}
	
	//printf("\n>>>> DANS testCRiterionAndUpdate : RF = %d, BD =%lf",aCrit.RF,aCrit.BD);
	
	return best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r15d
movl %ecx, %r14d
movq %rdx, %rbx
leaq 0x10(%rbp), %r12
movzbl (%rsi), %eax
cmpl $0x62, %eax
je 0x9520
cmpl $0x6c, %eax
je 0x955b
cmpl $0x71, %eax
je 0x94fd
cmpl $0x72, %eax
jne 0x95cd
cmpb $0x66, 0x1(%rsi)
jne 0x95cd
cmpb $0x0, 0x2(%rsi)
jne 0x95cd
movl 0x50(%rbx), %esi
movl 0x30(%r12), %edx
xorl %ecx, %ecx
pushq $0x1
popq %rax
cmpl %edx, %esi
jle 0x94d9
andl $0x0, (%rdi)
movl 0x50(%rbx), %esi
movl %eax, %ecx
cmpl %edx, %esi
jne 0x957d
movsd 0x20(%rbx), %xmm0
ucomisd (%r12), %xmm0
jbe 0x957d
cmpl $0x0, (%rdi)
cmovel %eax, %ecx
jmp 0x957d
cmpb $0x64, 0x1(%rsi)
jne 0x95cd
cmpb $0x0, 0x2(%rsi)
jne 0x95cd
movl 0x54(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x34(%r12), %eax
setg %cl
jmp 0x957d
cmpb $0x64, 0x1(%rsi)
jne 0x95cd
cmpb $0x0, 0x2(%rsi)
jne 0x95cd
movsd 0x30(%rbx), %xmm0
xorl %ecx, %ecx
ucomisd 0x10(%r12), %xmm0
seta %al
cmpl $0x2, %r9d
jne 0x957b
leaq 0xb3ff(%rip), %rdi      # 0x14951
xorl %eax, %eax
callq 0x1030
jmp 0x9576
cmpb $0x73, 0x1(%rsi)
jne 0x95cd
cmpb $0x0, 0x2(%rsi)
jne 0x95cd
movsd 0x20(%rbx), %xmm0
xorl %ecx, %ecx
ucomisd (%r12), %xmm0
jbe 0x957d
pushq $0x1
popq %rcx
jmp 0x957d
movb %al, %cl
xorl %eax, %eax
cmpl $0x0, 0xfbbe(%rip)      # 0x19144
setne %al
cmpl $0x1, 0x70(%rbp)
cmovnel %ecx, %eax
cmpl $0x1, %eax
jne 0x95c4
movl %r15d, 0x8(%rbx)
movl %r14d, 0x4(%rbx)
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0x30(%rbx)
movsd (%r12), %xmm0
movsd %xmm0, 0x20(%rbx)
movl 0x30(%r12), %ecx
movl %ecx, 0x50(%rbx)
movl 0x34(%r12), %ecx
movl %ecx, 0x54(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb382(%rip), %rdi      # 0x14956
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movl %esi, %r14d
leaq 0xad9d(%rip), %rsi      # 0x14740
callq 0x10d0
movq %rax, %r13
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
incl %r14d
movq %r14, -0x40(%rbp)
pushq $0x1
popq %rax
pushq $0x3b
popq %r14
cmpq -0x40(%rbp), %rax
je 0x9a8b
movq %rax, -0x48(%rbp)
imulq $0xa8, %rax, %r15
movq -0x38(%rbp), %rax
movl (%rax,%r15), %eax
cmpl $0x6, %eax
je 0x99ed
cmpl $0x1, %eax
jne 0x9a7f
addq -0x38(%rbp), %r15
movq %r13, %rdi
leaq 0xaf80(%rip), %rsi      # 0x1497b
movl -0x2c(%rbp), %edx
xorl %eax, %eax
callq 0x1170
pushq $0x1
popq %r12
movq 0x10(%r15), %rax
movslq (%rax), %rcx
cmpq %rcx, %r12
jg 0x9a43
movslq (%rax,%r12,4), %rax
movq (%rbx,%rax,8), %rdi
movq %r13, %rsi
callq 0x10b0
movq 0x10(%r15), %rax
movslq (%rax), %rax
cmpq %rax, %r12
pushq $0x20
popq %rdi
cmovll %r14d, %edi
movq %r13, %rsi
callq 0x1120
incq %r12
jmp 0x9a09
pushq $0x1
popq %r12
movq 0x18(%r15), %rax
movslq (%rax), %rcx
cmpq %rcx, %r12
jg 0x9a7f
movslq (%rax,%r12,4), %rax
movq (%rbx,%rax,8), %rdi
movq %r13, %rsi
callq 0x10b0
movq 0x18(%r15), %rax
movslq (%rax), %rax
cmpq %rax, %r12
jge 0x9a7a
movl %r14d, %edi
movq %r13, %rsi
callq 0x1120
incq %r12
jmp 0x9a47
movq -0x48(%rbp), %rax
incq %rax
jmp 0x99c2
pushq $0xa
popq %rdi
movq %r13, %rsi
callq 0x1120
movq %r13, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9b27
leaq 0xb8(%rbp), %rsi
leaq 0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl (%rcx), %edx
movq 0x18(%rsi), %rsi
cmpl (%rsi), %edx
jne 0x9b27
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
cmpq %rax, %r8
je 0x9b01
movl 0x4(%rdi,%rax,4), %r10d
leaq 0x1(%rax), %r11
cmpl 0x4(%r9,%rax,4), %r10d
movq %r11, %rax
je 0x9ae7
jmp 0x9b25
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
movl $0x1, %eax
cmpq %rdi, %rdx
je 0x9b27
movl 0x4(%rcx,%rdi,4), %r8d
leaq 0x1(%rdi), %r9
cmpl 0x4(%rsi,%rdi,4), %r8d
movq %r9, %rdi
je 0x9b0d
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r11
leaq 0x10(%rbp), %r9
movq 0x10(%r9), %rdi
movl (%rdi), %r8d
movq 0x10(%r11), %rax
movl (%rax), %edx
xorl %ecx, %ecx
movl $0x0, %esi
cmpl %edx, %r8d
jne 0x9b89
xorl %r10d, %r10d
testl %r8d, %r8d
movl $0x0, %ebx
cmovgl %r8d, %ebx
movl $0x1, %esi
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x9b89
movl 0x4(%rdi,%r14,4), %r15d
cmpl 0x4(%rax,%r14,4), %r15d
cmovnel %r10d, %esi
incq %r14
jmp 0x9b71
movq 0x18(%r9), %r9
movl (%r9), %r10d
movq 0x18(%r11), %r11
movl (%r11), %ebx
cmpl %ebx, %r10d
jne 0x9bdd
xorl %r14d, %r14d
testl %r10d, %r10d
movl $0x0, %r15d
cmovgl %r10d, %r15d
movl $0x1, %ecx
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x9bcc
movl 0x4(%r9,%r12,4), %r13d
cmpl 0x4(%r11,%r12,4), %r13d
cmovnel %r14d, %ecx
incq %r12
jmp 0x9bb4
cmpl $0x1, %ecx
jne 0x9bdd
cmpl $0x1, %esi
jne 0x9bdd
movl $0x1, %eax
jmp 0x9c42
cmpl %ebx, %r8d
jne 0x9c0a
xorl %ebx, %ebx
testl %r8d, %r8d
cmovlel %ebx, %r8d
movl $0x1, %esi
xorl %r14d, %r14d
cmpq %r14, %r8
je 0x9c0a
movl 0x4(%rdi,%r14,4), %r15d
cmpl 0x4(%r11,%r14,4), %r15d
cmovnel %ebx, %esi
incq %r14
jmp 0x9bf3
cmpl %edx, %r10d
jne 0x9c35
movl $0x1, %ecx
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x9c35
movl 0x4(%r9,%r8,4), %r10d
cmpl 0x4(%rax,%r8,4), %r10d
cmovnel %edi, %ecx
incq %r8
jmp 0x9c1e
xorl $0x1, %ecx
xorl $0x1, %esi
xorl %eax, %eax
orl %ecx, %esi
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1130
movq %rax, %r14
movq %rax, 0x10(%rbx)
movq 0x28(%rbp), %r15
movslq (%r15), %rax
leaq 0x4(,%rax,4), %rdi
callq 0x1130
movq %rax, 0x18(%rbx)
movl %r13d, (%r14)
xorl %ecx, %ecx
testl %r13d, %r13d
movl $0x0, %edx
cmovgl %r13d, %edx
cmpq %rcx, %rdx
je 0x9d32
movl 0x4(%r12,%rcx,4), %esi
movl %esi, 0x4(%r14,%rcx,4)
incq %rcx
jmp 0x9d1e
movl (%r15), %ecx
movl %ecx, (%rax)
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x9d51
movl 0x4(%r15,%rdx,4), %esi
movl %esi, 0x4(%rax,%rdx,4)
incq %rdx
jmp 0x9d3e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rcx, -0x30(%rbp)
movl %edx, %r15d
movq %rsi, %r12
cmpl $0x1, %edi
jne 0x9df7
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
addq $0xa8, %r12
movabsq $0x3ff0000000000000, %r14 # imm = 0x3FF0000000000000
subq $0x1, %r15
jb 0x9ef6
movl (%r12), %eax
cmpl $0x6, %eax
je 0x9dbd
cmpl $0x1, %eax
jne 0x9dee
movslq %r13d, %rax
incl %r13d
movq -0x38(%rbp), %rcx
movq %r14, 0x8(%rcx,%rax,8)
incq %rax
imulq $0xa8, %rax, %rax
addq -0x30(%rbp), %rax
pushq $0x15
popq %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x9c4d
addq $0xa8, %r12
jmp 0x9da5
movl (%rbx), %eax
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
incl %r15d
testl %eax, %eax
cmovlel %ecx, %eax
incl %eax
movq %rax, -0x48(%rbp)
pushq $0x1
popq %rax
movsd 0xa24d(%rip), %xmm0     # 0x14068
cmpq -0x48(%rbp), %rax
je 0x9ef9
movq %rax, -0x40(%rbp)
imulq $0xa8, %rax, %rdi
leaq (%r12,%rdi), %r8
addq -0x30(%rbp), %rdi
pushq $0x1
popq %r9
cmpq %r15, %r9
je 0x9eea
imulq $0xa8, %r9, %r11
cmpl $0x1, (%r12,%r11)
je 0x9e5d
cmpl $0x6, (%r8)
jne 0x9ee2
addq %r12, %r11
movq 0x10(%rdi), %rdx
movq 0x10(%r11), %r14
movl (%rdx), %eax
cmpl (%r14), %eax
jne 0x9ee2
movq 0x18(%rdi), %r10
movq 0x18(%r11), %r11
movl (%r10), %r13d
cmpl (%r11), %r13d
jne 0x9ee2
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
xorl %ebx, %ebx
cmpq %rbx, %rax
je 0x9ea4
movl 0x4(%rdx,%rbx,4), %ecx
leaq 0x1(%rbx), %rsi
cmpl 0x4(%r14,%rbx,4), %ecx
movq %rsi, %rbx
je 0x9e8b
jmp 0x9ee2
testl %r13d, %r13d
movl $0x0, %eax
cmovlel %eax, %r13d
xorl %eax, %eax
cmpq %rax, %r13
je 0x9ecc
movl 0x4(%r10,%rax,4), %ecx
leaq 0x1(%rax), %rdx
cmpl 0x4(%r11,%rax,4), %ecx
movq %rdx, %rax
je 0x9eb2
jmp 0x9ee2
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rcx,8)
incq %r9
jmp 0x9e3c
movq -0x40(%rbp), %rax
incq %rax
jmp 0x9e1b
movl %r13d, (%rbx)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa1b8
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x10f0
movq 0x30(%rbx), %rdi
callq 0x10f0
xorl %r15d, %r15d
movslq (%rbx), %rax
leaq -0x1(,%rax,2), %rax
cmpq %rax, %r15
jge 0xa13e
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x10f0
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x10f0
incq %r15
jmp 0xa10f
leal (%r14,%r14), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0xa163
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x10f0
incq %r12
jmp 0xa14c
cmpq $0x0, 0x18(%rbx)
je 0xa18c
movslq %r14d, %r14
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
cmpq %r14, %r15
jg 0xa187
movq (%rdi,%r15,8), %rdi
callq 0x10f0
incq %r15
jmp 0xa170
callq 0x10f0
movq 0x8(%rbx), %rdi
callq 0x10f0
movq 0x28(%rbx), %rdi
callq 0x10f0
movq 0x40(%rbx), %rdi
callq 0x10f0
movq 0x50(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa2a2
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x10f0
movq 0x30(%rbx), %rdi
callq 0x10f0
movslq %r14d, %r15
addl %r14d, %r14d
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
cmpq %r12, %r14
je 0xa22d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x10f0
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x10f0
cmpq %r15, %r12
jg 0xa228
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x10f0
incq %r12
jmp 0xa1f7
xorl %r12d, %r12d
cmpq %r12, %r14
je 0xa247
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x10f0
incq %r12
jmp 0xa230
cmpq $0x0, 0x18(%rbx)
je 0xa26d
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
cmpq %r15, %r14
jg 0xa268
movq (%rdi,%r14,8), %rdi
callq 0x10f0
incq %r14
jmp 0xa251
callq 0x10f0
movq 0x8(%rbx), %rdi
callq 0x10f0
movq 0x28(%rbx), %rdi
callq 0x10f0
movq 0x10(%rbx), %rdi
callq 0x10f0
movq 0x40(%rbx), %rdi
callq 0x10f0
movq 0x50(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10f0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
leaq 0xa6d1(%rip), %r15      # 0x1498c
leaq -0x29(%rbp), %r12
pushq $-0x1
popq %rbx
movabsq $0x100002600, %r13      # imm = 0x100002600
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x11c0
cmpl $-0x1, %eax
je 0xa308
movzbl -0x29(%rbp), %eax
cmpq $0x20, %rax
ja 0xa2f1
btq %rax, %r13
jb 0xa2cc
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x10a0
xorl %ebx, %ebx
cmpb $0x28, -0x29(%rbp)
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1130
movq %rax, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x11a0
movb %al, (%rbx,%r15)
incq %r15
cmpb $0x3b, %al
jne 0xa336
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_O2/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 0xa3a3
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 0xa371
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa35e
movl %eax, (%rbx)
leal 0x1(%rax), %esi
movq %rbx, %rdi
callq 0x717c
movq 0x18(%rbx), %rcx
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
leaq 0x48(%rbx), %r8
movq %r14, %rdi
callq 0x4a99
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl (%rbx), %ecx
movl 0x48(%rbx), %r8d
callq 0x20bd
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 0x1ce8
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xad8b(%rip), %rsi      # 0x151da
leaq -0x2c(%rbp), %r15
movq %r15, %rdx
xorl %eax, %eax
callq 0x11c0
movl (%r15), %esi
movl %esi, (%rbx)
incl %esi
movq %rbx, %rdi
callq 0x717c
pushq $0x1
popq %r12
movl (%r15), %eax
leaq -0x38(%rbp), %r15
cltq
cmpq %rax, %r12
jg 0xa4f2
movq %r14, %rdi
leaq 0xaf9c(%rip), %rsi      # 0x15424
leaq -0x70(%rbp), %r13
movq %r13, %rdx
xorl %eax, %eax
callq 0x11c0
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq %r13, %rsi
callq 0x1070
pushq $0x1
popq %r13
movslq -0x2c(%rbp), %rax
cmpq %rax, %r13
jg 0xa4ed
movq %r14, %rdi
leaq 0x9f7e(%rip), %rsi      # 0x1443b
movq %r15, %rdx
xorl %eax, %eax
callq 0x11c0
movsd -0x38(%rbp), %xmm0
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rax
movsd %xmm0, (%rax,%r13,8)
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0xa4aa
incq %r12
jmp 0xa477
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq