LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: xtoa(unsigned long, char*, unsigned int, int)
static void xtoa (unsigned long val,char *buf,unsigned radix,int is_neg){
	char *p;                /* pointer to traverse string */
	char *firstdig;         /* pointer to first digit */
	char temp;              /* temp char */
	unsigned digval;        /* value of digit */

	p = buf;

	if (is_neg) {
		/* negative, so output '-' and negate */
		*p++ = '-';
		val = (unsigned long)(-(long)val);
	}

	firstdig = p;           /* save pointer to first digit */

	do {
		digval = (unsigned) (val % radix);
		val /= radix;       /* get next digit */

		/* convert to ascii and store */
		if (digval > 9)
			*p++ = (char) (digval - 10 + 'a');  /* a letter */
		else
			*p++ = (char) (digval + '0');       /* a digit */
	} while (val > 0);

	/* We now have the digit of the number in the buffer, but in reverse
	order.  Thus we reverse them now. */

	*p-- = '\0';            /* terminate string; p points to last digit */

	do {
		temp = *p;
		*p = *firstdig;
		*firstdig = temp;   /* swap *p and *firstdig */
		--p;
		++firstdig;         /* advance to next two digits */
	} while (firstdig < p); /* repeat until halfway */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x896c
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x2d, (%rax)
xorl %eax, %eax
subq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
cmpl $0x9, -0x30(%rbp)
jbe 0x89bb
movl -0x30(%rbp), %eax
subl $0xa, %eax
addl $0x61, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x89d4
movl -0x30(%rbp), %eax
addl $0x30, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x89d6
cmpq $0x0, -0x8(%rbp)
ja 0x8974
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movb -0x29(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x89ef
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: ajouterMatriceGene(double**, char const*, int, char**)
void ajouterMatriceGene(double **mat,const char *outfile,int taille,char **noms){
	int i,j;
	FILE *out;
	if((out=fopen(outfile,"a"))==NULL){
		printf("cannot create output file !!");
		printf("==2==>%s<===",outfile);
		exit(-1);
	}
	else{
		fprintf(out,"\n");
		for(i=1;i<=taille;i++){
			if(strcmp(noms[i],"") != 0){  //if(strlen(noms[i]) > 1){
				fprintf(out,"\n%s",noms[i]);
				for(j=1;j<=taille;j++)
					if(mat[i][j] != -1)
						fprintf(out," %lf",mat[i][j]);
			}
			else{
				//printf("\ngene : 1 cas");
			}
		}
		fclose(out);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1acd4(%rip), %rsi     # 0x257f6
callq 0x10c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xab5b
leaq 0x1ac94(%rip), %rdi     # 0x257cc
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rsi
leaq 0x1acae(%rip), %rdi     # 0x257f8
movb $0x0, %al
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10f0
movq -0x30(%rbp), %rdi
leaq 0x1b691(%rip), %rsi     # 0x261f7
movb $0x0, %al
callq 0x1140
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xac3d
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1b665(%rip), %rsi     # 0x261f8
callq 0x1130
cmpl $0x0, %eax
je 0xac2b
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1b910(%rip), %rsi     # 0x264c8
movb $0x0, %al
callq 0x1140
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xac29
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1a475(%rip), %xmm1    # 0x25060
ucomisd %xmm1, %xmm0
jne 0xabf5
jp 0xabf5
jmp 0xac1c
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x1b7f0(%rip), %rsi     # 0x26405
movb $0x1, %al
callq 0x1140
jmp 0xac1e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xabc6
jmp 0xac2d
jmp 0xac2d
jmp 0xac2f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xab74
movq -0x30(%rbp), %rdi
callq 0x1090
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: compare(int*, int*, int)
int compare(int * B, int *BI,int n){

	int somme = 0,i;
	int *tab = (int*)malloc((n+1)*sizeof(int));

	for(i=1;i<=n;i++)
		if(B[i] == BI[i])
			tab[i] = 1;
		else
			tab[i] = 0;
	for(i=1;i<=n;i++)
		somme = somme + tab[i];

	free(tab);

	return somme;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1110
movq %rax, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xafd4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0xafb8
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0xafc7
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0xafc9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xaf87
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xafff
movl -0x18(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xafdb
movq -0x28(%rbp), %rdi
callq 0x10e0
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: trouver_3_noeuds(double**, int, int, int*)
void trouver_3_noeuds(double ** Adjacence,int sommet,int n,int tab_noeuds[]){
	int j=1;
	for(int i=1;i<=2*n-2;i++){
		if(Adjacence[sommet][i] < INFINI){
			tab_noeuds[j++] = i;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x10(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jg 0xb2a3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd 0x19db1(%rip), %xmm0    # 0x25028
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xb296
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xb298
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb250
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: trouver_fils(double**, int, int, int*, int)
void trouver_fils(double **Adjacence,int sommet,int parent,int tab_fils[],int n){
	
	for(int i=1;i<=2*n-2;i++){
		if(Adjacence[sommet][i] < INFINI){
			if(i != parent){
				if(i<=n){
					tab_fils[0] += 1;
					tab_fils[tab_fils[0]] = i;	
				}
				else{
					trouver_fils(Adjacence,i,sommet,tab_fils,n);
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jg 0xb358
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd 0x19d30(%rip), %xmm0    # 0x25028
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xb348
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0xb346
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0xb32d
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xb344
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
callq 0xb2b0
jmp 0xb346
jmp 0xb348
jmp 0xb34a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb2d1
addq $0x20, %rsp
popq %rbp
retq
nop
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: deleteBipartitionSansRacine(DescTree*, int)
void deleteBipartitionSansRacine(struct DescTree * DT,int taille){
	
	int i,j;
	
	for(i=3*(taille+1);i<=3*(2*taille-2);i++){
		
		for(j=0;j<DT[i].Tableau[0];j++){
			free(DT[i].Matrice[j]);
		}
		free(DT[i].Matrice);
		free(DT[i].Tableau);
	}
	free(DT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
imull $0x3, %eax, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
imull $0x3, %ecx, %ecx
cmpl %ecx, %eax
jg 0xb6db
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jge 0xb69d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb658
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb63b
movq -0x8(%rbp), %rdi
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq 0x1a128(%rip), %rdi     # 0x2583d
movb $0x0, %al
callq 0x1030
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jg 0xb76c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x1a103(%rip), %rdi     # 0x2585d
movb $0x0, %al
callq 0x1030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb723
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0xbc(%rbp)
movl $0x0, -0xc0(%rbp)
movl -0xc0(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xbc2d
movq -0x8(%rbp), %rax
movslq -0xc0(%rbp), %rcx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movl 0x50(%rax), %eax
movq -0x8(%rbp), %rcx
movl -0xc0(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq $0xa8, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x50(%rcx), %eax
jle 0xbc17
movq -0x8(%rbp), %rsi
movslq -0xc0(%rbp), %rax
imulq $0xa8, %rax, %rax
addq %rax, %rsi
leaq -0xb8(%rbp), %rdi
movl $0xa8, %edx
callq 0x1070
movq -0x8(%rbp), %rsi
movl -0xc0(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0xa8, %rax, %rax
addq %rax, %rsi
movq -0x8(%rbp), %rdi
movslq -0xc0(%rbp), %rax
imulq $0xa8, %rax, %rax
addq %rax, %rdi
movl $0xa8, %edx
callq 0x1070
movq -0x8(%rbp), %rdi
movl -0xc0(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0xa8, %rax, %rax
addq %rax, %rdi
leaq -0xb8(%rbp), %rsi
movl $0xa8, %edx
callq 0x1070
movl $0x1, -0xbc(%rbp)
jmp 0xbc19
movl -0xc0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc0(%rbp)
jmp 0xbb36
jmp 0xbc2f
cmpl $0x0, -0xbc(%rbp)
jne 0xbb22
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xc040
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xc035
jmp 0xc040
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc01d
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc0c6
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xc09e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd 0x18fba(%rip), %xmm0    # 0x25030
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xc093
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl $0x1, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc056
cmpl $0x1, -0x20(%rbp)
jne 0xc0b5
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0xc0c4
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x2, (%rax,%rcx,4)
jmp 0xc0d0
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xc106
movl $0x0, -0x4(%rbp)
jmp 0xc189
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0xc16c
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0xc15f
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0xc152
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc154
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc126
jmp 0xc161
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc114
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xc180
movl $0x1, -0x4(%rbp)
jmp 0xc189
jmp 0xc182
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x20(%rbp), %rdx
movl -0xc(%rbp), %eax
movl (%rdx), %ecx
shll %ecx
subl $0x2, %ecx
subl 0x48(%rdx), %ecx
cmpl %ecx, %eax
jg 0xceca
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
je 0xcea4
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0xce8c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xce46
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x10e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xce1b
movq -0x8(%rbp), %rdi
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rax, -0x8(%rbp)
addq $0x3fc, %rdi            # imm = 0x3FC
leaq 0x189ac(%rip), %rsi     # 0x258b1
callq 0x1130
cmpl $0x0, %eax
jne 0xcf1f
leaq -0x40(%rbp), %rdi
leaq 0x1899a(%rip), %rsi     # 0x258b4
callq 0x1080
movq -0x48(%rbp), %rdi
addq $0x3fc, %rdi            # imm = 0x3FC
leaq 0x19631(%rip), %rsi     # 0x26562
callq 0x1130
cmpl $0x0, %eax
jne 0xcf4b
leaq -0x40(%rbp), %rdi
leaq 0x1898b(%rip), %rsi     # 0x258d1
callq 0x1080
movq -0x48(%rbp), %rdi
addq $0x3fc, %rdi            # imm = 0x3FC
leaq 0x18982(%rip), %rsi     # 0x258df
callq 0x1130
cmpl $0x0, %eax
jne 0xcf77
leaq -0x40(%rbp), %rdi
leaq 0x18970(%rip), %rsi     # 0x258e2
callq 0x1080
movq -0x48(%rbp), %rdi
addq $0x3fc, %rdi            # imm = 0x3FC
leaq 0x18973(%rip), %rsi     # 0x258fc
callq 0x1130
cmpl $0x0, %eax
jne 0xcfa3
leaq -0x40(%rbp), %rdi
leaq 0x18961(%rip), %rsi     # 0x258ff
callq 0x1080
movq -0x8(%rbp), %rdi
movq 0x1d14a(%rip), %rdx     # 0x2a0f8
leaq 0x19514(%rip), %rsi     # 0x264c9
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rdi
leaq 0x19230(%rip), %rsi     # 0x261f7
movb $0x0, %al
callq 0x1140
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rdi
addq $0xe9e, %rdx            # imm = 0xE9E
leaq 0x1892c(%rip), %rsi     # 0x25910
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq 0x18930(%rip), %rsi     # 0x2592a
movb $0x0, %al
callq 0x1140
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rdi
addq $0xf0c, %rdx            # imm = 0xF0C
leaq 0x1892d(%rip), %rsi     # 0x25944
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rdi
leaq 0x191ce(%rip), %rsi     # 0x261f7
movb $0x0, %al
callq 0x1140
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x48(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x186ec(%rip), %rsi     # 0x257c9
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xd108
movq -0x8(%rbp), %rsi
leaq 0x18867(%rip), %rdi     # 0x2595e
movb $0x0, %al
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10f0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq 0x19b6f(%rip), %rsi     # 0x26c88
movb $0x0, %al
callq 0x1140
movq -0x18(%rbp), %rdi
callq 0x1090
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1867b(%rip), %rsi     # 0x257c9
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xd179
movq -0x8(%rbp), %rsi
leaq 0x187f6(%rip), %rdi     # 0x2595e
movb $0x0, %al
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10f0
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0xd21f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl -0xc(%rbp), %edx
shll %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl -0xc(%rbp), %edx
shll %edx
subl $0x2, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd20f
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x18771(%rip), %rsi     # 0x25979
movb $0x0, %al
callq 0x1140
jmp 0xd211
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd180
movq -0x20(%rbp), %rdi
leaq 0x18753(%rip), %rsi     # 0x2597d
movb $0x0, %al
callq 0x1140
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0xd2d3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl -0xc(%rbp), %edx
shll %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl -0xc(%rbp), %edx
shll %edx
subl $0x2, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xd2c3
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x186bd(%rip), %rsi     # 0x25979
movb $0x0, %al
callq 0x1140
jmp 0xd2c5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd238
movq -0x20(%rbp), %rdi
callq 0x1090
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0xd596
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd516
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movsd (%rax), %xmm0
movq -0x8(%rbp), %rcx
movsd %xmm0, 0x20(%rcx)
movl 0x30(%rax), %edx
movq -0x8(%rbp), %rcx
movl %edx, 0x50(%rcx)
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rcx
movsd %xmm0, 0x30(%rcx)
movl 0x34(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x8(%rcx)
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x4(%rcx)
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rcx
movsd %xmm0, 0x30(%rcx)
movsd (%rax), %xmm0
movq -0x18(%rbp), %rcx
movsd %xmm0, 0x20(%rcx)
movl 0x30(%rax), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x50(%rcx)
movl 0x34(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x54(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
leaq 0xb8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x10(%rax), %rax
movl (%rax), %eax
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x12b84
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
movq 0x18(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x12b84
movl $0x1, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movl -0x8(%rbp), %eax
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jg 0x12b2f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x8(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x10(%rcx), %rcx
movslq -0x8(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x12b22
movl $0x0, -0x4(%rbp)
jmp 0x12b8b
jmp 0x12b24
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x12aea
movl $0x1, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movl -0x8(%rbp), %eax
movq 0x18(%rcx), %rcx
cmpl (%rcx), %eax
jg 0x12b7b
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x8(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x18(%rcx), %rcx
movslq -0x8(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x12b6e
movl $0x0, -0x4(%rbp)
jmp 0x12b8b
jmp 0x12b70
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x12b36
movl $0x1, -0x4(%rbp)
jmp 0x12b8b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1380a
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x10e0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
shll %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1375c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13715
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x1378f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13763
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x137d6
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x137c9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x137a1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13970
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x10e0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x138b5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x138a8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
jmp 0x138aa
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13855
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x138e8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x138bc
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1392f
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x13922
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x138fa
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x10e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x12041(%rip), %rsi     # 0x259d8
leaq -0x11(%rbp), %rdx
movb $0x0, %al
callq 0x1190
cmpl $-0x1, %eax
je 0x139fd
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
je 0x139fb
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
je 0x139fb
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
je 0x139fb
movsbl -0x11(%rbp), %eax
cmpl $0xd, %eax
je 0x139fb
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x10a0
movsbl -0x11(%rbp), %eax
cmpl $0x28, %eax
jne 0x139f2
movl $0x1, -0x4(%rbp)
jmp 0x13a04
movl $0x0, -0x4(%rbp)
jmp 0x13a04
jmp 0x1398c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x1110
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1160
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0x3b, %eax
jne 0x13a31
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x20, -0x12(%rbp)
movb $0x20, -0x13(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3a, %eax
jne 0x13add
movsbl -0x13(%rbp), %eax
cmpl $0x29, %eax
je 0x13add
cmpl $0x1, -0x18(%rbp)
je 0x13add
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x30, %eax
jl 0x13aff
movsbl -0x11(%rbp), %eax
cmpl $0x39, %eax
jg 0x13aff
movsbl -0x13(%rbp), %eax
cmpl $0x29, %eax
jne 0x13aff
movl $0x1, -0x18(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3a, %eax
jne 0x13b15
cmpl $0x1, -0x18(%rbp)
jne 0x13b15
movl $0x0, -0x18(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x13(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3b, %eax
jne 0x13aa5
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x13a80
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
callq 0xd2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %r8
addq $0x48, %r8
callq 0x8a40
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x48(%rax), %r8d
callq 0x3230
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x48(%rax), %r8d
callq 0x2a10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12664(%rip), %rsi     # 0x2627f
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x1190
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
callq 0xd2f0
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x13cfa
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq 0x12866(%rip), %rsi     # 0x264c9
movb $0x0, %al
callq 0x1190
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1080
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x13cea
movq -0x8(%rbp), %rdi
leaq 0x1177e(%rip), %rsi     # 0x2541b
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x1190
movsd -0x58(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13c8a
jmp 0x13cec
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13c48
addq $0x60, %rsp
popq %rbp
retq
// File: 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 %rbx
subq $0x48, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x64, -0x24(%rbp)
movq -0x10(%rbp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %r9
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rbx
movl -0x14(%rbp), %r10d
movq -0x10(%rbp), %rax
movl (%rax), %eax
leaq -0x24(%rbp), %r8
leaq -0x28(%rbp), %r11
movq %rbx, (%rsp)
movl $0x1, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x4b10
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x48(%rax), %r8d
callq 0x3230
cmpl $0x1, -0x18(%rbp)
jne 0x14418
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movl 0x48(%rax), %ecx
callq 0x2850
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
nop
// File: dcarrey[P]hgt-detection/./fonctions.cpp
// Function: AdjustBranchLength2(InputTree*, InputTree, int, int)
int AdjustBranchLength2(struct InputTree *aTree1, struct InputTree aTree2,int binaire,int useFloyd){

	int i,j,iternumber=100;
	int kt = aTree1->kt;
	
	if(approx_arb(aTree2.ADD,aTree1->ADD,aTree1->ADD,aTree1->W,&iternumber,aTree1->ARETE,aTree1->LONGUEUR,1,&kt,binaire,aTree1->size)==0){
    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
		  return 0;
	  }
	  return -1;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl $0x64, -0x2c(%rbp)
movq -0x18(%rbp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, -0x30(%rbp)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %r9
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rbx
movl -0x1c(%rbp), %r10d
movq -0x18(%rbp), %rax
movl (%rax), %eax
leaq -0x2c(%rbp), %r8
leaq -0x30(%rbp), %r11
movq %rbx, (%rsp)
movl $0x1, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x4b10
cmpl $0x0, %eax
jne 0x1450f
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x48(%rax), %r8d
callq 0x3230
cmpl $0x1, -0x20(%rbp)
jne 0x14506
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movl 0x48(%rax), %ecx
callq 0x2850
movl $0x0, -0xc(%rbp)
jmp 0x14516
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x14516
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq