LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomUniform
double RandomUniform (long int *seed)
	{
    long int	lo, hi, test;
		
    hi = (*seed) / 127773;
    lo = (*seed) % 127773;
    test = 16807 * lo - 2836 * hi;
    if (test > 0)
        *seed = test;
    else
        *seed = test + 2147483647;
    return (double)(*seed) / (double)2147483647;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x1f31d, %ecx          # imm = 0x1F31D
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x1f31d, %ecx          # imm = 0x1F31D
cqto
idivq %rcx
movq %rdx, -0x10(%rbp)
imulq $0x41a7, -0x10(%rbp), %rax # imm = 0x41A7
imulq $0xb14, -0x18(%rbp), %rcx # imm = 0xB14
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0xa55d
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa56f
movq -0x20(%rbp), %rcx
addq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movsd 0x34ae0(%rip), %xmm1    # 0x3f060
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: MakeTreeNonClock
void MakeTreeNonClock (TreeNode *p, long int *seed)
    {
    if (p != NULL)
        {
        p->branchLength *=  RandomGamma (alphaBranches, seed) / alphaBranches;
        MakeTreeNonClock (p->left, seed);
        MakeTreeNonClock (p->right, seed);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xda0f
movsd 0x409e1(%rip), %xmm0    # 0x4e3b0
movq -0x10(%rbp), %rdi
callq 0x19ca0
divsd 0x409d0(%rip), %xmm0    # 0x4e3b0
movq -0x8(%rbp), %rax
mulsd 0x40(%rax), %xmm0
movsd %xmm0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd9b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd9b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: SumBranches
double SumBranches (TreeNode *p)
   {
	double totalSum, leftSum, rightSum;
	totalSum = leftSum = rightSum = 0;
	
	if (p == NULL)
	   return 0;
	else
		{
		leftSum  = SumBranches(p->left);
		rightSum = SumBranches(p->right);
		totalSum =  p->branchLength + leftSum + rightSum;
		return totalSum;
		}
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xdcb5
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xdcfa
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xdc80
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xdc80
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsd 0x40(%rax), %xmm0
addsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: PrintTimes
void PrintTimes(int listPosition, FILE *fp)
    {
    fprintf (fp, "\n-------------------- Nodes -------------------");
    fprintf (fp, "\n       class  label  index  (left right anc) |         time     time length    branch length");
    fprintf (fp, "\n--------------------------------------------------------------------------------------------\n");
    ListTimes (listPosition, fp);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x34c8b(%rip), %rsi     # 0x429f5
movb $0x0, %al
callq 0x21b0
movq -0x10(%rbp), %rdi
leaq 0x34ca9(%rip), %rsi     # 0x42a25
movb $0x0, %al
callq 0x21b0
movq -0x10(%rbp), %rdi
leaq 0x34cf5(%rip), %rsi     # 0x42a83
movb $0x0, %al
callq 0x21b0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x21a10
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: AddGermlineVariation
void AddGermlineVariation (long int *seed)
    {
	int		j, site, genome, current_state;
	double	ran;
	
	for (site=0; site<numSites; site++)
		{
		if(RandomUniform(seed) < SNPrate) //there is a SNP at this site
			{
			allSites[site].isSNP = YES;
			if(RandomUniform(seed) < 0.5)  // in maternal/paternal genome
				genome = MATERNAL;
			else
				genome = PATERNAL;
		
			if (alphabet == BINARY)
				data[genome][OUTGROUP_ROOT][site] = 1;
			else // DNA mutation according to Mij matrix
				{
				current_state = data[genome][OUTGROUP_ROOT][site];
				ran = RandomUniform(seed) * cumMij[current_state][3];
                for (j=0; j<4; j++)
                    {
					if (ran <= cumMij[current_state][j])
                        {
                        data[genome][OUTGROUP_ROOT][site] = j;
                        break;
                        }
					}
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x3f9e0(%rip), %eax     # 0x4e1dc
jge 0xe95c
movq -0x8(%rbp), %rdi
callq 0xa500
movaps %xmm0, %xmm1
movsd 0x3f9fa(%rip), %xmm0    # 0x4e210
ucomisd %xmm1, %xmm0
jbe 0xe94c
movq 0x40f81(%rip), %rax     # 0x4f7a8
movslq -0x10(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0xa500
movaps %xmm0, %xmm1
movsd 0x307c0(%rip), %xmm0    # 0x3f010
ucomisd %xmm1, %xmm0
jbe 0xe85f
movl $0x0, -0x14(%rbp)
jmp 0xe866
movl $0x1, -0x14(%rbp)
cmpl $0x0, 0x3f9b7(%rip)     # 0x4e224
jne 0xe899
movq 0x40f2a(%rip), %rax     # 0x4f7a0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x40ebb(%rip), %rcx     # 0x4f740
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0xe94a
movq 0x40f00(%rip), %rax     # 0x4f7a0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x40e91(%rip), %rcx     # 0x4f740
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa500
movslq -0x18(%rbp), %rcx
leaq 0x3fd4f(%rip), %rax     # 0x4e620
shlq $0x5, %rcx
addq %rcx, %rax
mulsd 0x18(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0xe948
movsd -0x20(%rbp), %xmm1
movslq -0x18(%rbp), %rcx
leaq 0x3fd21(%rip), %rax     # 0x4e620
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xe93b
movl -0xc(%rbp), %edx
movq 0x40e81(%rip), %rax     # 0x4f7a0
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x40e12(%rip), %rcx     # 0x4f740
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xe948
jmp 0xe93d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe8e9
jmp 0xe94a
jmp 0xe94c
jmp 0xe94e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xe7f3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: CountTrueVariants
int CountTrueVariants (void) 
	{
    int		cell, site;
    int		nVariants = 0;
		
    for (site=0; site<numSites; site++)
        {
		for (cell=0; cell<numCells+1; cell++)
			{
			if ((data[MATERNAL][cell][site] != DELETION && data[MATERNAL][cell][site] != data[MATERNAL][OUTGROUP_ROOT
][site]) 	||
			    (data[PATERNAL][cell][site] != DELETION && data[PATERNAL][cell][site] != data[PATERNAL][OUTGROUP_ROOT
][site]))
                {
				allSites[site].isVariant = YES;
				variantSites[nVariants++] = site;
  				break;
               }
			}
		}
    return nVariants;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x3f001(%rip), %eax     # 0x4e1dc
jge 0xf2fe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl 0x3efe3(%rip), %ecx     # 0x4e1d4
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xf2ee
movq 0x4059d(%rip), %rax     # 0x4f7a0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
cmpl $0x7, (%rax,%rcx,4)
je 0xf24f
movq 0x40581(%rip), %rax     # 0x4f7a0
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x40568(%rip), %rcx     # 0x4f7a0
movq (%rcx), %rcx
movslq 0x404fe(%rip), %rdx     # 0x4f740
movq (%rcx,%rdx,8), %rcx
movslq -0x8(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0xf2a5
movq 0x4054a(%rip), %rax     # 0x4f7a0
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
cmpl $0x7, (%rax,%rcx,4)
je 0xf2de
movq 0x4052d(%rip), %rax     # 0x4f7a0
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x40513(%rip), %rcx     # 0x4f7a0
movq 0x8(%rcx), %rcx
movslq 0x404a8(%rip), %rdx     # 0x4f740
movq (%rcx,%rdx,8), %rcx
movslq -0x8(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0xf2de
movq 0x404fc(%rip), %rax     # 0x4f7a8
movslq -0x8(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x8(%rax)
movl -0x8(%rbp), %edx
movq 0x404ed(%rip), %rax     # 0x4f7b8
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xf2ee
jmp 0xf2e0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xf1e8
jmp 0xf2f0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xf1d2
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: WhichNuc
char WhichNuc (int nucleotide)
    {
    if (nucleotide == A)
        return ('A');
    else if (nucleotide == C)
        return ('C');
    else if (nucleotide == G)
        return ('G');
    else if (nucleotide == T)
        return ('T');
    else if (nucleotide == ADO)
        return ('?');
    else if (nucleotide == DELETION)
        return ('-');
  else
	    return ('N');
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x18d93
movb $0x41, -0x1(%rbp)
jmp 0x18dd3
cmpl $0x1, -0x8(%rbp)
jne 0x18d9f
movb $0x43, -0x1(%rbp)
jmp 0x18dd3
cmpl $0x2, -0x8(%rbp)
jne 0x18dab
movb $0x47, -0x1(%rbp)
jmp 0x18dd3
cmpl $0x3, -0x8(%rbp)
jne 0x18db7
movb $0x54, -0x1(%rbp)
jmp 0x18dd3
cmpl $0x9, -0x8(%rbp)
jne 0x18dc3
movb $0x3f, -0x1(%rbp)
jmp 0x18dd3
cmpl $0x7, -0x8(%rbp)
jne 0x18dcf
movb $0x2d, -0x1(%rbp)
jmp 0x18dd3
movb $0x4e, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: ChooseTrinucMutation
int ChooseTrinucMutation (double ***prob, long int *seed)
	{
	int		i, j = 0, k = 0;
	double	ran, cumProb;
	
	cumProb = 0;
	ran = RandomUniform(seed);
	for (i=0; i<4; i++)
		for (j=0; j<6; j++)
			for (k=0; k<4; k++)
				{
				cumProb += prob[i][j][k];
				if (ran <= cumProb)
					break;
				}
	return trimut(i,j,k);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa500
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x196cb
movl $0x0, -0x18(%rbp)
cmpl $0x6, -0x18(%rbp)
jge 0x196be
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x196b1
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x196a4
jmp 0x196b1
jmp 0x196a6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19665
jmp 0x196b3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19658
jmp 0x196c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1964b
imull $0x18, -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomExponential
double RandomExponential (double lambda, long int *seed)
	{
		
    double 	exponentialNumber, U;
		
    do
		U = RandomUniform (seed);
	while (U == 0);
		
    exponentialNumber = -log (U) / lambda;
		
    return exponentialNumber;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa500
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x19711
jp 0x19711
jmp 0x196f1
movsd -0x20(%rbp), %xmm0
callq 0x2150
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RelabelNodes
void RelabelNodes (TreeNode *p)
    {
    if (p != NULL)
        {
        RelabelNodes (p->left);
        RelabelNodes (p->right);
        if (p->left == NULL && p->right == NULL && p->isHealthyTip == NO) /* is cell tip */
            p->label = p->index;
        else if (p->left == NULL && p->right == NULL && p->isHealthyTip == YES) /* is outgroup tip */
                p->label = tipLabel++;
        else
            p->label = intLabel++; /* is internal */
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x19804
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x19750
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x19750
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x197af
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x197af
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x197af
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x19802
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x197e8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x197e8
movq -0x8(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x197e8
movl 0x36194(%rip), %ecx     # 0x4f968
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x36189(%rip)     # 0x4f968
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x19800
movl 0x3617e(%rip), %ecx     # 0x4f96c
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x36173(%rip)     # 0x4f96c
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x19802
jmp 0x19804
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RelabelUserTree
void RelabelUserTree (TreeNode *p)
	{
    if (p != NULL)
        {
		RelabelUserTree (p->left);
		RelabelUserTree (p->right);
		if (p->left == NULL && p->right == NULL)
			p->index = TipNodeNum++;
		else
			p->index = IntNodeNum++;
		p->label = p->index;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x19c91
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x19c10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x19c10
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x19c6b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x19c6b
movl 0x35d2d(%rip), %ecx     # 0x4f984
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x35d22(%rip)     # 0x4f984
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x19c83
movl 0x35d17(%rip), %ecx     # 0x4f988
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x35d0c(%rip)     # 0x4f988
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomGamma
double	RandomGamma (double shape, long int *seed)
{
    double gammaNumber = 0;
	
    if (shape <= 0)
        fprintf (stderr, "!!! ERROR: problems with gamma variable generation, shape < 0");
    else if (shape < 1)
        gammaNumber = RandomGamma1 (shape, seed);
    else if (shape > 1)
        gammaNumber = RandomGamma2 (shape, seed);
    else
        gammaNumber = -log (RandomUniform(seed));
	
    return (gammaNumber);
	
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jb 0x19cdd
movq 0x3432e(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
leaq 0x272c1(%rip), %rsi     # 0x40f95
movb $0x0, %al
callq 0x21b0
jmp 0x19d57
movsd 0x2533b(%rip), %xmm0    # 0x3f020
ucomisd -0x8(%rbp), %xmm0
jbe 0x19d01
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rdi
callq 0x19d70
movsd %xmm0, -0x18(%rbp)
jmp 0x19d55
movsd -0x8(%rbp), %xmm0
movsd 0x25312(%rip), %xmm1    # 0x3f020
ucomisd %xmm1, %xmm0
jbe 0x19d29
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rdi
callq 0x1a070
movsd %xmm0, -0x18(%rbp)
jmp 0x19d53
movq -0x10(%rbp), %rdi
callq 0xa500
callq 0x2150
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x19d55
jmp 0x19d57
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: BranchRateSwitch
void BranchRateSwitch (TreeNode *p, float multiplier, int *numTips, long int *seed)
	{
	if (p != NULL)
		{
		p->branchLength *= multiplier;
		if (p->left == NULL && p->right == NULL)
			{
			(*numTips)++;
			char *concat;
			concat = (char *) calloc(20, sizeof(char));
			sprintf (concat, "%d ", p->label+1);
			strcat (treeRateInfo, concat);
			free (concat);
			}
		BranchRateSwitch (p->left, multiplier, numTips, seed);
		BranchRateSwitch (p->right, multiplier, numTips, seed);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1a356
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
mulsd 0x40(%rax), %xmm0
movsd %xmm0, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1a323
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1a323
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x14, %edi
movl $0x1, %esi
callq 0x2190
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edx
addl $0x1, %edx
leaq 0x252ec(%rip), %rsi     # 0x3f5ef
movb $0x0, %al
callq 0x2280
movq 0x35467(%rip), %rdi     # 0x4f778
movq -0x28(%rbp), %rsi
callq 0x2270
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1a280
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1a280
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: WhichNucChar
int WhichNucChar (char nucleotide)
    {
    if (nucleotide == 'A')
        return (A);
    else if (nucleotide == 'C')
        return (C);
    else if (nucleotide == 'G')
        return (G);
    else if (nucleotide == 'T')
        return (T);
    else if (nucleotide == '?')
        return (ADO);
    else if (nucleotide == '-')
        return (DELETION);
    else
        {
 		fprintf (stderr, "\nERROR in WhicNucChar: nucleotide = %c\n",  nucleotide);
		exit(-1);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jne 0x1a383
movl $0x0, -0x4(%rbp)
jmp 0x1a403
movsbl -0x5(%rbp), %eax
cmpl $0x43, %eax
jne 0x1a395
movl $0x1, -0x4(%rbp)
jmp 0x1a403
movsbl -0x5(%rbp), %eax
cmpl $0x47, %eax
jne 0x1a3a7
movl $0x2, -0x4(%rbp)
jmp 0x1a403
movsbl -0x5(%rbp), %eax
cmpl $0x54, %eax
jne 0x1a3b9
movl $0x3, -0x4(%rbp)
jmp 0x1a403
movsbl -0x5(%rbp), %eax
cmpl $0x3f, %eax
jne 0x1a3cb
movl $0x9, -0x4(%rbp)
jmp 0x1a403
movsbl -0x5(%rbp), %eax
cmpl $0x2d, %eax
jne 0x1a3dd
movl $0x7, -0x4(%rbp)
jmp 0x1a403
movq 0x33c14(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
movsbl -0x5(%rbp), %edx
leaq 0x26c1d(%rip), %rsi     # 0x4100f
movb $0x0, %al
callq 0x21b0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2290
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: ChooseUniformState
int ChooseUniformState (double *prob, long int *seed)
	{
	int			chosenState;
	double		ran, cumProb;
	
	chosenState = 0;
	cumProb = prob[chosenState];
	ran = RandomUniform(seed);

	while (ran > cumProb)
		cumProb += prob[++chosenState];
	
	return chosenState;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa500
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x1a754
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x1a727
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: CountTriNucFrequencies
void CountTriNucFrequencies (int *genome_array, int genome)
	{
	int i, n1, n2, n3;
	TriNucStr *triNucleotide;

	if (genome == MATERNAL)
		triNucleotide = triNucleotideMaternal;
	else
		triNucleotide = triNucleotidePaternal;

	for (i=0; i<numSites-2; i++)
		{
		n1 = genome_array[i];
		n2 = genome_array[i+1];
		n3 = genome_array[i+2];
		RecordTriNucObservation(&triNucleotide[trinuc(n1,n2,n3)], i);
		}

	#ifdef PRINT_TRINUC_GENOME
		if (genome == MATERNAL)
			{
			fprintf (stderr, "\n\nSimulated trinuc maternal genome: ");
			int rest;
			for (i=0; i<numSites; i++)
				fprintf (stderr, "%c", WhichNuc(allSites[i].referenceAllele));
			
			fprintf (stderr, "\n\nObserved trinuc freqs: ");
			for (i=0; i<64; i++)
				{
				n1 = i/16;
				rest = i%16;
				n2 = rest/4;
				n3 = rest%4;
				fprintf (stderr, "\n%2d %c%c%c [%d] = ", i+1, WhichNuc(n1), WhichNuc(n2), WhichNuc(n3), triNucleotide[i].numAvailablePositions);
				for (int j=0; j<triNucleotide[i].numAvailablePositions; j++)
					fprintf (stderr, "%d ",triNucleotide[i].position[j]+1);
				 }
			fprintf (stderr, "\n\n");
			}
	#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1b282
movq 0x345ec(%rip), %rax     # 0x4f868
movq %rax, -0x28(%rbp)
jmp 0x1b28d
movq 0x345e7(%rip), %rax     # 0x4f870
movq %rax, -0x28(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl 0x32f3f(%rip), %ecx     # 0x4e1dc
subl $0x2, %ecx
cmpl %ecx, %eax
jge 0x1b309
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
shll $0x4, %eax
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
cltq
shlq $0x4, %rax
addq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1b990
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1b294
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomBinomial
int RandomBinomial (double prob, int numTrials, long int *seed)
	{
	int i, sum;
	sum = 0;
	
	for(i=0; i<numTrials; i++)
		{
		if(RandomUniform(seed) < prob)
			sum++;
		}
	return sum;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b367
movq -0x18(%rbp), %rdi
callq 0xa500
movaps %xmm0, %xmm1
movsd -0x8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1b35a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1b35c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b332
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomPoisson
int RandomPoisson (double lambda, long int *seed)
	{
    int		poissonNumber;
    double	sum;
		
    sum = 0;
    poissonNumber = -1;
		
    while (sum <= 1.0)
		{
        sum += RandomExponential (lambda, seed);
        poissonNumber++;
		}
		
    return poissonNumber;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movsd 0x23c88(%rip), %xmm0    # 0x3f020
ucomisd -0x20(%rbp), %xmm0
jb 0x1b3c2
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rdi
callq 0x196e0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b390
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RecordTriNucObservation
void RecordTriNucObservation (TriNucStr *trin, int site)
	{
	if (trin->numAvailablePositions == trin->tempLength)
	  {
	  trin->tempLength *= 2;
	  trin->position = (int *)realloc(trin->position, trin->tempLength * sizeof(int));
	  if (!trin->position)
		  {
		  fprintf (stderr, "Could not reallocate trinucleotide position array when adding\n");
		  exit (-1);
		  }
	  }
	trin->position[trin->numAvailablePositions++] = site;
  	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1ba0a
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x2220
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1ba08
movq 0x3260b(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
leaq 0x25896(%rip), %rsi     # 0x4128d
movb $0x0, %al
callq 0x21b0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2290
jmp 0x1ba0a
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x4(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RemoveTriNucObservation
void RemoveTriNucObservation(TriNucStr *trin, int site)
	{
	int		i;
	
	for (i=site; i<trin->tempLength-1; i++)
		 trin->position[i] = trin->position[i+1];
	
	trin->tempLength = --trin->numAvailablePositions;
	
	if (trin->numAvailablePositions > 0 && trin->numAvailablePositions % 100 == 0)
		{
		//fprintf (stderr, "\nreallocating now (available positions = %d)",trin->numAvailablePositions);
		trin->position = (int *)realloc(trin->position, trin->tempLength * sizeof(int));
		if (!trin->position)
			{
			fprintf (stderr, "Could not reallocate trinucleotide position array when removing\n");
			exit (-1);
			}
		}
 /*	else if (trin->numAvailablePositions == 0)
		{
		fprintf (stderr, "\nthis class has zero available positions now");
		}
*/

/* NOTE:  we could put this nucleotide class signature to zero, as it cannot mutate again, always considering the strand
		  But it does not seem necessary 240518 */
  	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1bac3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1ba85
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x1bb46
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1bb46
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x2220
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1bb44
movq 0x324cf(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
leaq 0x25835(%rip), %rsi     # 0x41368
movb $0x0, %al
callq 0x21b0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2290
jmp 0x1bb46
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: FillSubstitutionMatrix
void FillSubstitutionMatrix (double ch_prob[4][4], double branchLength)
	{
	int i, j;
	
	if (branchLength<1e-6)
		{
		for (i=0; i<4; i++)
			{
			for (j=0; j<4; j++)
				{
				if (i == j)
					ch_prob[i][j] = 1.0;
				else
					ch_prob[i][j] = 0.0;
				}
			}
		}
    else if (doJC == YES)
        JCmodel (ch_prob, branchLength);
    else if (doHKY == YES)
        HKYmodel (ch_prob, branchLength);
    else if (doGTR == YES)
		GTRmodel (ch_prob, branchLength);
    else if (doGTnR == YES)
        GTRmodel (ch_prob, branchLength);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd 0x22a6f(%rip), %xmm0    # 0x3f008
ucomisd -0x10(%rbp), %xmm0
jbe 0x1c61b
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x1c619
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x1c60c
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x1c5e4
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsd 0x22a43(%rip), %xmm0    # 0x3f020
movsd %xmm0, (%rax,%rcx,8)
jmp 0x1c5ff
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x1c601
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c5b4
jmp 0x1c60e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c5a7
jmp 0x1c685
cmpl $0x1, 0x31d6e(%rip)     # 0x4e390
jne 0x1c634
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1c690
jmp 0x1c683
cmpl $0x1, 0x31d59(%rip)     # 0x4e394
jne 0x1c64d
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1c7b0
jmp 0x1c681
cmpl $0x1, 0x31d44(%rip)     # 0x4e398
jne 0x1c666
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1cb50
jmp 0x1c67f
cmpl $0x1, 0x31d2f(%rip)     # 0x4e39c
jne 0x1c67d
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x1cb50
jmp 0x1c67f
jmp 0x1c681
jmp 0x1c683
jmp 0x1c685
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: JCmodel
void JCmodel (double Pij[4][4], double branchLength)
	{
	int i, j;
	
	for (i=0; i<4; i++)
		{
		for (j=0; j<4; j++)
			{
			if (i == j)
				Pij[i][j] = 0.25 + 0.75*exp(beta*-branchLength);
			else
				Pij[i][j] = 0.25 - 0.25*exp(beta*-branchLength);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x1c7a7
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x1c797
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x1c72a
movsd 0x3333d(%rip), %xmm0    # 0x4fa10
movsd -0x10(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm1, %xmm0
callq 0x22b0
movsd 0x229b8(%rip), %xmm1    # 0x3f0b8
mulsd %xmm1, %xmm0
movsd 0x22924(%rip), %xmm1    # 0x3f030
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x1c787
movsd 0x332de(%rip), %xmm0    # 0x4fa10
movsd -0x10(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm1, %xmm0
callq 0x22b0
movsd 0x22951(%rip), %xmm1    # 0x3f0b0
mulsd %xmm1, %xmm0
movsd 0x228c5(%rip), %xmm1    # 0x3f030
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x1c789
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c6b9
jmp 0x1c799
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c6a8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: GTRmodel
void GTRmodel (double Pij[4][4], double branchLength)
	{
	int 	i, j, k;
	double	t, expt[4];

	t = branchLength;

	/* P(t)ij = SUM Cijk * exp{Root*t} */
	for (k=1; k<4; k++)
		expt[k]=exp(t*Root[k]);
	for (i=0; i<4; i++)
		for (j=0; j<4; j++)
			{
			Pij[i][j]=Cijk[i*4*4+j*4+0];
			for (k=1; k<4; k++)
				Pij[i][j]+=Cijk[i*4*4+j*4+k]*expt[k];
			}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x1cba7
movsd -0x28(%rbp), %xmm0
movslq -0x1c(%rbp), %rcx
leaq 0x32eb8(%rip), %rax     # 0x4fa40
mulsd (%rax,%rcx,8), %xmm0
callq 0x22b0
movslq -0x1c(%rbp), %rax
movsd %xmm0, -0x50(%rbp,%rax,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1cb72
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x1cc8e
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x1cc7e
movl -0x14(%rbp), %eax
shll $0x2, %eax
shll $0x2, %eax
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl $0x0, %eax
movslq %eax, %rcx
leaq 0x32e79(%rip), %rax     # 0x4fa60
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x1cc6e
movl -0x14(%rbp), %eax
shll $0x2, %eax
shll $0x2, %eax
movl -0x18(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rcx
leaq 0x32e31(%rip), %rax     # 0x4fa60
movsd (%rax,%rcx,8), %xmm0
movslq -0x1c(%rbp), %rax
movsd -0x50(%rbp,%rax,8), %xmm2
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1cc0b
jmp 0x1cc70
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1cbbf
jmp 0x1cc80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1cbae
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomBetaMeanVar
double RandomBetaMeanVar (double mean, double var, long int *seed)
	{
	double sample_size, shape1, shape2, gamma1, gamma2, randBeta;
	
	/* assuming variance < mean (1-mean) */
	sample_size = (mean * (1.0 - mean) / var) - 1.0;
	
	shape1 = mean * sample_size;
	shape2 = (1.0 - mean) * sample_size;
	
	gamma1 = RandomGamma(shape1, seed);
	gamma2 = RandomGamma(shape2, seed);
	randBeta = gamma1 / (gamma1 + gamma2);
	
	return randBeta;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x21e1d(%rip), %xmm1    # 0x3f020
subsd -0x8(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x10(%rbp), %xmm0
movsd 0x21e07(%rip), %xmm1    # 0x3f020
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x21de7(%rip), %xmm0    # 0x3f020
subsd -0x8(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x19ca0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x19ca0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
addsd -0x40(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: WriteTree
void WriteTree (TreeNode *p, FILE *fp)
    {
    if (p != NULL)
        {
        if(p->isHealthyTip == YES)
            {
           // fprintf (fp, "healthycell:%8.6f",p->branchLength);
			fprintf (fp, "%s:%8.6f",outCellName, p->branchLength);
			}
        else if (p->left == NULL && p->right == NULL)
            {
			if (doUserTree == NO)
				//fprintf (fp, "tumcell%04d:%8.6f", Index(p),p->branchLength);
				fprintf (fp, "%s%04d:%8.6f", inCellName, Index(p),p->branchLength);
			else
				fprintf (fp, "%s:%8.6f", p->name,p->branchLength);
            }
        else
            {
            fprintf (fp, "(");
            WriteTree (p->left, fp);
            fprintf (fp, ",");
            WriteTree (p->right, fp);
            if (p->anc !=NULL)
				{
				fprintf (fp, "):%8.6f",p->branchLength);
				//TODO: anotate tree?
				/*if (p->rateSwitch > 0)
					fprintf (fp, "[&rate_switch=%e]",p->rateSwitch);*/
				}
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x219d7
movq -0x8(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x218ec
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movsd 0x40(%rax), %xmm0
leaq 0x210fe(%rip), %rsi     # 0x429d7
leaq 0x2ced0(%rip), %rdx     # 0x4e7b0
movb $0x1, %al
callq 0x21b0
jmp 0x219d5
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x21966
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x21966
cmpl $0x0, 0x2cabc(%rip)     # 0x4e3c4
jne 0x21941
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x219e0
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movq -0x8(%rbp), %rax
movsd 0x40(%rax), %xmm0
leaq 0x210af(%rip), %rsi     # 0x429e0
leaq 0x2cdf8(%rip), %rdx     # 0x4e730
movb $0x1, %al
callq 0x21b0
jmp 0x21964
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdx
movq -0x8(%rbp), %rax
movsd 0x40(%rax), %xmm0
leaq 0x2107a(%rip), %rsi     # 0x429d7
movb $0x1, %al
callq 0x21b0
jmp 0x219d3
movq -0x10(%rbp), %rdi
leaq 0x21381(%rip), %rsi     # 0x42cf2
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x218a0
movq -0x10(%rbp), %rdi
leaq 0x20fd7(%rip), %rsi     # 0x4296a
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x218a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x219d1
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movsd 0x40(%rax), %xmm0
leaq 0x21023(%rip), %rsi     # 0x429ed
movb $0x1, %al
callq 0x21b0
jmp 0x219d3
jmp 0x219d5
jmp 0x219d7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: WhichMut
char WhichMut (int state)
    {
    if (state == 0)
        return ('0');
    else if (state == 1)
        return ('1');
    else if (state == ADO)
        return ('?');
     else if (state == DELETION)
        return ('-');
   else
        return ('N');
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x21ee3
movb $0x30, -0x1(%rbp)
jmp 0x21f0b
cmpl $0x1, -0x8(%rbp)
jne 0x21eef
movb $0x31, -0x1(%rbp)
jmp 0x21f0b
cmpl $0x9, -0x8(%rbp)
jne 0x21efb
movb $0x3f, -0x1(%rbp)
jmp 0x21f0b
cmpl $0x7, -0x8(%rbp)
jne 0x21f07
movb $0x2d, -0x1(%rbp)
jmp 0x21f0b
movb $0x4e, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: WhichConsensusBinary
char WhichConsensusBinary (int allele1, int allele2)
	{
	if (allele1 == 0)
		{
		if (allele2 == 0)		//00
			return ('0');
		else if (allele2 == 1)	//01
			return ('1');
		else if (allele2 == ADO)	//0?
			return ('0');
		else if (allele2 == DELETION)	//0-
			return ('0');
		else
			return ('N');
		}
	else if (allele1 == 1)
		{
		if (allele2 == 0)		//10
			return ('1');
		else if (allele2 == 1)	//11
			return ('2');
		else if (allele2 == ADO)	//1?
			return ('2');
		else if (allele2 == DELETION)	//1-
			return ('2');
		else
			return ('N');
		}
	else if (allele1 == ADO)
		{
		if (allele2 == 0)		//?0
			return ('0');
		else if (allele2 == 1)	//?1
			return ('2');
		else if (allele2 == ADO)	//??
			return ('-');
		else if (allele2 == DELETION)	//?-
			return ('-');
		else
			return ('N');
		}
	else if (allele1 == DELETION)
		{
		if (allele2 == 0)		//-0
			return ('0');
		else if (allele2 == 1)	//-1
			return ('2');
		else if (allele2 == ADO)	//-?
			return ('-');
		else if (allele2 == DELETION)	//--
			return ('-');
		else
			return ('N');
		}
	else
		return ('N');
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x21f65
cmpl $0x0, -0xc(%rbp)
jne 0x21f2f
movb $0x30, -0x1(%rbp)
jmp 0x22029
cmpl $0x1, -0xc(%rbp)
jne 0x21f3e
movb $0x31, -0x1(%rbp)
jmp 0x22029
cmpl $0x9, -0xc(%rbp)
jne 0x21f4d
movb $0x30, -0x1(%rbp)
jmp 0x22029
cmpl $0x7, -0xc(%rbp)
jne 0x21f5c
movb $0x30, -0x1(%rbp)
jmp 0x22029
movb $0x4e, -0x1(%rbp)
jmp 0x22029
cmpl $0x1, -0x8(%rbp)
jne 0x21fad
cmpl $0x0, -0xc(%rbp)
jne 0x21f7a
movb $0x31, -0x1(%rbp)
jmp 0x22029
cmpl $0x1, -0xc(%rbp)
jne 0x21f89
movb $0x32, -0x1(%rbp)
jmp 0x22029
cmpl $0x9, -0xc(%rbp)
jne 0x21f98
movb $0x32, -0x1(%rbp)
jmp 0x22029
cmpl $0x7, -0xc(%rbp)
jne 0x21fa7
movb $0x32, -0x1(%rbp)
jmp 0x22029
movb $0x4e, -0x1(%rbp)
jmp 0x22029
cmpl $0x9, -0x8(%rbp)
jne 0x21fe9
cmpl $0x0, -0xc(%rbp)
jne 0x21fbf
movb $0x30, -0x1(%rbp)
jmp 0x22029
cmpl $0x1, -0xc(%rbp)
jne 0x21fcb
movb $0x32, -0x1(%rbp)
jmp 0x22029
cmpl $0x9, -0xc(%rbp)
jne 0x21fd7
movb $0x2d, -0x1(%rbp)
jmp 0x22029
cmpl $0x7, -0xc(%rbp)
jne 0x21fe3
movb $0x2d, -0x1(%rbp)
jmp 0x22029
movb $0x4e, -0x1(%rbp)
jmp 0x22029
cmpl $0x7, -0x8(%rbp)
jne 0x22025
cmpl $0x0, -0xc(%rbp)
jne 0x21ffb
movb $0x30, -0x1(%rbp)
jmp 0x22029
cmpl $0x1, -0xc(%rbp)
jne 0x22007
movb $0x32, -0x1(%rbp)
jmp 0x22029
cmpl $0x9, -0xc(%rbp)
jne 0x22013
movb $0x2d, -0x1(%rbp)
jmp 0x22029
cmpl $0x7, -0xc(%rbp)
jne 0x2201f
movb $0x2d, -0x1(%rbp)
jmp 0x22029
movb $0x4e, -0x1(%rbp)
jmp 0x22029
movb $0x4e, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: Unlink_callback
int Unlink_callback(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf)
	{
    int rv = remove(fpath);

    if (rv)
        perror(fpath);

    return rv;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2060
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x22062
movq -0x8(%rbp), %rdi
callq 0x2240
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: CheckMatrixSymmetry
int CheckMatrixSymmetry(double matrix[4][4])
	{
	int i,j;
	
	for(i=0; i<4; i++)
		for(j=0; j<4; j++)
			if(matrix[i][j] != matrix[j][i])
				return NO;
	return YES;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x220eb
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x220de
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jne 0x220c8
jp 0x220c8
jmp 0x220d1
movl $0x0, -0x4(%rbp)
jmp 0x220f2
jmp 0x220d3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2208c
jmp 0x220e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2207f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/cellcoal.c
// Function: ReadUntil
void ReadUntil(FILE *fv, char stopChar, char *what)
{
    char ch;
	
    ch=fgetc(fv);
    while (!feof(fv) && ch!=stopChar)
        ch=fgetc(fv);
	
    if (feof(fv) || ch!=stopChar) {
        fprintf (stderr, "%s missing", what);
        exit(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2140
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x22147
movsbl -0x19(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x22150
jmp 0x2215e
movq -0x8(%rbp), %rdi
callq 0x2140
movb %al, -0x19(%rbp)
jmp 0x22122
movq -0x8(%rbp), %rdi
callq 0x21c0
cmpl $0x0, %eax
jne 0x22178
movsbl -0x19(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x2219b
movq 0x2be79(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x24e21(%rip), %rsi     # 0x46fae
movb $0x0, %al
callq 0x21b0
xorl %edi, %edi
callq 0x2290
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/eigen.c
// Function: EigenREV
int EigenREV (double Root[], double Cijk[])
{
/* freq[] is constant
*/
	int i,j,k;
	double U[16], V[16], T1[16], T2[16];

	abyx (1/mr, Qij, 16);

	if ((k=eigen (1, Qij, 4, Root, T1, U, V, T2))!=0) {
		fprintf(stderr, "\ncomplex roots in EigenREV");
		exit(0);
	}
	xtoy (U, V, 16);
	matinv (V, 4, 4, T1);
	for (i=0; i<4; i++)
   		for (j=0; j<4; j++)
   			for (k=0; k<4; k++)
   				Cijk[i*4*4+j*4+k] = U[i*4+k]*V[k*4+j];
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd 0x1ce55(%rip), %xmm0    # 0x3f020
divsd 0x2e14d(%rip), %xmm0    # 0x50320
leaq 0x2e156(%rip), %rdi     # 0x50330
movl $0x10, %esi
callq 0x22330
movq -0x8(%rbp), %rcx
leaq -0x1a0(%rbp), %r8
leaq -0xa0(%rbp), %r9
leaq -0x120(%rbp), %r10
leaq -0x220(%rbp), %rax
movl $0x1, %edi
leaq 0x2e120(%rip), %rsi     # 0x50330
movl $0x4, %edx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x22380
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x2224a
movq 0x2bdc6(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
leaq 0x24dc4(%rip), %rsi     # 0x47000
movb $0x0, %al
callq 0x21b0
xorl %edi, %edi
callq 0x2290
leaq -0xa0(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movl $0x10, %edx
callq 0x226a0
leaq -0x120(%rbp), %rdi
leaq -0x1a0(%rbp), %rcx
movl $0x4, %edx
movl %edx, %esi
callq 0x226f0
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x22317
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x22307
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x222fa
movl -0x14(%rbp), %eax
shll $0x2, %eax
addl -0x1c(%rbp), %eax
cltq
movsd -0xa0(%rbp,%rax,8), %xmm0
movl -0x1c(%rbp), %eax
shll $0x2, %eax
addl -0x18(%rbp), %eax
cltq
mulsd -0x120(%rbp,%rax,8), %xmm0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
shll $0x2, %ecx
movl -0x18(%rbp), %edx
shll $0x2, %edx
addl %edx, %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x222a1
jmp 0x222fc
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x22294
jmp 0x22309
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x22283
xorl %eax, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopw %cs:(%rax,%rax)