LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7359
testl %ecx, %ecx
jle 0x734e
pushq %rbp
movq %rsp, %rbp
pushq %rbx
incl %edx
leaq 0x1(%rcx), %rax
xorl %r8d, %r8d
movl $0x1, %r9d
movl (%rdi,%r9,4), %r10d
movl $0x1, %r11d
xorl %ebx, %ebx
cmpl (%rsi,%r11,4), %r10d
sete %bl
addl %ebx, %r8d
incq %r11
cmpq %r11, %rdx
jne 0x732e
incq %r9
cmpq %rax, %r9
jne 0x7324
popq %rbx
popq %rbp
jmp 0x7351
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %ecx, %r8d
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: ListesBranchesPourHGT(int*, long*, int, DescTree*, int*, int*)
void ListesBranchesPourHGT(int *tab_sommets,long int * ARETE, int taille,struct DescTree *DT,int *tab_branches,int *nb_branches){
	
	(*nb_branches) = 0;
	for(int i=1;i<=2*taille-3;i++){
		DT[ARETE[2*i-1]].Tableau[0] = DT[ARETE[2*i-1]].nbSommet;
		DT[ARETE[2*i-2]].Tableau[0] = DT[ARETE[2*i-2]].nbSommet;
		
		if( ((Est_un_sous_ensemble_exact(DT[ARETE[2*i-1]].Tableau,tab_sommets)==1) || (Est_un_sous_ensemble_exact(DT[ARETE[2*i-2]].Tableau,tab_sommets)==1)) ||
		    ((Est_un_sous_ensemble_exact(DT[ARETE[2*i-2]].Tableau,tab_sommets)==1) || (Est_un_sous_ensemble_exact(DT[ARETE[2*i-1]].Tableau,tab_sommets)==1)) ){
			(*nb_branches) ++;
			
			tab_branches[(*nb_branches)] = i;
					
		}	
	}
	
}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movl $0x6672, %eax           # imm = 0x6672
xorl 0x3fc(%r14), %eax
movzbl 0x3fe(%r14), %ecx
orw %ax, %cx
jne 0x7a22
movups 0xde62(%rip), %xmm0     # 0x15875
movups %xmm0, -0x43(%rbp)
movups 0xde4a(%rip), %xmm0     # 0x15868
movaps %xmm0, -0x50(%rbp)
movzwl 0x3fc(%r14), %eax
xorl $0x736c, %eax           # imm = 0x736C
movzbl 0x3fe(%r14), %ecx
orw %ax, %cx
jne 0x7a58
movabsq $0x73657261757173, %rax # imm = 0x73657261757173
movq %rax, -0x4a(%rbp)
movabsq $0x71732d747361656c, %rax # imm = 0x71732D747361656C
movq %rax, -0x50(%rbp)
movzwl 0x3fc(%r14), %eax
xorl $0x6462, %eax           # imm = 0x6462
movzbl 0x3fe(%r14), %ecx
orw %ax, %cx
jne 0x7a88
movups 0xde27(%rip), %xmm0     # 0x158a0
movups %xmm0, -0x46(%rbp)
movups 0xde12(%rip), %xmm0     # 0x15896
movaps %xmm0, -0x50(%rbp)
movzwl 0x3fc(%r14), %eax
xorl $0x6471, %eax           # imm = 0x6471
movzbl 0x3fe(%r14), %ecx
orw %ax, %cx
jne 0x7ab1
movups 0xde0a(%rip), %xmm0     # 0x158b3
movaps %xmm0, -0x50(%rbp)
movb $0x0, -0x40(%rbp)
movq 0x12670(%rip), %rdi     # 0x1a128
movq %rbx, %rsi
callq 0x10c0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1130
leaq 0xe9e(%r14), %rdx
leaq 0xdde9(%rip), %rsi      # 0x158c4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1180
leaq 0xddf2(%rip), %rsi      # 0x158de
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1180
addq $0xf0c, %r14            # imm = 0xF0C
leaq 0xddf0(%rip), %rsi      # 0x158f8
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1180
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1130
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdc24(%rip), %rsi      # 0x15795
callq 0x10e0
testq %rax, %rax
je 0x7ba4
movq %rax, %r12
leaq 0xefaa(%rip), %rsi      # 0x16b2f
movq %rax, %rdi
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1180
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
leaq 0xdd67(%rip), %rdi      # 0x15912
movq %r15, %rsi
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printRootByLeaves(char*, int, InputTree*)
void printRootByLeaves(char *fichier,int choix,struct InputTree *aTree){

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, -0x30(%rbp)
movq %rdi, %r12
leaq 0xdbb7(%rip), %rsi      # 0x15795
callq 0x10e0
testq %rax, %rax
je 0x7cdc
movq %rax, %r14
movl (%rbx), %eax
testl %eax, %eax
jle 0x7c4e
movq -0x30(%rbp), %rcx
addl %ecx, %ecx
movslq %ecx, %r13
leaq 0xdd28(%rip), %r12      # 0x1592d
xorl %r15d, %r15d
movq 0x8(%rbx), %rcx
movq 0x30(%rbx), %rdx
movq 0x8(%rcx,%r15,8), %rcx
movq -0x10(%rdx,%r13,8), %rsi
movq -0x8(%rdx,%r13,8), %rdx
movsd (%rcx,%rsi,8), %xmm0
ucomisd (%rcx,%rdx,8), %xmm0
jbe 0x7c43
movq 0x18(%rbx), %rax
movq 0x8(%rax,%r15,8), %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1180
movl (%rbx), %eax
movslq %eax, %rcx
incq %r15
cmpq %rcx, %r15
jl 0x7c08
leaq 0xdcdc(%rip), %rdi      # 0x15931
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x11f0
movl (%rbx), %eax
testl %eax, %eax
jle 0x7cc6
movq -0x30(%rbp), %rcx
addl %ecx, %ecx
movslq %ecx, %r12
leaq 0xdcb0(%rip), %r15      # 0x1592d
xorl %r13d, %r13d
movq 0x8(%rbx), %rcx
movq 0x30(%rbx), %rdx
movq 0x8(%rcx,%r13,8), %rcx
movq -0x10(%rdx,%r12,8), %rsi
movq -0x8(%rdx,%r12,8), %rdx
movsd (%rcx,%rdx,8), %xmm0
ucomisd (%rcx,%rsi,8), %xmm0
jbe 0x7cbb
movq 0x18(%rbx), %rax
movq 0x8(%rax,%r13,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1180
movl (%rbx), %eax
movslq %eax, %rcx
incq %r13
cmpq %rcx, %r13
jl 0x7c80
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
leaq 0xdc2f(%rip), %rdi      # 0x15912
movq %r12, %rsi
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7cff
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%r14), %r12d
movslq %r12d, %r15
leaq (,%r15,4), %rdi
callq 0x1140
movq %rax, 0x50(%rbx)
shlq $0x3, %r15
movq %r15, %rdi
callq 0x1140
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x1140
movq %rax, 0x28(%rbx)
movq %r15, %rdi
callq 0x1140
movq %rax, 0x10(%rbx)
leal 0x1(%r14), %eax
movl %eax, -0x2c(%rbp)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x40(%rbx)
movq %r14, -0x38(%rbp)
testl %r14d, %r14d
jle 0x7dcd
movl -0x38(%rbp), %r13d
movl %r12d, %r12d
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x1140
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq %r15, %rdi
callq 0x1140
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq %r15, %rdi
callq 0x1140
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
cmpq %r13, %r14
ja 0x7dc5
movq %r15, %rdi
callq 0x1140
movq 0x40(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x7d80
movq -0x38(%rbp), %r14
leal (,%r14,8), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x30(%rbx)
leal (,%r14,4), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, 0x38(%rbx)
movq %r15, %rdi
callq 0x1140
movq %rax, 0x18(%rbx)
testl %r14d, %r14d
js 0x7e33
movl -0x2c(%rbp), %r14d
xorl %r15d, %r15d
movl $0x32, %edi
callq 0x1140
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x7e19
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: freeReducedTree(InputTree*, int)
void freeReducedTree(struct InputTree *aTree,int n){
	int i,j;
	
	for(i=0;i<2*n;i++){
		free(aTree->ADD[i]);
		free(aTree->Adjacence[i]);
		free(aTree->Input[i]);
		free(aTree->W[i]);
		free(aTree->SpeciesName[i]);
	}
	free(aTree->ADD);
	free(aTree->Adjacence);
	free(aTree->Input);
	free(aTree->W);
	free(aTree->ARETE);
	free(aTree->SpeciesName);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x7eae
addl %esi, %esi
cmpl $0x2, %esi
movl $0x1, %r14d
cmovgel %esi, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
cmpq %r15, %r14
jne 0x7e65
movq 0x8(%rbx), %rdi
callq 0x1100
movq 0x28(%rbx), %rdi
callq 0x1100
movq 0x10(%rbx), %rdi
callq 0x1100
movq 0x40(%rbx), %rdi
callq 0x1100
movq 0x30(%rbx), %rdi
callq 0x1100
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: computeCriteria(double**, double**, int, CRITERIA*, double*, long*, double*, long*)
void computeCriteria(double ** Matrix1, double ** Matrix2, int size,struct CRITERIA *aCrit,double *L1, long int *A1,double *L2, long int *A2){

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

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

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

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

}

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rbp), %rax
movq 0x40(%rbp), %rcx
movslq 0x4(%rdi), %rdx
shlq $0x4, %rdx
movq -0x10(%rcx,%rdx), %rdi
movq -0x8(%rcx,%rdx), %r12
movq (%rax,%r12,8), %rdx
movslq 0x30(%rbp), %r8
movq (%rax,%rdi,8), %r9
movsd (%r9,%r8,8), %xmm0
ucomisd (%rdx,%r8,8), %xmm0
cmovaq %rdi, %r12
movslq 0x8(%rbx), %rdx
shlq $0x4, %rdx
movq -0x10(%rcx,%rdx), %rdi
movq -0x8(%rcx,%rdx), %rdx
movq (%rax,%rdx,8), %rcx
movq (%rax,%rdi,8), %rax
movsd (%rax,%r8,8), %xmm0
ucomisd (%rcx,%r8,8), %xmm0
cmovaq %rdi, %rdx
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa1c9
callq 0x1100
movslq %r12d, %rax
leaq (%rax,%rax,2), %r13
movl (%r15,%r13,8), %r14d
leal 0x1(%r14), %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
callq 0x1140
movq %rax, 0x10(%rbx)
movl %r14d, (%rax)
testl %r14d, %r14d
jle 0xa20e
leaq (%r15,%r13,8), %rcx
movq 0x10(%rcx), %rcx
movl %r12d, %edx
movl $0x1, %esi
movl (%rcx,%rsi,4), %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0xa200
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xa21c
callq 0x1100
movslq -0x30(%rbp), %rax
leaq (%rax,%rax,2), %r12
movq %r15, %r13
movl (%r15,%r12,8), %r14d
leal 0x1(%r14), %r15d
movslq %r15d, %rdi
shlq $0x2, %rdi
callq 0x1140
movq %rax, 0x18(%rbx)
movl %r14d, (%rax)
testl %r14d, %r14d
jle 0xa26c
leaq (,%r12,8), %rcx
addq %r13, %rcx
movq 0x10(%rcx), %rcx
movl %r15d, %edx
movl $0x1, %esi
movl (%rcx,%rsi,4), %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0xa25e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: 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 $0x70, %eax
jg 0xa2d9
cmpl $0x62, %eax
je 0xa339
cmpl $0x6c, %eax
jne 0xa3e6
cmpb $0x73, 0x1(%rsi)
jne 0xa3e6
cmpb $0x0, 0x2(%rsi)
jne 0xa3e6
movsd 0x20(%rbx), %xmm0
xorl %ecx, %ecx
ucomisd (%r12), %xmm0
ja 0xa372
jmp 0xa396
cmpl $0x71, %eax
je 0xa379
cmpl $0x72, %eax
jne 0xa3e6
cmpb $0x66, 0x1(%rsi)
jne 0xa3e6
cmpb $0x0, 0x2(%rsi)
jne 0xa3e6
movl 0x50(%rbx), %edx
movl 0x30(%r12), %eax
xorl %ecx, %ecx
cmpl %eax, %edx
jle 0xa31b
movl $0x0, (%rdi)
movl 0x50(%rbx), %edx
movl $0x1, %ecx
cmpl %eax, %edx
jne 0xa396
movsd 0x20(%rbx), %xmm0
ucomisd (%r12), %xmm0
jbe 0xa396
cmpl $0x0, (%rdi)
movl $0x1, %eax
cmovel %eax, %ecx
jmp 0xa396
cmpb $0x64, 0x1(%rsi)
jne 0xa3e6
cmpb $0x0, 0x2(%rsi)
jne 0xa3e6
movsd 0x30(%rbx), %xmm0
xorl %ecx, %ecx
ucomisd 0x10(%r12), %xmm0
seta %al
cmpl $0x2, %r9d
jne 0xa394
leaq 0xb5e6(%rip), %rdi      # 0x15951
xorl %eax, %eax
callq 0x1030
movl $0x1, %ecx
jmp 0xa396
cmpb $0x64, 0x1(%rsi)
jne 0xa3e6
cmpb $0x0, 0x2(%rsi)
jne 0xa3e6
movl 0x54(%rbx), %eax
xorl %ecx, %ecx
cmpl 0x34(%r12), %eax
setg %cl
jmp 0xa396
movb %al, %cl
xorl %eax, %eax
cmpl $0x0, 0xfdb5(%rip)      # 0x1a154
setne %al
cmpl $0x1, 0x70(%rbp)
cmovnel %ecx, %eax
cmpl $0x1, %eax
jne 0xa3dd
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 0xb569(%rip), %rdi      # 0x15956
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: printLeaves(char*, int, HGT*, int, char**)
void printLeaves(char *fichier,int nbHGT,struct HGT *outHGT,int noTree,char **NomsSpecies){

	FILE *out;
	int i,j;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movl %ecx, -0x34(%rbp)
movq %rdx, -0x40(%rbp)
movl %esi, %r14d
leaq 0xaf16(%rip), %rsi      # 0x15740
callq 0x10e0
movq %rax, %r13
movq %r14, -0x30(%rbp)
testl %r14d, %r14d
jle 0xa939
movq -0x30(%rbp), %rax
incl %eax
movq %rax, -0x30(%rbp)
movl $0x1, %r14d
imulq $0xa8, %r14, %r15
movq -0x40(%rbp), %rax
movl (%rax,%r15), %eax
cmpl $0x6, %eax
je 0xa86c
cmpl $0x1, %eax
jne 0xa92c
movq %r14, -0x48(%rbp)
addq -0x40(%rbp), %r15
movq %r13, %rdi
leaq 0xb0fd(%rip), %rsi      # 0x1597b
movl -0x34(%rbp), %edx
xorl %eax, %eax
callq 0x1180
movq 0x10(%r15), %rax
cmpl $0x0, (%rax)
movl $0x3b, %r14d
jle 0xa8dc
movl $0x1, %r12d
movslq (%rax,%r12,4), %rax
movq (%rbx,%rax,8), %rdi
movq %r13, %rsi
callq 0x10c0
movq 0x10(%r15), %rax
movslq (%rax), %rax
cmpq %rax, %r12
movl $0x20, %edi
cmovll %r14d, %edi
movq %r13, %rsi
callq 0x1130
leaq 0x1(%r12), %rcx
movq 0x10(%r15), %rax
movslq (%rax), %rdx
cmpq %rdx, %r12
movq %rcx, %r12
jl 0xa89d
movq 0x18(%r15), %rax
cmpl $0x0, (%rax)
movq -0x48(%rbp), %r14
jle 0xa92c
movl $0x1, %r12d
movslq (%rax,%r12,4), %rax
movq (%rbx,%rax,8), %rdi
movq %r13, %rsi
callq 0x10c0
movq 0x18(%r15), %rax
movslq (%rax), %rcx
cmpq %rcx, %r12
jge 0xa91f
movl $0x3b, %edi
movq %r13, %rsi
callq 0x1130
movq 0x18(%r15), %rax
movslq (%rax), %rcx
leaq 0x1(%r12), %rdx
cmpq %rcx, %r12
movq %rdx, %r12
jl 0xa8ef
incq %r14
cmpq -0x30(%rbp), %r14
jne 0xa84f
movl $0xa, %edi
movq %r13, %rsi
callq 0x1130
movq %r13, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa9d1
leaq 0xb8(%rbp), %rsi
leaq 0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl (%rcx), %edx
movq 0x18(%rsi), %rsi
cmpl (%rsi), %edx
jne 0xa9d1
testl %r8d, %r8d
jle 0xa9ae
incq %r8
movl $0x1, %r10d
movl (%rdi,%r10,4), %r11d
cmpl (%r9,%r10,4), %r11d
jne 0xa9d1
incq %r10
cmpq %r10, %r8
jne 0xa99c
testl %edx, %edx
jle 0xa9cc
incq %rdx
movl $0x1, %edi
movl (%rcx,%rdi,4), %r8d
cmpl (%rsi,%rdi,4), %r8d
jne 0xa9d1
incq %rdi
cmpq %rdi, %rdx
jne 0xa9ba
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: sameHGT2(HGT, HGT)
int sameHGT2(struct HGT HGT1, struct HGT HGT2){
	int i,h1=0,h2=0;

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

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

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


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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xb8(%rbp), %rax
leaq 0x10(%rbp), %r10
movq 0x10(%r10), %r8
movl (%r8), %r9d
movq 0x10(%rax), %rcx
movl (%rcx), %edx
xorl %esi, %esi
movl $0x0, %edi
cmpl %edx, %r9d
jne 0xaa35
testl %r9d, %r9d
jle 0xaa30
leaq 0x1(%r9), %r11
movl $0x1, %edi
movl $0x1, %ebx
xorl %r14d, %r14d
movl (%r8,%rbx,4), %r15d
cmpl (%rcx,%rbx,4), %r15d
cmovnel %r14d, %edi
incq %rbx
cmpq %rbx, %r11
jne 0xaa1a
jmp 0xaa35
movl $0x1, %edi
movq 0x18(%r10), %r10
movl (%r10), %r15d
movq 0x18(%rax), %rbx
movl (%rbx), %r14d
cmpl %r14d, %r15d
jne 0xaa99
movl $0x1, %eax
movl $0x1, %esi
movq %r15, -0x30(%rbp)
testl %r15d, %r15d
jle 0xaa85
movq -0x30(%rbp), %rsi
leaq 0x1(%rsi), %r15
movl $0x1, %esi
movl $0x1, %r12d
xorl %r13d, %r13d
movl (%r10,%r12,4), %r11d
cmpl (%rbx,%r12,4), %r11d
cmovnel %r13d, %esi
incq %r12
cmpq %r12, %r15
jne 0xaa71
cmpl $0x1, %esi
jne 0xaa95
cmpl $0x1, %edi
movq -0x30(%rbp), %r15
je 0xab0f
jmp 0xaa99
movq -0x30(%rbp), %r15
cmpl %r14d, %r9d
jne 0xaace
testl %r9d, %r9d
jle 0xaac9
incl %r9d
movl $0x1, %edi
movl $0x1, %eax
xorl %r14d, %r14d
movl (%r8,%rax,4), %r11d
cmpl (%rbx,%rax,4), %r11d
cmovnel %r14d, %edi
incq %rax
cmpq %rax, %r9
jne 0xaab3
jmp 0xaace
movl $0x1, %edi
cmpl %edx, %r15d
jne 0xab02
testl %edx, %edx
jle 0xaafd
incq %rdx
movl $0x1, %esi
movl $0x1, %eax
xorl %r8d, %r8d
movl (%r10,%rax,4), %r9d
cmpl (%rcx,%rax,4), %r9d
cmovnel %r8d, %esi
incq %rax
cmpq %rax, %rdx
jne 0xaae7
jmp 0xab02
movl $0x1, %esi
xorl $0x1, %esi
xorl $0x1, %edi
xorl %eax, %eax
orl %esi, %edi
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: 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
movl (%r12), %r13d
leal 0x1(%r13), %eax
movl %eax, -0x2c(%rbp)
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1140
movq %rax, %r14
movq %rax, 0x10(%rbx)
movq 0x28(%rbp), %r15
movslq (%r15), %rax
leaq 0x4(,%rax,4), %rdi
callq 0x1140
movq %rax, 0x18(%rbx)
movl %r13d, (%r14)
testl %r13d, %r13d
jle 0xac00
movl -0x2c(%rbp), %ecx
movl $0x1, %edx
movl (%r12,%rdx,4), %esi
movl %esi, (%r14,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0xabf0
movl (%r15), %ecx
movl %ecx, (%rax)
testl %ecx, %ecx
jle 0xac20
incq %rcx
movl $0x1, %edx
movl (%r15,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0xac11
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: updateBootHGT(int, HGT*, int, HGT*, int*, double*)
void updateBootHGT(int first,struct HGT *bestHGT,int cpt_hgt,struct HGT *bootHGT, int *nbHGT_boot, double *tabBoot){
	
	int i,cpt=0,j;

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


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, -0x38(%rbp)
movq %r8, %r14
movq %rcx, %rbx
movq %rsi, %r15
cmpl $0x1, %edi
jne 0xacc4
testl %edx, %edx
jle 0xadb3
movl %edx, %r12d
addq $0xa8, %r15
xorl %r13d, %r13d
movl (%r15), %eax
cmpl $0x6, %eax
je 0xac77
cmpl $0x1, %eax
jne 0xacb3
movslq %r13d, %rax
incl %r13d
movq -0x38(%rbp), %rcx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rdx, 0x8(%rcx,%rax,8)
incq %rax
imulq $0xa8, %rax, %rax
addq %rbx, %rax
movl $0x15, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0xab1a
addq $0xa8, %r15
decq %r12
jne 0xac6a
jmp 0xadb6
movq %rbx, -0x40(%rbp)
movl (%r14), %eax
movq %rax, -0x30(%rbp)
testl %eax, %eax
jle 0xadb9
leal 0x1(%rdx), %ecx
incq -0x30(%rbp)
movl $0x1, %esi
movsd 0xa37d(%rip), %xmm0     # 0x15068
movq %rdx, -0x48(%rbp)
testl %edx, %edx
jle 0xada0
imulq $0xa8, %rsi, %rdi
leaq (%r15,%rdi), %r8
addq -0x40(%rbp), %rdi
movl $0x1, %r9d
imulq $0xa8, %r9, %r11
cmpl $0x1, (%r15,%r11)
je 0xad20
cmpl $0x6, (%r8)
jne 0xad94
addq %r15, %r11
movq 0x10(%rdi), %r13
movq 0x10(%r11), %r14
movl (%r13), %eax
cmpl (%r14), %eax
jne 0xad94
movq 0x18(%rdi), %r10
movq 0x18(%r11), %r11
movl (%r10), %r12d
cmpl (%r11), %r12d
jne 0xad94
testl %eax, %eax
jle 0xad63
incq %rax
movl $0x1, %edx
movl (%r13,%rdx,4), %ebx
cmpl (%r14,%rdx,4), %ebx
jne 0xad94
incq %rdx
cmpq %rdx, %rax
jne 0xad50
testl %r12d, %r12d
jle 0xad82
incq %r12
movl $0x1, %eax
movl (%r10,%rax,4), %edx
cmpl (%r11,%rax,4), %edx
jne 0xad94
incq %rax
cmpq %rax, %r12
jne 0xad70
movq -0x38(%rbp), %rax
movsd (%rax,%rsi,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rsi,8)
incq %r9
cmpq %rcx, %r9
jne 0xad0c
incq %rsi
cmpq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rdx
jne 0xacef
jmp 0xadb9
xorl %r13d, %r13d
movl %r13d, (%r14)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb07c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x1100
movq 0x30(%rbx), %rdi
callq 0x1100
cmpl $0x0, (%rbx)
jle 0xaff0
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
movslq (%rbx), %rax
leaq -0x1(,%rax,2), %rax
cmpq %rax, %r15
jl 0xafc3
testl %r14d, %r14d
jle 0xb01e
leal (%r14,%r14), %eax
cmpl $0x2, %eax
movl $0x1, %r15d
cmovgel %eax, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x1100
incq %r12
cmpq %r12, %r15
jne 0xb009
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xb050
testl %r14d, %r14d
js 0xb04b
incl %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
cmpq %r15, %r14
jne 0xb032
movq 0x18(%rbx), %rdi
callq 0x1100
movq 0x8(%rbx), %rdi
callq 0x1100
movq 0x28(%rbx), %rdi
callq 0x1100
movq 0x40(%rbx), %rdi
callq 0x1100
movq 0x50(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1100
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb19b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x1100
movq 0x30(%rbx), %rdi
callq 0x1100
testl %r14d, %r14d
jle 0xb12e
leal (%r14,%r14), %eax
movl %r14d, %r12d
cmpl $0x2, %eax
movl $0x1, %r13d
movl %eax, -0x2c(%rbp)
cmovgel %eax, %r13d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
cmpq %r12, %r15
ja 0xb0f9
movq 0x40(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
cmpq %r15, %r13
jne 0xb0cd
testl %r14d, %r14d
jle 0xb12e
movl -0x2c(%rbp), %eax
cmpl $0x2, %eax
movl $0x1, %r15d
cmovgel %eax, %r15d
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x1100
incq %r12
cmpq %r12, %r15
jne 0xb119
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xb160
testl %r14d, %r14d
js 0xb15b
incl %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1100
incq %r15
cmpq %r15, %r14
jne 0xb142
movq 0x18(%rbx), %rdi
callq 0x1100
movq 0x8(%rbx), %rdi
callq 0x1100
movq 0x28(%rbx), %rdi
callq 0x1100
movq 0x10(%rbx), %rdi
callq 0x1100
movq 0x40(%rbx), %rdi
callq 0x1100
movq 0x50(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: nextTreeIsNewick(_IO_FILE*)
int nextTreeIsNewick(FILE *in){
	
	char c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa7d8(%rip), %rsi      # 0x1598c
leaq -0x29(%rbp), %rdx
xorl %eax, %eax
callq 0x11e0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0xb225
movabsq $0x100002600, %r13      # imm = 0x100002600
leaq 0xa7b1(%rip), %r15      # 0x1598c
leaq -0x29(%rbp), %r12
movzbl -0x29(%rbp), %eax
cmpq $0x20, %rax
ja 0xb206
btq %rax, %r13
jae 0xb206
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x11e0
cmpl $-0x1, %eax
jne 0xb1df
jmp 0xb225
movq %rbx, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x10b0
xorl %r14d, %r14d
cmpb $0x28, -0x29(%rbp)
sete %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb2c1
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 0xb28f
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb27c
movl %eax, (%rbx)
leal 0x1(%rax), %esi
movq %rbx, %rdi
callq 0x7cf7
movq 0x18(%rbx), %rcx
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
leaq 0x48(%rbx), %r8
movq %r14, %rdi
callq 0x519d
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl (%rbx), %ecx
movl 0x48(%rbx), %r8d
callq 0x2215
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 0x1d65
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: readMatrix(_IO_FILE*, InputTree*)
void readMatrix(FILE *in,struct InputTree *aTree){
	
	int n,i,j;
	char name[50];
	double value;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %eax
movq %rdi, %rbx
leaq -0x18(%rbp), %r8
movl $0x64, (%r8)
movl 0x48(%rdi), %ecx
leaq -0x14(%rbp), %r10
movl %ecx, (%r10)
movq 0x18(%rbp), %rdi
movq 0x8(%rbx), %rdx
movq 0x30(%rbx), %r9
movl (%rbx), %ecx
subq $0x8, %rsp
movq %rdx, %rsi
pushq %rcx
pushq %rax
pushq %r10
pushq $0x1
pushq 0x38(%rbx)
callq 0x319a
addq $0x30, %rsp
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl (%rbx), %ecx
movl 0x48(%rbx), %r8d
callq 0x2215
cmpl $0x1, %r14d
jne 0xb819
movq 0x28(%rbx), %rdi
movq 0x8(%rbx), %rsi
movl (%rbx), %edx
movl 0x48(%rbx), %ecx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1cad
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %eax
movq %rdi, %rbx
leaq -0x20(%rbp), %r8
movl $0x64, (%r8)
movl 0x48(%rdi), %ecx
leaq -0x1c(%rbp), %r10
movl %ecx, (%r10)
movq 0x18(%rbp), %rdi
movq 0x8(%rbx), %rdx
movq 0x30(%rbx), %r9
movl (%rbx), %ecx
subq $0x8, %rsp
movq %rdx, %rsi
pushq %rcx
pushq %rax
pushq %r10
pushq $0x1
pushq 0x38(%rbx)
callq 0x319a
addq $0x30, %rsp
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xb8ac
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl (%rbx), %ecx
movl 0x48(%rbx), %r8d
callq 0x2215
cmpl $0x1, %r14d
jne 0xb8ac
movq 0x28(%rbx), %rdi
movq 0x8(%rbx), %rsi
movl (%rbx), %edx
movl 0x48(%rbx), %ecx
callq 0x1cad
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq