LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/QFSW[P]MIPS1-Simulator/src/Simulator.cpp
// Function: Clarkitechture::MIPS::Simulator::executeNext()
void Simulator::executeNext()
{
    reg.PC += 4;
    size_t index = currInstrIndex();
    std::shared_ptr<Instruction> currentInstr;
    
    if (index < instrCount)
    {
        currentInstr = instrs[index];
        currentInstr->execute(mem, reg);
    }
    else { currentInstr = nullptr; }
    if (previousInstr) { previousInstr->delayedExecute(mem, reg); }
    
    if (!currentInstr && !previousInstr)
    {
        throw BadProgramCounter(reg.PC - 4, "PC was outside of the instruction memory space.");
    }
    
    previousInstr = currentInstr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
addl $0x4, 0x30(%rdi)
callq 0x9d18
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
cmpq (%rbx), %rax
jae 0x9c09
movq 0x8(%rbx), %rcx
shll $0x4, %eax
leaq (%rcx,%rax), %rsi
addq $0x8, %rsi
movq -0x8(%rsi), %rax
leaq 0x8(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
callq 0x9f72
movq -0x8(%r15), %rdi
leaq 0xc0(%rbx), %rsi
movq (%rdi), %rax
movq %r14, %rdx
callq *(%rax)
jmp 0x9c0d
movaps %xmm0, (%rsp)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x9c30
leaq 0xc0(%rbx), %rsi
movq (%rdi), %rax
movq %r14, %rdx
callq *0x8(%rax)
cmpq $0x0, 0x20(%rbx)
setne %al
jmp 0x9c32
xorl %eax, %eax
movq (%rsp), %rcx
testq %rcx, %rcx
jne 0x9c3f
testb %al, %al
je 0x9c71
movq %rcx, 0x20(%rbx)
addq $0x28, %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9f72
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9c64
callq 0x9f02
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0x5100
movq %rax, %rbx
movl (%r14), %ebp
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x21ce(%rip), %rsi      # 0xbe5f
leaq 0x21f6(%rip), %rdx      # 0xbe8e
leaq 0x10(%rsp), %rdi
callq 0x7e20
addl $-0x4, %ebp
movb $0x1, %r12b
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6216
xorl %r12d, %r12d
leaq 0x613f(%rip), %rsi      # 0xfe00
leaq -0x33b6(%rip), %rdx     # 0x6912
movq %rbx, %rdi
callq 0x5380
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x9cea
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x5210
testb %r12b, %r12b
jne 0x9cf4
jmp 0x9d01
movq %rax, %r14
movq %rbx, %rdi
callq 0x5190
jmp 0x9d01
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9d10
callq 0x9f02
movq %r14, %rdi
callq 0x53a0
// File: /workspace/github_cpp_makefile_star2_O3/kchan1[P]helloworld_test1/./encoder.hh
// Function: markTree(int, int, int, int, int, unsigned char**)
void markTree(int width, int height, int depth,int x,int y,unsigned char**coded)
{
  //quickly determind what layer we are at
  int layer = depth;
  while(x > width>>layer)
    layer++;
  //first mark this node
  coded[x][y]='T';
  //if this is the deepest level, there are three children to mark
  if(x < width>>depth && y < height>>depth)
  {
    markTree(width,height,depth,
	     x+(width>>depth),y,
	     coded);
    markTree(width,height,depth,
	     x,y+(height>>depth),
	     coded);
    markTree(width,height,depth,
	     x+(width>>depth),y+(height>>depth),
	     coded);
  }
  //if this is the lowest level, there are no children to mark
  else if(x > width/2 && y > height/2)
  {
    return;
  }
  //otherwise there are 4 children to mark
  else
  {
    markTree(width,height,depth,
	     x*2,y*2,
	     coded);
    markTree(width,height,depth,
	     x*2+1,y*2,
	     coded);
    markTree(width,height,depth,
	     x*2,y*2+1,
	     coded);
    markTree(width,height,depth,
	     x*2+1,y*2+1,
	     coded);    
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x18(%rsp)
movl %r8d, %r14d
movl %ecx, %r13d
movl %edx, %ecx
movl %edi, %r8d
sarl %cl, %r8d
movl %esi, %r9d
movl %edx, 0x14(%rsp)
sarl %cl, %r9d
movl %edi, %eax
shrl $0x1f, %eax
movl %edi, 0xc(%rsp)
addl %edi, %eax
sarl %eax
movl %eax, 0x28(%rsp)
movl %esi, %eax
shrl $0x1f, %eax
movl %esi, 0x10(%rsp)
addl %esi, %eax
sarl %eax
movl %eax, 0x24(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x8(%rsp)
movslq %r13d, %rax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rcx
movslq %r14d, %rdx
movb $0x54, (%rcx,%rdx)
cmpl %eax, %r8d
setg %al
cmpl %edx, %r9d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2448
leal (%r8,%r13), %ecx
movl %ecx, 0x4(%rsp)
movl 0xc(%rsp), %ebx
movl %ebx, %edi
movl 0x10(%rsp), %r12d
movl %r12d, %esi
movl 0x14(%rsp), %r15d
movl %r15d, %edx
movl %r14d, %r8d
movq 0x18(%rsp), %rbp
movq %rbp, %r9
callq 0x236c
addl 0x8(%rsp), %r14d
movl %ebx, %edi
movl %r12d, %esi
movl %r15d, %edx
movl %r13d, %ecx
movl %r14d, %r8d
movq %rbp, %r9
callq 0x236c
movl 0x8(%rsp), %r9d
movq 0x30(%rsp), %r8
movl 0x4(%rsp), %eax
movl %eax, %r13d
jmp 0x23c3
cmpl %r13d, 0x28(%rsp)
jge 0x245a
cmpl %r14d, 0x24(%rsp)
jl 0x24e0
leal (,%r13,2), %ecx
movl %ecx, 0x4(%rsp)
leal (%r14,%r14), %r8d
movl %r8d, 0x2c(%rsp)
movl 0xc(%rsp), %r15d
movl %r15d, %edi
movq 0x18(%rsp), %rbp
movl 0x10(%rsp), %ebx
movl %ebx, %esi
movl 0x14(%rsp), %r12d
movl %r12d, %edx
movq %rbp, %r9
callq 0x236c
leal 0x1(,%r13,2), %r13d
movl %r15d, %edi
movl %ebx, %esi
movl %r12d, %edx
movl %r13d, %ecx
movl 0x2c(%rsp), %r8d
movq %rbp, %r9
callq 0x236c
leal 0x1(,%r14,2), %r14d
movl %r15d, %edi
movl %ebx, %esi
movl %r12d, %edx
movl 0x4(%rsp), %ecx
movl %r14d, %r8d
movq %rbp, %r9
callq 0x236c
movl 0x8(%rsp), %r9d
movq 0x30(%rsp), %r8
jmp 0x23c3
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kchan1[P]helloworld_test1/./encoder.hh
// Function: subordinate_pass(double**, int, IntQueue*, double**, BitWriter*)
void subordinate_pass(double**image,int threshold,IntQueue*sub_list,double**recon_coeff,BitWriter*bitstream)
{
  int coord,x,y;
  //empty out the sub_list
  while(sub_list->size>0)
  {
    //separate x and y from the compact form used in the list
    coord = sub_list->DQ();
    x=coord>>16&0xFFFF;
    y=coord&0xFFFF;
    //as in the algorithm
    if(image[x][y]>recon_coeff[x][y])
    {
      bitstream->write(1);
      recon_coeff[x][y]+=threshold/2;
    }
    else
    {
      bitstream->write(0);
      recon_coeff[x][y]-=threshold/2;
    }
  }
}

// Assembly:
movl 0x4(%rdx), %eax
testl %eax, %eax
je 0x2ba3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl %esi, %ecx
shrl $0x1f, %ecx
addl %esi, %ecx
sarl %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, (%rsp)
decl %eax
movl %eax, 0x4(%r15)
movq 0x10(%r15), %rax
movl 0x8(%r15), %ecx
movl (%rax,%rcx,4), %ebp
leal 0x1(%rcx), %eax
xorl %edx, %edx
divl (%r15)
movl %edx, 0x8(%r15)
movzwl %bp, %r13d
shrl $0x10, %ebp
movl %ebp, %eax
shll $0x3, %eax
movq (%r12,%rax), %rcx
leal (,%r13,8), %edx
movsd (%rcx,%rdx), %xmm0
movq (%r14,%rax), %rax
ucomisd (%rax,%rdx), %xmm0
jbe 0x2b6a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4f72
movq (%r14,%rbp,8), %rax
movsd (%rax,%r13,8), %xmm0
addsd (%rsp), %xmm0
jmp 0x2b83
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4f72
movq (%r14,%rbp,8), %rax
movsd (%rax,%r13,8), %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rax,%r13,8)
movl 0x4(%r15), %eax
testl %eax, %eax
jne 0x2b07
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kchan1[P]helloworld_test1/main.cpp
// Function: prepare(double**&, int, int, int)
void prepare(double** &image_data, int height, int width, int quant){
	
	for (int i = 0; i<height; i++){
		for(int j=0; j<height; j++){
			image_data[i][j]=(int)image_data[i][j];
		}
	}

	int max = 0;
	for (int i = 0; i<height; i++){
		for(int j=0; j<height; j++){
			image_data[i][j]=(int)(image_data[i][j]/quant)*quant;
			image_data[i][j]=image_data[i][j]/quant;
			if (image_data[i][j] < -126){
				image_data[i][j] = -126;
			}
			if (image_data[i][j] > 127){
				image_data[i][j]= 127;
			}
			if (abs(image_data[i][j]) > max){
				max = abs(image_data[i][j]);
			}
			//image_data[i][j]*=quant;
			//std::cout<<image_data[i][j]<<" ";
		}
	}
	//std::cout<<max<<std::endl;
	

}

// Assembly:
testl %esi, %esi
jle 0x3f81
movq (%rdi), %rdx
movl %esi, %eax
xorl %r8d, %r8d
movq (%rdx,%r8,8), %r9
xorl %r10d, %r10d
movsd (%r9,%r10,8), %xmm0
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movlpd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rax
jne 0x3ee7
incq %r8
cmpq %rax, %r8
jne 0x3ee0
testl %esi, %esi
jle 0x3f81
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movq (%rdi), %rdx
xorl %esi, %esi
movsd 0x2225(%rip), %xmm1     # 0x6148
movsd 0x2225(%rip), %xmm2     # 0x6150
movq (%rdx,%rsi,8), %rdi
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm3
divsd %xmm0, %xmm3
cvttsd2si %xmm3, %r9d
imull %ecx, %r9d
xorps %xmm3, %xmm3
cvtsi2sd %r9d, %xmm3
divsd %xmm0, %xmm3
movsd %xmm3, (%rdi,%r8,8)
ucomisd %xmm3, %xmm1
movapd %xmm1, %xmm4
ja 0x3f6b
ucomisd %xmm2, %xmm3
movapd %xmm2, %xmm4
jbe 0x3f71
movsd %xmm4, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x3f32
incq %rsi
cmpq %rax, %rsi
jne 0x3f2b
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: TrierTableau(int*, int)
void TrierTableau(int tableau[],int taille){

	int i, inversion,tmp;
	do
	{
		inversion=0;

		for(i=1;i<taille;i++)
		{
			if (tableau[i]>tableau[i+1])
			{
				tmp = tableau[i];
				tableau[i] = tableau[i+1];
				tableau[i+1] = tmp;
				inversion=1;
			}
		}
	}
	while(inversion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %esi
jl 0x1c68
movl %esi, %eax
movl 0x4(%rdi), %ecx
xorl %r8d, %r8d
movl $0x1, %edx
movl 0x4(%rdi,%rdx,4), %r9d
cmpl %r9d, %ecx
jle 0x1c53
movl %r9d, (%rdi,%rdx,4)
movl %ecx, 0x4(%rdi,%rdx,4)
movl $0x1, %r8d
jmp 0x1c56
movl %r9d, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x1c39
testl %r8d, %r8d
je 0x1c68
cmpl $0x1, %esi
jg 0x1c2e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: vecteursEgaux(DescTree, DescTree)
int vecteursEgaux(struct DescTree DTSpecies, struct DescTree DTGene){

	int Tspecies = DTSpecies.nbSommet;
	int Tgene = DTGene.nbSommet;
	int i;

	if(Tspecies != Tgene) return 0;

	for(i=1;i<=Tspecies;i++)
		if(DTSpecies.Tableau[i] != DTGene.Tableau[i])
			return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %ecx
xorl %eax, %eax
cmpl 0x28(%rbp), %ecx
jne 0x1cab
testl %ecx, %ecx
jle 0x1ca6
leaq 0x28(%rbp), %rsi
leaq 0x10(%rbp), %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rsi), %rsi
incq %rcx
movl $0x1, %edi
movl (%rdx,%rdi,4), %r8d
cmpl (%rsi,%rdi,4), %r8d
jne 0x1cab
incq %rdi
cmpq %rdi, %rcx
jne 0x1c94
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: Floyd(double**, double**, int, int)
void Floyd(double ** Adjacence , double ** DIST,int n,int kt)
{
	int i,j,k;

	for(i=1;i<=2*n-2-kt;i++)
		for(j=1;j<=2*n-2-kt;j++)
		{
			if(i==j)
				DIST[i][j] = 0;
			else
				DIST[i][j] = Adjacence[i][j];
		}

		for(i=1;i<=2*n-2-kt;i++)
			for(j=1;j<=2*n-2-kt;j++)
				for(k=1;k<=2*n-2-kt;k++)
				{
					if((DIST[j][i] + DIST[i][k]) < DIST[j][k])
						DIST[j][k] = DIST[j][i] + DIST[i][k];
				}
}

// Assembly:
addl %edx, %edx
movl %edx, %eax
subl %ecx, %eax
addl $-0x2, %eax
testl %eax, %eax
jle 0x1d64
pushq %rbp
movq %rsp, %rbp
pushq %rbx
notl %ecx
addl %ecx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movq (%rsi,%rcx,8), %r9
movl $0x1, %r10d
leaq (%r8,%r10), %rbx
xorpd %xmm0, %xmm0
movq %rcx, %r11
cmpq $0x1, %rbx
je 0x1cf7
movq (%rdi,%rcx,8), %r11
movsd (%r11,%r10,8), %xmm0
movq %r10, %r11
movsd %xmm0, (%r9,%r11,8)
incq %r10
cmpq %r10, %rdx
jne 0x1cd9
incq %rcx
decq %r8
cmpq %rdx, %rcx
jne 0x1ccf
testl %eax, %eax
jle 0x1d62
movl $0x1, %eax
movq (%rsi,%rax,8), %rcx
movl $0x1, %edi
movq (%rsi,%rdi,8), %r8
movl $0x1, %r9d
movsd (%r8,%rax,8), %xmm0
addsd (%rcx,%r9,8), %xmm0
movsd (%r8,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1d4a
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x1d2c
incq %rdi
cmpq %rdx, %rdi
jne 0x1d22
incq %rax
cmpq %rdx, %rax
jne 0x1d19
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: Floyd(double**, double**, double**, int, int)
void Floyd(double ** Adjacence , double ** DIST,double **DIST2,int n,int kt)
{
	int i,j,k1;

	for(i=1;i<=2*n-2-kt;i++)
		for(j=1;j<=2*n-2-kt;j++)
		{
			if(i==j)
				DIST[i][j] = DIST2[i][j] = 0;
			else
				DIST[i][j] = DIST2[i][j] = Adjacence[i][j];
		}

		for(i=1;i<=2*n-2-kt;i++)
			for(j=1;j<=2*n-2-kt;j++)
				for(k1=1;k1<=2*n-2-kt;k1++)
				{
					if((DIST[j][i] + DIST[i][k1]) < DIST[j][k1])
						DIST[j][k1] = DIST2[j][k1] = DIST[j][i] + DIST[i][k1];
				}
}

// Assembly:
addl %ecx, %ecx
movl %ecx, %eax
subl %r8d, %eax
addl $-0x2, %eax
testl %eax, %eax
jle 0x1e3c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
notl %r8d
addl %r8d, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
movq (%rdx,%r8,8), %r10
movq (%rsi,%r8,8), %r11
movl $0x1, %ebx
leaq (%r9,%rbx), %r15
xorpd %xmm0, %xmm0
movq %r8, %r14
cmpq $0x1, %r15
je 0x1dba
movq (%rdi,%r8,8), %r14
movsd (%r14,%rbx,8), %xmm0
movq %rbx, %r14
movsd %xmm0, (%r10,%r14,8)
movsd %xmm0, (%r11,%r14,8)
incq %rbx
cmpq %rbx, %rcx
jne 0x1d9c
incq %r8
decq %r9
cmpq %rcx, %r8
jne 0x1d8f
testl %eax, %eax
jle 0x1e36
movl $0x1, %eax
movq (%rsi,%rax,8), %rdi
movl $0x1, %r8d
movq (%rsi,%r8,8), %r9
movl $0x1, %r10d
movsd (%r9,%rax,8), %xmm0
addsd (%rdi,%r10,8), %xmm0
movsd (%r9,%r10,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1e1e
movq (%rdx,%r8,8), %r11
movsd %xmm0, (%r11,%r10,8)
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0x1df6
incq %r8
cmpq %rcx, %r8
jne 0x1dec
incq %rax
cmpq %rcx, %rax
jne 0x1de2
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: loadAdjacenceMatrix(double**, long*, double*, int, int)
void loadAdjacenceMatrix( double **Adjacence, long int *ARETE, double *LONGUEUR,int size,int kt){
	
	int i,j;
	
	for(i=1;i<=2*size-2;i++) /*/(n+1)*/
		for(j=1;j<=2*size-2;j++){
			Adjacence[i][j] = Adjacence[j][i] = INFINI;
      //printf("i=%d,j=%d",i,j);
}
	for(i=1;i<=2*size-3-kt;i++){
		Adjacence[ARETE[2*i-2]][ARETE[2*i-1]] = LONGUEUR[i-1];//(LONGUEUR[i-1]>5*epsilon)?LONGUEUR[i-1]:5*epsilon;
		Adjacence[ARETE[2*i-1]][ARETE[2*i-2]] = LONGUEUR[i-1]; //(LONGUEUR[i-1]>5*epsilon)?LONGUEUR[i-1]:5*epsilon;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leal (%rcx,%rcx), %r9d
leal -0x2(,%rcx,2), %eax
cmpl $0x2, %ecx
jl 0x2274
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
leal 0x1(%rcx), %r10d
movl $0x1, %r11d
movabsq $0x412e847ffae147ae, %rbx # imm = 0x412E847FFAE147AE
movq (%rdi,%r11,8), %r14
xorl %r15d, %r15d
movq 0x8(%rdi,%r15,8), %r12
movq %rbx, (%r12,%r11,8)
movq %rbx, 0x8(%r14,%r15,8)
incq %r15
cmpq %r15, %rcx
jne 0x2256
incq %r11
cmpq %r10, %r11
jne 0x224f
subl %r8d, %r9d
addl $-0x3, %r9d
testl %r9d, %r9d
jle 0x22b8
subl %r8d, %eax
addq $0x8, %rsi
decq %rax
xorl %ecx, %ecx
movsd (%rdx,%rcx,8), %xmm0
movq -0x8(%rsi), %r8
movq (%rsi), %r9
movq (%rdi,%r8,8), %r10
movsd %xmm0, (%r10,%r9,8)
movq (%rdi,%r9,8), %r9
movsd %xmm0, (%r9,%r8,8)
addq $0x10, %rsi
incq %rcx
cmpq %rcx, %rax
jne 0x228c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: odp1(double**, int*, int*, int*, int)
void odp1(double **D, int *X, int *i1, int *j1, int n)
{
	double S1,S;
	int i,j,k,a,*Y1;

	Y1=(int *) malloc((n+1)*sizeof(int));

	for(i=1;i<=n;i++)
		Y1[i]=1;

	X[1]=*i1;
	X[n]=*j1;
	if (n==2){
		free(Y1);
		return;
	}
	Y1[*i1]=0;
	Y1[*j1]=0;
	for(i=0;i<=n-3;i++)
	{ a=2;
	S=0;
	for(j=1;j<=n;j++)
	{ if (Y1[j]>0)
	{
		S1= D[X[n-i]][X[1]]-D[j][X[1]]+D[X[n-i]][j];
		if ((a==2)||(S1<=S))
		{
			S=S1;
			a=1;
			X[n-i-1]=j;
			k=j;
		}
	}
	}
	Y1[k]=0;
	}     
	free(Y1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leal 0x1(%rbx), %r13d
movslq %r13d, %rdi
shlq $0x2, %rdi
callq 0x1140
testl %ebx, %ebx
jle 0x23ce
movq %r12, %rsi
movq -0x30(%rbp), %r12
movl %r13d, %ecx
movl $0x1, %edx
movl $0x1, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x2306
movq %rsi, %rdi
movl (%rsi), %edx
movl %edx, 0x4(%r14)
movslq (%r12), %rsi
movl %ebx, %edx
movl %esi, (%r14,%rdx,4)
cmpl $0x2, %ebx
je 0x23e3
movslq (%rdi), %rdi
xorl %r8d, %r8d
movl %r8d, (%rax,%rdi,4)
movl %r8d, (%rax,%rsi,4)
cmpl $0x3, %ebx
jl 0x23e3
addl $-0x2, %ebx
xorl %esi, %esi
movq %rdx, %r8
subq %rsi, %r8
movl $0x2, %r9d
xorpd %xmm0, %xmm0
movl $0x1, %r10d
cmpl $0x0, (%rax,%r10,4)
jle 0x239f
movslq (%r14,%r8,4), %r11
movq (%r15,%r11,8), %r11
movslq 0x4(%r14), %r12
movsd (%r11,%r12,8), %xmm1
movq (%r15,%r10,8), %r13
subsd (%r13,%r12,8), %xmm1
addsd (%r11,%r10,8), %xmm1
cmpl $0x2, %r9d
movl $0x1, %r9d
je 0x23a5
ucomisd %xmm1, %xmm0
jae 0x23a5
movapd %xmm0, %xmm1
jmp 0x23ad
movl %r10d, -0x4(%r14,%r8,4)
movl %r10d, %edi
incq %r10
movapd %xmm1, %xmm0
cmpq %r10, %rcx
jne 0x2363
movslq %edi, %r8
movl $0x0, (%rax,%r8,4)
incq %rsi
cmpq %rbx, %rsi
jne 0x234d
jmp 0x23e3
movl (%r12), %ecx
movl %ecx, 0x4(%r14)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movslq %ebx, %rdx
movl %ecx, (%r14,%rdx,4)
movq %rax, %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/./utils_tree.cpp
// Function: Table_Comparaison(int**, int**, int*, int*, int, int, int)
int Table_Comparaison (int **B, int ** B1, int *PLACE, int *PLACE1, int m, int m1,int n)
{
	int RF=0,i,p,p1;

	p=1; p1=1;

	while ((p<=m)&&(p1<=m1))
	{
		i=n;
		while ((B[PLACE[p]][i]==B1[PLACE1[p1]][i])&&(i>1))
			i--;
		if (i==1) { RF=RF+1; p++; p1++; }
		else if (B[PLACE[p]][i]>B1[PLACE1[p1]][i]) p1++;
		else p++; 

	}
	RF=(m-RF)+(m1-RF);

	return RF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r9d, %eax
movq %rcx, -0x38(%rbp)
testl %r8d, %r8d
setle %r9b
testl %eax, %eax
setle %r10b
xorl %ecx, %ecx
orb %r9b, %r10b
jne 0x318a
movslq 0x10(%rbp), %rcx
movl $0x0, -0x2c(%rbp)
movl $0x1, %r11d
movl $0x1, %ebx
movslq %ebx, %r10
movslq (%rdx,%r10,4), %r10
movq (%rdi,%r10,8), %r14
movslq %r11d, %r10
movq -0x38(%rbp), %r9
movslq (%r9,%r10,4), %r10
movq (%rsi,%r10,8), %r13
movq %rcx, %r9
movq %r9, %r10
movl (%r14,%r9,4), %r15d
movl (%r13,%r9,4), %r12d
decq %r9
cmpq $0x2, %r10
jl 0x3165
cmpl %r12d, %r15d
je 0x314b
testq %r9, %r9
je 0x3173
cmpl %r12d, %r15d
jg 0x3178
incl %ebx
jmp 0x317b
incl -0x2c(%rbp)
incl %ebx
incl %r11d
cmpl %r8d, %ebx
jg 0x3185
cmpl %eax, %r11d
jle 0x312e
movl -0x2c(%rbp), %ecx
addl %ecx, %ecx
addl %r8d, %eax
subl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: findFils(double**, int, int)
int findFils(double ** Adjacence,int sommet,int n){

	int i;
	
	for(i=1;i<=2*n-2;i++){
		if(Adjacence[sommet][i]<INFINI){
			Adjacence[sommet][i] = Adjacence[i][sommet] = INFINI;
			return i;
		}
	}
	return -1;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %edx
jl 0x49cb
pushq %rbp
movq %rsp, %rbp
leal -0x2(,%rdx,2), %edx
movslq %esi, %rcx
cmpl $0x2, %edx
movl $0x1, %esi
cmovgel %edx, %esi
movq (%rdi,%rcx,8), %rdx
negq %rsi
movl $0x1, %r8d
movsd 0x106b1(%rip), %xmm0    # 0x15048
ucomisd (%rdx,%r8,8), %xmm0
ja 0x49b1
leaq (%rsi,%r8), %r9
incq %r9
incq %r8
cmpq $0x1, %r9
jne 0x4997
jmp 0x49ca
movq (%rdi,%r8,8), %rax
movabsq $0x412e847ffae147ae, %rsi # imm = 0x412E847FFAE147AE
movq %rsi, (%rax,%rcx,8)
movq %rsi, (%rdx,%r8,8)
movl %r8d, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: CreerSousArbre(long*, int*, double**, int, int)
struct TNoeud * CreerSousArbre(long int *ARETE,int *indice, double ** Adjacence,int sommet,int n){

	int i=0;
	int *tableau;
	int nbElt=0;
	int nouveauFils;
	struct TNoeud * node;

	if(sommet==-1)
		return NULL;

	tableau = (int*)malloc(100*sizeof(int));

	node = (struct TNoeud*)malloc(sizeof(struct TNoeud));
	node->NoNoeud = sommet;
	node->nbfils = 0;
	node->fils = (struct TNoeud**)malloc(100*sizeof(struct TNoeud*));
	for(i=0;i<100;i++)
		node->fils[i] = NULL;

	nouveauFils = -1;

	do{
		nouveauFils = findFils(Adjacence,sommet,n);
		if(nouveauFils != -1){
			tableau[nbElt] = nouveauFils;
			nbElt++;
		}
	}while(nouveauFils != -1);

	for(i=0;i<nbElt;i++){	
		node->fils[node->nbfils] = CreerSousArbre(ARETE,indice,Adjacence,tableau[i],n);
		node->nbfils = node->nbfils + 1;
	}
	free(tableau);
	return node;
}

// Assembly:
cmpl $-0x1, %ecx
je 0x4aad
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movq %rdi, -0x40(%rbp)
movl $0x190, %edi            # imm = 0x190
movq %r8, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r12
callq 0x1140
movq %rax, %r14
movl $0x18, %edi
callq 0x1140
movq %rax, %r15
movl %ebx, (%rax)
movl $0x0, 0x10(%rax)
movl $0x1, %edi
movl $0x320, %esi            # imm = 0x320
callq 0x1070
movq %r14, %r11
movq -0x30(%rbp), %r8
movq %rax, 0x8(%r15)
cmpl $0x2, %r8d
jl 0x4b07
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %r14
leal -0x2(,%r8,2), %esi
movslq %ebx, %rax
movq (%r13,%rax,8), %rcx
cmpl $0x2, %esi
movl $0x1, %edx
cmovgel %esi, %edx
negq %rdx
xorl %esi, %esi
movsd 0x105db(%rip), %xmm0    # 0x15048
movabsq $0x412e847ffae147ae, %rdi # imm = 0x412E847FFAE147AE
movl $0x1, %r10d
ucomisd (%rcx,%r10,8), %xmm0
ja 0x4a97
leaq (%rdx,%r10), %r9
incq %r9
incq %r10
cmpq $0x1, %r9
jne 0x4a7d
jmp 0x4ab0
movq (%r13,%r10,8), %r9
movq %rdi, (%r9,%rax,8)
movq %rdi, (%rcx,%r10,8)
movl %r10d, (%r11,%rsi,4)
incq %rsi
jmp 0x4a77
xorl %eax, %eax
retq
testq %rsi, %rsi
movq %r14, %rdx
movq -0x38(%rbp), %r14
je 0x4b07
movl %esi, %ecx
movq %rcx, -0x48(%rbp)
xorl %ebx, %ebx
movq %r15, -0x58(%rbp)
movq %r12, -0x50(%rbp)
movl (%r11,%rbx,4), %ecx
movq %rdx, %r15
movq %rdx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r11, %r12
callq 0x49cc
movq %r15, %rdx
movq -0x58(%rbp), %r15
movq %r12, %r11
movq -0x50(%rbp), %r12
movq -0x30(%rbp), %r8
movq %rax, (%r14,%rbx,8)
incq %rbx
movl %ebx, 0x10(%r15)
cmpq %rbx, -0x48(%rbp)
jne 0x4acc
movq %r11, %rdi
callq 0x1100
movq %r15, %rax
addq $0x38, %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/./utils_tree.cpp
// Function: sortIntTab(int*, int, int)
void sortIntTab(int * tab, int debut, int fin){
	
	int i,j,tmp;

	for(i=debut;i<=fin;i++){
		for(j=i+1;j<=fin;j++){
			if(tab[i] > tab[j]){
				tmp = tab[i];
				tab[i] = tab[j];
				tab[j] = tmp;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %esi
jg 0x4b66
movslq %edx, %rax
movslq %esi, %rcx
incl %edx
incl %esi
cmpq %rax, %rcx
jge 0x4b5d
movslq %esi, %r8
decq %r8
movl (%rdi,%rcx,4), %r9d
movl 0x4(%rdi,%r8,4), %r10d
cmpl %r10d, %r9d
jle 0x4b55
movl %r10d, (%rdi,%rcx,4)
movl %r9d, 0x4(%rdi,%r8,4)
incq %r8
cmpq %rax, %r8
jl 0x4b3e
incq %rcx
incl %esi
cmpl %ecx, %edx
jne 0x4b33
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: viderArbre(TNoeud*)
void viderArbre(struct TNoeud * A){
	int i;
	
	if(A->nbfils != 0){
		for(i=0; i<A->nbfils;i++){
			viderArbre(A->fils[i]);
		}
	//	printf("%d ",A->NoNoeud);
		free(A->fils);
		free(A);
	}
	else{
		free(A->fils);
		free(A);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jle 0x4ced
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x4cc1
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x4cd4
movq 0x8(%rbx), %rdi
callq 0x1100
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: AfficherArbre(TNoeud*, int)
void AfficherArbre(struct TNoeud * A,int prof){
	
	int i, taille;
	
	if(A != NULL){
		if(A->nbfils== 0){
			for(i=0;i<prof;i++) printf("  ");
			printf("%d\n",A->NoNoeud);
		}
		else{
			taille = A->nbfils;
			for(i=0; i<taille/2;i++){
				AfficherArbre(A->fils[i],prof+1);
				printf("\n");
			}
			for(i=0;i<prof;i++) printf("  ");
			printf("%d\n",A->NoNoeud);
			for(i=taille/2; i<taille;i++){
				AfficherArbre(A->fils[i],prof+1);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4db9
movl %esi, %r14d
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x4dc8
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
movl %eax, %r13d
movl %ecx, -0x2c(%rbp)
cmpl $0x2, %ecx
jl 0x4d67
leal 0x1(%r14), %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
movl %r15d, %esi
callq 0x4d02
movl $0xa, %edi
callq 0x1160
incq %r12
cmpq %r12, %r13
jne 0x4d45
testl %r14d, %r14d
jle 0x4d85
leaq 0x106ef(%rip), %r15     # 0x15462
movl %r14d, %r12d
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
decl %r12d
jne 0x4d76
movl (%rbx), %esi
leaq 0x106d7(%rip), %rdi     # 0x15465
xorl %eax, %eax
callq 0x1030
movl -0x2c(%rbp), %r15d
testl %r15d, %r15d
jle 0x4db9
incl %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
movl %r14d, %esi
callq 0x4d02
incq %r13
cmpl %r13d, %r15d
jg 0x4da1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r14d, %r14d
jle 0x4de3
leaq 0x1068e(%rip), %r15     # 0x15462
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
decl %r14d
jne 0x4dd4
movl (%rbx), %esi
leaq 0x10679(%rip), %rdi     # 0x15465
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: itoa_(int, char*, int)
char * itoa_(int val,char *buf,int radix){
	if (radix == 10 && val < 0)
		xtoa((unsigned long)val, buf, radix, 1);
	else
		xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xa, %edx
setne %al
testl %edi, %edi
setns %cl
orb %al, %cl
jne 0x513d
movslq %edi, %rcx
leaq 0x1(%rsi), %rdi
movb $0x2d, (%rsi)
negq %rcx
leaq -0x1(%rsi), %r8
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r10d
subl %eax, %r10d
orb $0x30, %r10b
movb %r10b, 0x2(%r8)
incq %r8
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x50f1
movb $0x0, 0x2(%r8)
movb 0x1(%r8), %al
movb (%rdi), %cl
movb %cl, 0x1(%r8)
movb %al, (%rdi)
incq %rdi
leaq -0x1(%r8), %rax
cmpq %r8, %rdi
movq %rax, %r8
jb 0x5120
jmp 0x5198
movl %edi, %ecx
movl %edx, %r8d
leaq -0x2(%rsi), %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movl %edx, %r9d
orb $0x30, %r9b
leal 0x57(%rdx), %r10d
cmpq $0xa, %rdx
movzbl %r10b, %edx
movzbl %r9b, %r9d
cmovael %edx, %r9d
movb %r9b, 0x2(%rdi)
incq %rdi
cmpq %r8, %rcx
movq %rax, %rcx
jae 0x5146
movb $0x0, 0x2(%rdi)
movq %rsi, %rax
movb 0x1(%rdi), %cl
movb (%rax), %dl
movb %dl, 0x1(%rdi)
movb %cl, (%rax)
incq %rax
leaq -0x1(%rdi), %rcx
cmpq %rdi, %rax
movq %rcx, %rdi
jb 0x517f
movq %rsi, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: ecrireMatrice(double**, char const*, int, char**)
int ecrireMatrice(double **mat,const char *outfile,int taille,char **noms){
	int i,j,finalTaille;
	FILE *out;
	
	finalTaille=0;
	
	/*for(i=1;i<=taille;i++)
		if(mat[1][i] != -1)
			finalTaille = finalTaille+1;*/
	for(i=1;i<=taille;i++)
		if(strcmp(noms[i],"")!=0)
			finalTaille = finalTaille+1;
	if(finalTaille < 3){
		printf("There are less than 3 same species !");
		return -1;
	}
	if((out=fopen(outfile,"w+"))==NULL){
		printf("cannot create output file !!");
		printf("==1==>%s<===",outfile);
		exit(-1);
	}
	else{
		fprintf(out,"%d",finalTaille);
		//printf("%d",finalTaille);
		for(i=1;i<=taille;i++){
			if(strcmp(noms[i],"") != 0){//if(strlen(noms[i]) > 1){
				fprintf(out,"\n%s",noms[i]);
				//printf("\n%s",noms[i]);
				for(j=1;j<=taille;j++)
					if(mat[i][j] != -1){
						//printf(" %lf",mat[i][j]);
						fprintf(out," %lf",mat[i][j]);
					}
			}
			else{
				//printf("\nspecies : 1 cas");
			}
		}
		fclose(out);
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
jle 0x6434
movl %edx, %ebx
movq %rsi, %r8
movq %rdi, %r14
leal 0x1(%rbx), %r12d
xorl %r13d, %r13d
movl $0x1, %eax
movq (%rcx,%rax,8), %rdx
cmpb $0x1, (%rdx)
sbbl $-0x1, %r13d
incq %rax
cmpq %rax, %r12
jne 0x641b
cmpl $0x2, %r13d
ja 0x644c
leaq 0xf335(%rip), %rdi      # 0x15770
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x64f4
movq %rcx, -0x38(%rbp)
leaq 0xf33e(%rip), %rsi      # 0x15795
movq %r8, %rdi
movq %r8, -0x30(%rbp)
callq 0x10e0
testq %rax, %rax
je 0x6503
movq %rax, %r15
leaq 0xfd64(%rip), %rsi      # 0x161da
movq %rax, %rdi
movl %r13d, %edx
xorl %eax, %eax
callq 0x1180
testl %ebx, %ebx
jle 0x64e7
movl $0x1, %ebx
movq -0x38(%rbp), %rax
movq (%rax,%rbx,8), %rdx
cmpb $0x0, (%rdx)
je 0x64df
movq %r15, %rdi
leaq 0xff80(%rip), %rsi      # 0x16423
xorl %eax, %eax
callq 0x1180
movl $0x1, %r13d
movq (%r14,%rbx,8), %rax
movsd (%rax,%r13,8), %xmm0
ucomisd 0xeb8e(%rip), %xmm0     # 0x15050
jne 0x64c6
jnp 0x64d7
movq %r15, %rdi
leaq 0xfe90(%rip), %rsi      # 0x16360
movb $0x1, %al
callq 0x1180
incq %r13
cmpq %r13, %r12
jne 0x64b0
incq %rbx
cmpq %r12, %rbx
jne 0x648c
movq %r15, %rdi
callq 0x10a0
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf28e(%rip), %rdi      # 0x15798
xorl %eax, %eax
callq 0x1030
leaq 0xf29d(%rip), %rdi      # 0x157b5
movq -0x30(%rbp), %rsi
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movl %edx, %r14d
movq %rsi, %r13
movq %rdi, %r15
leaq 0xf273(%rip), %rsi      # 0x157c2
movq %r13, %rdi
callq 0x10e0
testq %rax, %rax
je 0x65ee
movq %rax, %r12
movl $0xa, %edi
movq %rax, %rsi
callq 0x1130
testl %r14d, %r14d
jle 0x65d8
incl %r14d
movl $0x1, %ebx
movq -0x30(%rbp), %rax
movq (%rax,%rbx,8), %rdx
cmpb $0x0, (%rdx)
je 0x65d0
movq %r12, %rdi
leaq 0xfe8f(%rip), %rsi      # 0x16423
xorl %eax, %eax
callq 0x1180
movl $0x1, %r13d
movq (%r15,%rbx,8), %rax
movsd (%rax,%r13,8), %xmm0
ucomisd 0xea9d(%rip), %xmm0     # 0x15050
jne 0x65b7
jnp 0x65c8
movq %r12, %rdi
leaq 0xfd9f(%rip), %rsi      # 0x16360
movb $0x1, %al
callq 0x1180
incq %r13
cmpq %r13, %r14
jne 0x65a1
incq %rbx
cmpq %r14, %rbx
jne 0x657d
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
leaq 0xf1a3(%rip), %rdi      # 0x15798
xorl %eax, %eax
callq 0x1030
leaq 0xf1c1(%rip), %rdi      # 0x157c4
movq %r13, %rsi
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leal 0x1(%r14), %r13d
movslq %r13d, %rdi
shlq $0x2, %rdi
callq 0x1140
xorl %ebx, %ebx
testl %r14d, %r14d
jle 0x68d1
movl %r13d, %ecx
movl $0x1, %edx
movl (%r12,%rdx,4), %esi
xorl %edi, %edi
cmpl (%r15,%rdx,4), %esi
sete %dil
movl %edi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x68a1
testl %r14d, %r14d
jle 0x68d1
xorl %ebx, %ebx
movl $0x1, %edx
addl (%rax,%rdx,4), %ebx
incq %rdx
cmpq %rdx, %rcx
jne 0x68c6
movq %rax, %rdi
callq 0x1100
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: CalculerBootARETE(int*, double**, double**, int)
void CalculerBootARETE(int *BSARETE,double **DISTG,double **DISS,int n){

	int m,mI,i,j,val;
	int **B=(int **) malloc((2*n-1)*sizeof(int*));
	int **BI=(int **) malloc((2*n-1)*sizeof(int*));
	int *PLACE=(int *) malloc((2*n-2)*sizeof(int));
	int *PLACEI=(int *) malloc((2*n-2)*sizeof(int));

	for (i=0;i<=2*n-2;i++){
		B[i]=(int *) malloc((2*n-2)*sizeof(int));
		BI[i]=(int *) malloc((2*n-2)*sizeof(int));
	}

	//TrierMatrices(DISS,NomsGene,NomsG,n);

	m=Bipartition_Table(DISTG,B,PLACE,n);
	mI=Bipartition_Table(DISS,BI,PLACEI,n);

	for(i=1;i<=2*n-3;i++){
		for(j=1;j<=2*n-3;j++){
			val = 0;
			val = compare(B[i],BI[j],n);

			if(val == n){
				BSARETE[i] = BSARETE[i] + 1;
			}	
		}
	}

	/*	printf("\n");
	for(i=1;i<=2*n-3;i++){
	printf("\n%d :",i );
	for(j=1;j<=n;j++){
	printf("%d",B[i][j]);		
	}
	}*/
	for(i=0;i<=2*n-2;i++){
		free(B[i]); free(BI[i]);
	}
	free(B);free(BI);free(PLACE);free(PLACEI);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r13d
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, -0x68(%rbp)
leal (%r13,%r13), %eax
movl %eax, -0x3c(%rbp)
movslq %eax, %rbx
leaq -0x8(,%rbx,8), %r14
movq %r14, %rdi
callq 0x1140
movq %rax, %r15
movq %r14, %rdi
callq 0x1140
movq %rax, -0x60(%rbp)
leal -0x2(,%r13,2), %eax
movq %rax, -0x48(%rbp)
leaq -0x8(,%rbx,4), %r12
movq %r12, %rdi
callq 0x1140
movq %rax, -0x58(%rbp)
movq %r12, %rdi
callq 0x1140
movq %rax, -0x50(%rbp)
testl %r13d, %r13d
jle 0x6993
movq -0x48(%rbp), %rbx
orl $0x1, %ebx
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x1140
movq %rax, (%r15,%r14,8)
movq %r12, %rdi
callq 0x1140
movq -0x60(%rbp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq %r14, %rbx
jne 0x696f
movq -0x30(%rbp), %rdi
movq %r15, -0x30(%rbp)
movq %r15, %rsi
movq -0x58(%rbp), %rdx
movl %r13d, %ecx
callq 0x2b12
movq -0x38(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rsi, %r15
movq -0x50(%rbp), %rdx
movl %r13d, %ecx
callq 0x2b12
cmpl $0x2, %r13d
jl 0x6a22
movl -0x3c(%rbp), %eax
cmpl $0x5, %eax
movl $0x4, %ebx
cmovgel %eax, %ebx
addl $-0x2, %ebx
movl $0x1, %ecx
movq -0x30(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq (%rax,%rcx,8), %r12
movl $0x1, %r14d
movq (%r15,%r14,8), %rsi
movq %r12, %rdi
movl %r13d, %edx
callq 0x686b
cmpl %r13d, %eax
jne 0x6a0e
movq -0x68(%rbp), %rax
movq -0x38(%rbp), %rcx
incl (%rax,%rcx,4)
incq %r14
cmpq %r14, %rbx
jne 0x69ef
movq -0x38(%rbp), %rcx
incq %rcx
cmpq %rbx, %rcx
jne 0x69dd
testl %r13d, %r13d
movq -0x30(%rbp), %r14
movq -0x48(%rbp), %r12
jle 0x6a4f
orl $0x1, %r12d
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
callq 0x1100
movq (%r15,%rbx,8), %rdi
callq 0x1100
incq %rbx
cmpq %rbx, %r12
jne 0x6a35
movq %r14, %rdi
callq 0x1100
movq %r15, %rdi
callq 0x1100
movq -0x58(%rbp), %rdi
callq 0x1100
movq -0x50(%rbp), %rdi
addq $0x48, %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/./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:
cmpl $0x2, %edx
jl 0x6ad2
pushq %rbp
movq %rsp, %rbp
leal -0x2(,%rdx,2), %eax
movslq %esi, %rsi
cmpl $0x2, %eax
movl $0x1, %edx
cmovll %edx, %eax
movq (%rdi,%rsi,8), %rsi
negq %rax
movl $0x1, %edi
movsd 0xe597(%rip), %xmm0     # 0x15048
ucomisd (%rsi,%rdi,8), %xmm0
jbe 0x6ac1
movslq %edx, %r8
incl %edx
movl %edi, (%rcx,%r8,4)
leaq (%rax,%rdi), %r8
incq %r8
incq %rdi
cmpq $0x1, %r8
jne 0x6ab1
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
cmpl $0x2, %r8d
jl 0x6b95
movq %rcx, %r12
movq %rdi, %rbx
movq -0x38(%rbp), %r8
leal -0x2(,%r8,2), %eax
movslq -0x2c(%rbp), %rsi
movl %edx, %r15d
cmpl $0x2, %eax
movl $0x1, %r14d
cmovgel %eax, %r14d
movl %r8d, %r8d
negq %r14
movl $0x1, %r13d
movsd 0xe519(%rip), %xmm0     # 0x15048
movq %rsi, -0x48(%rbp)
movq %r8, -0x40(%rbp)
cmpq %r13, %r15
je 0x6b85
movq (%rbx,%rsi,8), %rax
ucomisd (%rax,%r13,8), %xmm0
jbe 0x6b85
cmpq %r8, %r13
jbe 0x6b74
movq %rbx, %rdi
movl %r13d, %esi
movl -0x2c(%rbp), %edx
movq %r12, %rcx
movq -0x38(%rbp), %r8
callq 0x6ad3
movsd 0xe4de(%rip), %xmm0     # 0x15048
movq -0x40(%rbp), %r8
movq -0x48(%rbp), %rsi
jmp 0x6b85
movslq (%r12), %rax
leaq 0x1(%rax), %rdx
movl %edx, (%r12)
movl %r13d, 0x4(%r12,%rax,4)
leaq (%r14,%r13), %rax
incq %rax
incq %r13
cmpq $0x1, %rax
jne 0x6b37
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/./utils_tree.cpp
// Function: creerNoeudDT(int, double**, DescTree*, int*, int*)
void creerNoeudDT(int position,double ** DIST,struct DescTree *DT, int * tab_fils_1, int * tab_fils_2){
		
		int j;
		DT[position].Matrice = (double**)malloc((tab_fils_1[0] + tab_fils_2[0] + 1)*sizeof(double*));
		for(j=0;j<tab_fils_1[0] + tab_fils_2[0] + 1;j++){
			DT[position].Matrice[j] = (double*)malloc((tab_fils_1[0] + tab_fils_2[0] + 1)*sizeof(double));
		}
		DT[position].Tableau = (int*) malloc( (tab_fils_1[0] + tab_fils_2[0] + 1)*sizeof(int));
		DT[position].Tableau[0] = tab_fils_1[0] + tab_fils_2[0];
		for(j=1;j<=tab_fils_1[0];j++) DT[position].Tableau[j] = tab_fils_1[j];
		for(j=1;j<=tab_fils_2[0];j++) DT[position].Tableau[j+tab_fils_1[0]] = tab_fils_2[j];
		sortIntTab(DT[position].Tableau,1,DT[position].Tableau[0]);
		for(j=1;j<=DT[position].Tableau[0];j++){
			for(int k=1;k<=DT[position].Tableau[0];k++){
				DT[position].Matrice[j][k] = DIST[DT[position].Tableau[j]][DT[position].Tableau[k]];
			}
		}
		DT[position].nbSommet = DT[position].Tableau[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rsi, %rbx
movl %edi, -0x2c(%rbp)
movq %rcx, -0x38(%rbp)
movl (%rcx), %ecx
movq %r8, -0x40(%rbp)
movl (%r8), %eax
leal (%rax,%rcx), %r12d
movq %rax, -0x58(%rbp)
movq %rcx, -0x50(%rbp)
leal 0x1(%rax,%rcx), %r15d
movslq %r15d, %rax
movq %rax, -0x48(%rbp)
leaq (,%rax,8), %r14
movq %r14, %rdi
callq 0x1140
movslq -0x2c(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%r13,%rcx,8), %r13
movq %rax, 0x8(%r13)
movl %r12d, -0x2c(%rbp)
testl %r12d, %r12d
js 0x6c2b
movl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x1140
movq 0x8(%r13), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x6c13
movq -0x48(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1140
movq %rax, %r12
movq %rax, 0x10(%r13)
movl -0x2c(%rbp), %r15d
movl %r15d, (%rax)
movq -0x50(%rbp), %r14
testl %r14d, %r14d
jle 0x6c69
leaq 0x4(%r12), %rdi
movq -0x38(%rbp), %rsi
addq $0x4, %rsi
leaq (,%r14,4), %rdx
callq 0x1080
movq -0x58(%rbp), %rdx
testl %edx, %edx
jle 0x6c90
incl %r14d
movslq %r14d, %rax
leaq (%r12,%rax,4), %rdi
movq -0x40(%rbp), %rsi
addq $0x4, %rsi
shlq $0x2, %rdx
callq 0x1080
movl (%r12), %r15d
movq %r12, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x4b21
movl (%r12), %eax
testl %eax, %eax
jle 0x6ce7
leaq 0x1(%rax), %rcx
movq 0x8(%r13), %rdx
movl $0x1, %esi
movslq (%r12,%rsi,4), %rdi
movq (%rbx,%rdi,8), %rdi
movq (%rdx,%rsi,8), %r8
movl $0x1, %r9d
movslq (%r12,%r9,4), %r10
movsd (%rdi,%r10,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x6cc7
incq %rsi
cmpq %rcx, %rsi
jne 0x6cb5
movl %eax, (%r13)
addq $0x38, %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/./utils_tree.cpp
// Function: printNoeudDT(DescTree*, int, int, int)
void printNoeudDT(struct DescTree *DT,int position,int n1,int n2){		
		int j,k;
		printf("\ncouple (%d,%d) position (%d): ",n1,n2,position);
		for(j=1;j<=DT[position].nbSommet;j++)
			printf("%d ",DT[position].Tableau[j]);
	/*for(j=1;j<=DT[position].nbSommet;j++){
			printf("\n%d\t",DT[position].Tableau[j]);
			for(k=1;k<=DT[position].nbSommet;k++){
				printf("%lf\t",DT[position].Matrice[j][k]);
			}
		}*/
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, -0x30(%rbp)
cmpl $0x2, %esi
jl 0x710a
movq %rdi, %r14
movq -0x30(%rbp), %rax
leal -0x1(%rax), %edx
xorl %r15d, %r15d
xorl %eax, %eax
movq %rdx, -0x38(%rbp)
imulq $0xa8, %r15, %r12
movl 0x50(%r14,%r12), %ecx
cmpl 0xf8(%r14,%r12), %ecx
jle 0x70f0
addq %r14, %r12
movl $0xa8, %eax
leaq (%r12,%rax), %r13
movl $0xa8, %edx
leaq -0xe0(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1080
movl $0xa8, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1080
movl $0xa8, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1080
movq -0x38(%rbp), %rdx
movl $0x1, %eax
incq %r15
cmpq %rdx, %r15
jne 0x708e
testl %eax, %eax
je 0x710a
xorl %r15d, %r15d
movl $0x0, %eax
cmpl $0x1, -0x30(%rbp)
jg 0x708e
addq $0xb8, %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: addLeafAndUpdate(InputTree*, int)
void addLeafAndUpdate(struct InputTree *aTree, int choix){
	
	int n = aTree->size;
	int i,j;


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

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

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

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


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

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

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movslq (%rdi), %rcx
leaq (%rcx,%rcx), %rdi
movslq 0x48(%rbx), %r8
movl %edi, %edx
subl %r8d, %edx
addl $-0x3, %edx
movq 0x30(%rbx), %rsi
leal -0x2(%rdi), %r9d
testl %edx, %edx
jle 0x7181
movl %r9d, %edx
subl %r8d, %edx
leaq 0x8(%rsi), %r10
leaq -0x1(%rdx), %r11
movq (%r10), %r14
cmpq %rcx, %r14
jle 0x7166
incq %r14
movq %r14, (%r10)
movq -0x8(%r10), %r14
cmpq %rcx, %r14
jle 0x7176
incq %r14
movq %r14, -0x8(%r10)
addq $0x10, %r10
decq %r11
jne 0x7158
jmp 0x7187
movl %r9d, %edx
subl %r8d, %edx
leal (%rax,%rax), %r10d
movslq %r10d, %r10
movq -0x8(%rsi,%r10,8), %r11
addl %edx, %edx
movslq %edx, %rdx
movq %r11, -0x8(%rsi,%rdx,8)
movq %rdi, %r11
subq %r8, %r11
movq %r11, -0x10(%rsi,%rdx,8)
movq 0x38(%rbx), %rdx
cltq
movsd 0xde52(%rip), %xmm0     # 0x15008
movsd -0x8(%rdx,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd 0xde78(%rip), %xmm2     # 0x15040
maxsd %xmm2, %xmm1
movl %r8d, %r14d
notl %r14d
addl %r14d, %r9d
movslq %r9d, %r9
movsd %xmm1, (%rdx,%r9,8)
movq -0x10(%rsi,%r10,8), %r9
leal -0x1(%rdi), %r15d
subl %r8d, %r15d
addl %r15d, %r15d
movslq %r15d, %r15
movq %r9, -0x8(%rsi,%r15,8)
movq %r11, -0x10(%rsi,%r15,8)
mulsd -0x8(%rdx,%rax,8), %xmm0
maxsd %xmm2, %xmm0
addl %r14d, %edi
decl %edi
movslq %edi, %rdi
movsd %xmm0, (%rdx,%rdi,8)
incl %ecx
movslq %ecx, %r14
movq %r14, -0x8(%rsi,%r10,8)
movq %r11, -0x10(%rsi,%r10,8)
movabsq $0x3f0a36e2eb1c432d, %rcx # imm = 0x3F0A36E2EB1C432D
movq %rcx, -0x8(%rdx,%rax,8)
movl %r14d, (%rbx)
movq 0x28(%rbx), %rdi
movl %r14d, %ecx
callq 0x2215
movq 0x28(%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl 0x48(%rbx), %r8d
movl %r14d, %ecx
callq 0x1d65
movq 0x18(%rbx), %rax
movslq (%rbx), %rcx
movq (%rax,%rcx,8), %rax
movb $0x0, 0x4(%rax)
movl $0x746f6f52, (%rax)     # imm = 0x746F6F52
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcarrey[P]hgt-detection/./fonctions.cpp
// Function: ListeSommets_taille_0(double**, int*, int)
void ListeSommets_taille_0(double ** matrix,int * tab_sommet,int size){
	
	int cpt=1;
	int cpt_init;
	int nouveau_cas=0;
	
	//== recherche du premier element admissible
	while(cpt <= size){
		if(tab_sommet[cpt] == 0)
			break;
		else
			cpt++;
	}
	
	if(cpt < size){
		//== recherche des distances nulles
		cpt_init = cpt++;
		while(cpt <= size){
			if(matrix[cpt_init][cpt] < epsilon ){
				tab_sommet[cpt] = 1;
				nouveau_cas = 1;
			}		
			cpt++;
		}
		if(nouveau_cas == 1){
			tab_sommet[cpt_init] = 1;
		}
		else
			tab_sommet[cpt_init] = 2;
	}
	else
		tab_sommet[0] = TRUE; //== aucun elements trouves
}

// Assembly:
testl %edx, %edx
jle 0x7292
leal 0x1(%rdx), %eax
movl $0x1, %ecx
cmpl $0x0, (%rsi,%rcx,4)
je 0x7299
incq %rcx
cmpq %rcx, %rax
jne 0x7282
jmp 0x729b
movl $0x1, %eax
jmp 0x729b
movl %ecx, %eax
cmpl %edx, %eax
jge 0x72e3
pushq %rbp
movq %rsp, %rbp
movl %eax, %eax
movq (%rdi,%rax,8), %rcx
xorl %edi, %edi
movsd 0xdd75(%rip), %xmm0     # 0x15028
movq %rax, %r8
movl %r8d, %r9d
incq %r8
ucomisd (%rcx,%r8,8), %xmm0
ja 0x72d1
incq %r8
incl %r9d
cmpl %edx, %r9d
jl 0x72bc
jmp 0x72ea
movl $0x1, (%rsi,%r8,4)
movb $0x1, %dil
cmpl %edx, %r8d
jl 0x72b6
jmp 0x72f0
movl $0x1, (%rsi)
retq
testb $0x1, %dil
je 0x72f9
movl $0x1, (%rsi,%rax,4)
jmp 0x7300
movl $0x2, (%rsi,%rax,4)
popq %rbp
retq