LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocIntMatrix(int, int)
iMatrix *allocIntMatrix(int x, int y){
  try{
    iMatrix *tmp = new iMatrix();
    int **ppi = new int*[x];
    

    // int *curPtr = new int [x * y];
    for( int i = 0; i < x; ++i) {
      *(ppi + i) = new int[y];
      // curPtr += y;
    }
#if _fillup_
    for (int i=0;i<x;i++)
      for(int n=0;n<y;n++)
	ppi[i][n]=0;
#endif
    printf("\t-> Allocated: %.3f gig memory\n",(float)sizeof(int)*x*y/1000000000);
    tmp->matrix=ppi;
    tmp->x=x;
    tmp->y=y;
    return tmp;
  }catch(std::exception & e){
    printf("\t-> Tried to allocate: %.3f gig memory\n",(float)sizeof(int)*x*y/1000000000);
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %r14d
movl $0x10, %edi
movl %r14d, 0xc(%rsp)
callq 0x2220
xorps %xmm0, %xmm0
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rax)
movl %r14d, %ebp
leaq (,%rbp,8), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r15
testl %r14d, %r14d
jle 0xa742
movl %ebx, %r12d
leaq (,%r12,4), %rax
testl %ebx, %ebx
movq $-0x1, %r13
cmovnsq %rax, %r13
xorl %r14d, %r14d
movq %r13, %rdi
callq 0x2030
movq %rax, (%r15,%r14,8)
incq %r14
cmpq %r14, %rbp
jne 0xa706
cmpl $0x0, 0xc(%rsp)
jle 0xa742
shlq $0x2, %r12
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0xa73a
movq (%r15,%r13,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbp
jne 0xa728
movl 0xc(%rsp), %ebp
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
mulss 0x3d9f(%rip), %xmm0     # 0xe4f4
cvtsi2ss %ebx, %xmm1
mulss %xmm0, %xmm1
divss 0x3d93(%rip), %xmm1     # 0xe4f8
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x3d9d(%rip), %rdi      # 0xe510
movb $0x1, %al
callq 0x2040
movq 0x10(%rsp), %rax
movq %r15, 0x8(%rax)
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa79b
jmp 0xa79b
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xa7f1
callq 0x20c0
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rsp), %xmm0
mulss 0x3d3b(%rip), %xmm0     # 0xe4f4
cvtsi2ss %ebx, %xmm1
mulss %xmm0, %xmm1
divss 0x3d2f(%rip), %xmm1     # 0xe4f8
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x3d59(%rip), %rdi      # 0xe530
movb $0x1, %al
callq 0x2040
leaq 0x3fb0(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocUSIntMatrix(int, int)
usiMatrix *allocUSIntMatrix(int x, int y){
  try{
    usiMatrix *tmp = new usiMatrix();
    unsigned short int **ppi = new unsigned short int*[x];
    // int *curPtr = new int [x * y];
    for( int i = 0; i < x; ++i) {
      *(ppi + i) = new unsigned short int[y];
      // curPtr += y;
    }
#if _fillup_
    for (int i=0;i<x;i++)
      for(int n=0;n<y;n++)
	ppi[i][n]=0;
#endif
    printf("\t-> Allocated: %.3f gig memory\n",(float)sizeof(unsigned short int)*x*y/1000000000);
    tmp->matrix=ppi;
    tmp->x=x;
    tmp->y=y;
    return tmp;
  }catch(std::exception & e){
    printf("\t-> Tried to allocate: %.3f gig memory\n",(float)sizeof(int)*x*y/1000000000);
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %r14d
movl $0x10, %edi
movl %r14d, 0xc(%rsp)
callq 0x2220
xorps %xmm0, %xmm0
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rax)
movl %r14d, %ebp
leaq (,%rbp,8), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r15
testl %r14d, %r14d
jle 0xa89b
movl %ebx, %r12d
leaq (%r12,%r12), %rax
testl %ebx, %ebx
movq $-0x1, %r13
cmovnsq %rax, %r13
xorl %r14d, %r14d
movq %r13, %rdi
callq 0x2030
movq %rax, (%r15,%r14,8)
incq %r14
cmpq %r14, %rbp
jne 0xa860
cmpl $0x0, 0xc(%rsp)
jle 0xa89b
addq %r12, %r12
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0xa893
movq (%r15,%r13,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbp
jne 0xa881
movl 0xc(%rsp), %ebp
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %ebx, %xmm1
mulss %xmm0, %xmm1
divss 0x3c3e(%rip), %xmm1     # 0xe4f8
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x3c48(%rip), %rdi      # 0xe510
movb $0x1, %al
callq 0x2040
movq 0x10(%rsp), %rax
movq %r15, 0x8(%rax)
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa8f0
jmp 0xa8f0
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xa946
callq 0x20c0
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rsp), %xmm0
mulss 0x3be6(%rip), %xmm0     # 0xe4f4
cvtsi2ss %ebx, %xmm1
mulss %xmm0, %xmm1
divss 0x3bda(%rip), %xmm1     # 0xe4f8
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x3c04(%rip), %rdi      # 0xe530
movb $0x1, %al
callq 0x2040
leaq 0x3e5b(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: killSnpMatrix(snpMatrix*)
void killSnpMatrix(snpMatrix *mat){
  killMatrix(mat->pba);
  killMatrix(mat->dprime);
  killMatrix(mat->pbA);
  killMatrix(mat->pBa);
  killMatrix(mat->pBA);
  killMatrix(mat->rmisc);
  killMatrix(mat->D);
  killMatrix(mat->lod);
  delete mat;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq (%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x10(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x18(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x20(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x28(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x30(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x38(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movl $0x40, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: killPars(pars*)
void killPars(pars *mat){
  killArray(mat->Sk1);
  killArray(mat->Sk2);
  killArray(mat->Sk3);
  killArray(mat->t);
  killMatrix(mat->S);
  killArray(mat->maf);
  killArray(mat->maf2);
  killArray(mat->ind1);
  killArray(mat->ind2);
  //killArray(mat->pos);
  //killArray(mat->chr);
  delete mat;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xa94b
movq 0x8(%rbx), %rdi
callq 0xa94b
movq 0x10(%rbx), %rdi
callq 0xa94b
movq 0x18(%rbx), %rdi
callq 0xa94b
movq 0x20(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x30(%rbx), %rdi
callq 0xa94b
movq 0x38(%rbx), %rdi
callq 0xa94b
movq 0x40(%rbx), %rdi
callq 0xa98b
movq 0x48(%rbx), %rdi
callq 0xa98b
movl $0x78, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocDoubleMatrix(int, int)
dMatrix *allocDoubleMatrix(int x, int y){
  try{
    dMatrix *tmp = new dMatrix();
    double **ppi = new double*[x];
    double *curPtr = new double [x * y];
    
    for( int i = 0; i < x; ++i) {
      *(ppi + i) = curPtr;
      curPtr += y;
    }
#if _fillup_
    for (int i=0;i<x;i++)
      for(int n=0;n<y;n++)
	ppi[i][n]=0;
#endif
    tmp->matrix=ppi;
    tmp->x=x;
    tmp->y=y;
    return tmp;
  }catch(std::exception & e){
        printf("\t-> Tried to allocate: %.3f gig memory\n",(float)sizeof(double)*x*y/1000000000);
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x10, %edi
callq 0x2220
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movl %ebp, %r13d
leaq (,%r13,8), %rdi
testl %ebp, %ebp
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, %r15
movl %ebx, %eax
imull %ebp, %eax
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r12, %rdi
callq 0x2030
movl %ebp, 0x4(%rsp)
testl %ebp, %ebp
jle 0xac54
movslq %ebx, %rcx
shlq $0x3, %rcx
xorl %edx, %edx
movq %rax, (%r15,%rdx,8)
incq %rdx
addq %rcx, %rax
cmpq %rdx, %r13
jne 0xac1b
cmpl $0x0, 0x4(%rsp)
jle 0xac54
movl %ebx, %r12d
shlq $0x3, %r12
xorl %ebp, %ebp
testl %ebx, %ebx
jle 0xac4c
movq (%r15,%rbp,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2100
incq %rbp
cmpq %rbp, %r13
jne 0xac3a
movq %r15, 0x8(%r14)
movl 0x4(%rsp), %eax
movl %eax, (%r14)
movl %ebx, 0x4(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xac79
jmp 0xac79
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xaccd
callq 0x20c0
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
mulss 0x3867(%rip), %xmm0     # 0xe4fc
cvtsi2ss %ebx, %xmm1
mulss %xmm0, %xmm1
divss 0x3853(%rip), %xmm1     # 0xe4f8
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x387d(%rip), %rdi      # 0xe530
movb $0x1, %al
callq 0x2040
leaq 0x3ad4(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocDoubleMatrix(int, int, float)
dMatrix *allocDoubleMatrix(int x, int y,float inputVar){
  dMatrix *retVal = allocDoubleMatrix(x,y);
  for (int i=0;i<x;i++)
    for(int n=0;n<y;n++)
      retVal->matrix[i][n]= inputVar;

  return retVal;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movl %esi, %ebx
movl %edi, %ebp
callq 0xabb0
testl %ebp, %ebp
jle 0xadb0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
movl %ebp, %ecx
movl %ebx, %esi
leal 0x1(%rbx), %edx
decq %rsi
movq %rsi, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
shrl %edx
shlq $0x4, %rdx
xorl %esi, %esi
movdqa 0x2357(%rip), %xmm2     # 0xd070
movdqa 0x235f(%rip), %xmm3     # 0xd080
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movdqa 0x37cf(%rip), %xmm5     # 0xe500
testl %ebx, %ebx
jle 0xada8
movq 0x8(%rax), %rdi
movq (%rdi,%rsi,8), %rdi
xorl %r8d, %r8d
movdqa %xmm2, %xmm6
movdqa %xmm6, %xmm7
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm1, %xmm8
pcmpeqd %xmm1, %xmm7
pshufd $0xf5, %xmm7, %xmm9     # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7     # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %r9d
notl %r9d
testb $0x1, %r9b
je 0xad84
movsd %xmm0, (%rdi,%r8)
pxor %xmm4, %xmm7
pextrw $0x4, %xmm7, %r9d
testb $0x1, %r9b
je 0xad9b
movsd %xmm0, 0x8(%rdi,%r8)
paddq %xmm5, %xmm6
addq $0x10, %r8
cmpq %r8, %rdx
jne 0xad44
incq %rsi
cmpq %rcx, %rsi
jne 0xad31
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocIntArray(unsigned long)
iArray *allocIntArray(size_t  i){
  try{
    int *tmp= new int[i];
    iArray *intArray = new iArray();
#if _fillup_
    for (unsigned int j=0;j<i;j++)
      tmp[j]=0;
#endif
    intArray->x=i;
    intArray->array=tmp;
    return intArray;
  }catch(std::exception & e){
    printf("\t-> Tried to allocate: %.3f gig memory\n",(float)sizeof(size_t)*i/1000000000);
    printf("\t-> Thats an array of length: %lu \n",i);
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %rax
shrq $0x3e, %rax
leaq (,%rdi,4), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x2030
movq %rax, %r14
movl $0x10, %edi
callq 0x2220
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
testq %rbx, %rbx
je 0xae09
xorl %ecx, %ecx
movl $0x0, (%r14,%rcx,4)
incq %rcx
movl %ecx, %edx
cmpq %rbx, %rdx
jb 0xadf7
movl %ebx, (%rax)
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xae19
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xae32
callq 0x20c0
testq %rbx, %rbx
js 0xae37
cvtsi2ss %rbx, %xmm0
jmp 0xae4e
callq 0x2400
movq %rbx, %rax
shrq %rax
movl %ebx, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
mulss 0x36a6(%rip), %xmm0     # 0xe4fc
divss 0x369a(%rip), %xmm0     # 0xe4f8
cvtss2sd %xmm0, %xmm0
leaq 0x36c7(%rip), %rdi      # 0xe530
movb $0x1, %al
callq 0x2040
leaq 0x36e1(%rip), %rdi      # 0xe558
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2040
leaq 0x390d(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocBoolArray(int)
bArray *allocBoolArray(int i){
  try{
    int *tmp= new int[i];
  bArray *boolArray = new bArray();
#if _fillup_
  for (int j=0;j<i;j++)
    tmp[j]=0;
#endif
  boolArray->x=i;
  boolArray->array=tmp;
  boolArray->numTrue = 0;
  return boolArray;
 }catch(std::exception & e){
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %r14d
shlq $0x2, %r14
testl %edi, %edi
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0x2030
movq %rax, %r15
movl $0x10, %edi
callq 0x2220
movq %rax, %r12
testl %ebx, %ebx
jle 0xaed8
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
movl %ebx, (%r12)
movq %r15, 0x8(%r12)
movl $0x0, 0x4(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xaefb
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xaf1b
callq 0x20c0
leaq 0x3886(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocDoubleArray(int)
dArray *allocDoubleArray(int i){
  try{
    double *tmp= new double[i];
    dArray *darray = new dArray();
#if _fillup_
    for (int j=0;j<i;j++)
      tmp[j]=0.0;
#endif
    darray->x=i;
    darray->array=tmp;
    return darray;
  }catch(std::exception & e){
    printf("\t-> Tried to allocate: %.3f gig memory\n",(float)sizeof(double)*i/1000000000);
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %r14d
shlq $0x3, %r14
testl %edi, %edi
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0x2030
movq %rax, %r15
movl $0x10, %edi
callq 0x2220
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
testl %ebx, %ebx
jle 0xaf6a
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
movl %ebx, (%r12)
movq %r15, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xaf84
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xafca
callq 0x20c0
cvtsi2ss %ebx, %xmm0
mulss 0x355f(%rip), %xmm0     # 0xe4fc
divss 0x3553(%rip), %xmm0     # 0xe4f8
cvtss2sd %xmm0, %xmm0
leaq 0x3580(%rip), %rdi      # 0xe530
movb $0x1, %al
callq 0x2040
leaq 0x37d7(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocDoubleArray(dArray*)
dArray *allocDoubleArray(dArray *other){
  try{
    dArray *darray = new dArray();
  double *tmp= new double[other->x];
  
  for (int j=0;j<other->x;j++)
    tmp[j]=other->array[j];
  darray->x=other->x;
  darray->array=tmp;
  return darray;
  }catch(std::exception & e){
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2220
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movslq (%r14), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
testl %r15d, %r15d
jle 0xb025
movq 0x8(%r14), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0xb013
movl %r15d, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb037
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xb057
callq 0x20c0
leaq 0x374a(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: killFunctionPars(functionPars*)
void killFunctionPars(functionPars *tmp){

  killMatrix(tmp->data);
  killArray(tmp->pair);
  
  killArray(tmp->position);//this is the pos from the outer run
  killArray(tmp->alim);
  killArray(tmp->par); 
  killArray(tmp->chr);

  delete tmp;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%r14), %rdi
callq 0xa9c5
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x8(%rbx), %rdi
callq 0xa98b
movq 0x18(%rbx), %rdi
callq 0xa94b
movq 0x28(%rbx), %rdi
callq 0xa94b
movq 0x20(%rbx), %rdi
callq 0xa94b
movq 0x10(%rbx), %rdi
callq 0xa98b
movq %rbx, %rdi
callq 0xb782
movl $0x178, %esi            # imm = 0x178
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: killHapStruct(hapStruct*)
void killHapStruct(hapStruct *tmp){
  killMatrix(tmp->pBA);
  killMatrix(tmp->pBa);
  killMatrix(tmp->pbA);
  killMatrix(tmp->pba);
  killMatrix(tmp->mea);
  delete tmp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x8(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x10(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x18(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x20(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: killFullResults(fullResults*)
void killFullResults(fullResults *tmp){

  killArray(tmp->kResult);

  if (tmp->S1!=tmp->S)
    killMatrix(tmp->S);
  killMatrix(tmp->S1);

  killArray(tmp->t);

  
  killArray(tmp->position);
  
  //killArray(tmp->alim);
  
  if(tmp->choose!=NULL)
    killArray(tmp->choose);
  if(tmp->back!=0)
    killHapStruct(tmp->hap);
  else
    delete tmp->hap;
  killArray(tmp->maf);
  killArray(tmp->chr); //COKE ROX
  killMatrix(tmp->post);
  if(tmp->convInfo!=NULL)
    killMatrix(tmp->convInfo);
  killArray(tmp->keepList);
  killArray(tmp->path);
  delete tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xa94b
movq 0x10(%rbx), %r15
movq 0x88(%rbx), %r14
cmpq %r15, %r14
je 0xb19e
movq 0x8(%r15), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r15, %rdi
callq 0x2230
movq 0x88(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0x40(%rbx), %rdi
callq 0xa94b
movq 0x50(%rbx), %rdi
callq 0xa94b
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0xb1d4
callq 0xa98b
cmpl $0x0, 0x78(%rbx)
movq 0x80(%rbx), %rdi
je 0xb1e8
callq 0xb0c5
jmp 0xb1f2
movl $0x28, %esi
callq 0x2230
movq 0x90(%rbx), %rdi
callq 0xa94b
movq 0x98(%rbx), %rdi
callq 0xa98b
movq 0xa0(%rbx), %r14
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0xa8(%rbx), %r14
testq %r14, %r14
je 0xb249
movq 0x8(%r14), %rdi
callq 0xa9ab
movl $0x10, %esi
movq %r14, %rdi
callq 0x2230
movq 0xb8(%rbx), %rdi
callq 0xa98b
movq 0xc0(%rbx), %rdi
callq 0xa98b
movl $0xf0, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocFloatArray(int)
fArray *allocFloatArray(int i){
  try{
    float *tmp= new float[i];
    fArray *darray = new fArray();
#if _fillup_
    for (int j=0;j<i;j++)
      tmp[j]=0.0;
#endif
    darray->x=i;
    darray->array=tmp;
    return darray;
  }catch(std::exception & e){
printf("\t-> Tried to allocate: %.3f gig memory\n",(float)sizeof(float)*i/1000000000);
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %r14d
shlq $0x2, %r14
testl %edi, %edi
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0x2030
movq %rax, %r15
movl $0x10, %edi
callq 0x2220
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
testl %ebx, %ebx
jle 0xb55e
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
movl %ebx, (%r12)
movq %r15, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb578
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xb5be
callq 0x20c0
cvtsi2ss %ebx, %xmm0
mulss 0x2f63(%rip), %xmm0     # 0xe4f4
divss 0x2f5f(%rip), %xmm0     # 0xe4f8
cvtss2sd %xmm0, %xmm0
leaq 0x2f8c(%rip), %rdi      # 0xe530
movb $0x1, %al
callq 0x2040
leaq 0x31e3(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/alloc.cpp
// Function: allocFloatMatrix(unsigned long, unsigned long)
fMatrix *allocFloatMatrix(size_t x, size_t y){
  try{
    fMatrix *tmp = new fMatrix();
    float **ppi = new float*[x];
    float *curPtr = new float [x * y];
    
    for(unsigned long int i = 0; i < x; ++i) {
      *(ppi + i) = curPtr;
      curPtr += y;
    }
#if _fillup_
    for (unsigned long int i=0;i<x;i++)
      for(unsigned long int n=0;n<y;n++)
	ppi[i][n]=0;
#endif
    
    tmp->matrix=ppi;
    tmp->x=x;
    tmp->y=y;
    return tmp;
  }catch(std::exception & e){
    printf("\t-> Tried to allocate: %.3f gig memory\n",(float)sizeof(float)*x*y/1000000000);
    printf("\t-> Allocation failed, likely cause: need more memory, will exit.\n");
    exit(0);
  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2220
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %r14, %rax
shrq $0x3d, %rax
leaq (,%r14,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x2030
movq %rax, %r12
movq %rbx, %rax
imulq %r14, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x2030
testq %r14, %r14
je 0xb666
leaq (,%rbx,4), %r13
xorl %ecx, %ecx
movq %rax, (%r12,%rcx,8)
incq %rcx
addq %r13, %rax
cmpq %rcx, %r14
jne 0xb63a
xorl %ebp, %ebp
testq %rbx, %rbx
je 0xb65e
movq (%r12,%rbp,8), %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2100
incq %rbp
cmpq %rbp, %r14
jne 0xb64b
movq %r12, 0x8(%r15)
movl %r14d, (%r15)
movl %ebx, 0x4(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb687
jmp 0xb687
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xb6a3
callq 0x20c0
testq %r14, %r14
js 0xb6a8
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
jmp 0xb6c1
callq 0x2400
movq %r14, %rax
shrq %rax
andl $0x1, %r14d
orq %rax, %r14
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
addss %xmm0, %xmm0
mulss 0x2e2b(%rip), %xmm0     # 0xe4f4
testq %rbx, %rbx
js 0xb6d5
cvtsi2ss %rbx, %xmm1
jmp 0xb6ea
movq %rbx, %rax
shrq %rax
andl $0x1, %ebx
orq %rax, %rbx
cvtsi2ss %rbx, %xmm1
addss %xmm1, %xmm1
mulss %xmm1, %xmm0
divss 0x2e02(%rip), %xmm0     # 0xe4f8
cvtss2sd %xmm0, %xmm0
leaq 0x2e2f(%rip), %rdi      # 0xe530
movb $0x1, %al
callq 0x2040
leaq 0x3086(%rip), %rdi      # 0xe795
callq 0x2370
xorl %edi, %edi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/evalAdmix.cpp
// Function: calcRes(float**, float*, unsigned short**, double**, double**, int, int, int, int, int**, int*)
void calcRes(float **r, float *mean_r, unsigned short int **G, double **Q, double **F, int K, int nSites, int nInd,int nIndUse,  int **isMissing, int *useInd){

  double sum_r[nIndUse];
  int usedSites[nIndUse];


  for(int i=0; i<nIndUse;i++){
    sum_r[i] = 0;
    usedSites[i] = 0;
  }

  for(int j=0; j<nSites;j++){
    //int u=0;
    for(int i=0; i<nInd;i++){
      if(useInd[i]){
      if(!isMissing[j][i]){
	
	double fpart=0; // individual freq pi
	
	for(int k=0; k<K; k++){
	  fpart += Q[i][k]*F[j][k];

	  
	}

	 
	r[i][j] = G[j][i] - 2 * fpart;
	sum_r[i] += r[i][j];
	usedSites[i]++;
	//	u++;
      }
      //else u++;
      }
      
    }
  }

  for(int i=0; i<nIndUse;i++){
    //fprintf(stderr, "ind %i has %i sites with data\n", i, usedSites[i]); 
    mean_r[i] = sum_r[i]/usedSites[i];

  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r15d
movq %r8, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, %r13
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movl 0x20(%rbp), %ecx
movl 0x10(%rbp), %edx
movq %rsp, %r14
leaq 0xf(,%rcx,8), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movq %rsp, %r12
leaq 0xf(,%rcx,4), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
testl %ecx, %ecx
jle 0xbc0d
leaq (,%rcx,8), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2100
movl 0x20(%rbp), %eax
leaq (,%rax,4), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2100
movl 0x10(%rbp), %edx
testl %edx, %edx
jle 0xbcde
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rcx
movl %edx, %edx
movq %rdx, -0x38(%rbp)
movl 0x18(%rbp), %edi
movl %r15d, %r8d
xorl %r9d, %r9d
cmpl $0x0, 0x18(%rbp)
jle 0xbcd1
xorl %r10d, %r10d
cmpl $0x0, (%rax,%r10,4)
je 0xbcc5
movq (%rcx,%r9,8), %rdx
cmpl $0x0, (%rdx,%r10,4)
jne 0xbcc5
testl %r15d, %r15d
jle 0xbc83
movq -0x40(%rbp), %rdx
movq (%rdx,%r10,8), %r11
movq -0x48(%rbp), %rdx
movq (%rdx,%r9,8), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%r11,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %r8
jne 0xbc6a
jmp 0xbc87
xorpd %xmm0, %xmm0
movq (%r13,%r9,8), %rdx
movzwl (%rdx,%r10,2), %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
addsd %xmm0, %xmm0
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movq (%rbx,%r10,8), %rdx
movss %xmm0, (%rdx,%r9,4)
cvtss2sd %xmm0, %xmm0
addsd (%r14,%r10,8), %xmm0
movsd %xmm0, (%r14,%r10,8)
incl (%r12,%r10,4)
incq %r10
cmpq %rdi, %r10
jne 0xbc39
incq %r9
cmpq -0x38(%rbp), %r9
jne 0xbc2c
movl 0x20(%rbp), %edx
testl %edx, %edx
movq -0x30(%rbp), %rcx
jle 0xbd12
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sdl (%r12,%rax,4), %xmm0
movsd (%r14,%rax,8), %xmm1
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rcx,%rax,4)
incq %rax
cmpq %rax, %rdx
jne 0xbceb
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/evalAdmix.cpp
// Function: correlateRes(int, float*, float*, double, double, int**, int, int)
double correlateRes(int nSites, float *r1, float *r2, double mean_r1, double mean_r2, int **isMissing, int ind1, int ind2){

  double cor_num=0;
  double cor_den1=0;
  double cor_den2=0;
  double d_r1=0;
  double d_r2=0;
  

  for(int j=0; j<nSites;j++){
    //if(j==368)
    //continue;
    if(!isMissing[j][ind1]&!isMissing[j][ind2]){
      d_r1 = (r1[j] - mean_r1);
      d_r2 = (r2[j] - mean_r2);
      cor_num += d_r1*d_r2;
      cor_den1 += d_r1*d_r1;
      cor_den2 += d_r2*d_r2;
    }
    
  }
  double cor;
  cor = cor_num/(sqrt(cor_den1)*sqrt(cor_den2));
  return cor;

}

// Assembly:
subq $0x28, %rsp
xorpd %xmm2, %xmm2
testl %edi, %edi
jle 0xbd8a
movslq %r8d, %rax
movslq %r9d, %r8
movl %edi, %edi
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
xorl %r9d, %r9d
movq (%rcx,%r9,8), %r10
movl (%r10,%r8,4), %r11d
orl (%r10,%rax,4), %r11d
jne 0xbd80
movss (%rdx,%r9,4), %xmm1
movss (%rsi,%r9,4), %xmm3
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
cvtps2pd %xmm3, %xmm1
subpd %xmm0, %xmm1
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm4
mulpd %xmm1, %xmm1
addpd %xmm1, %xmm5
incq %r9
cmpq %r9, %rdi
jne 0xbd44
jmp 0xbd92
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
ucomisd %xmm2, %xmm5
movapd %xmm4, 0x10(%rsp)
jb 0xbda7
xorps %xmm2, %xmm2
sqrtsd %xmm5, %xmm2
jmp 0xbdbe
movapd %xmm5, %xmm0
movapd %xmm5, (%rsp)
callq 0x2190
movapd (%rsp), %xmm5
movapd %xmm0, %xmm2
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jb 0xbdd5
xorps %xmm0, %xmm0
sqrtsd %xmm5, %xmm0
jmp 0xbde8
movapd %xmm5, %xmm0
movsd %xmm2, (%rsp)
callq 0x2190
movsd (%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/GenisGE[P]evalAdmix/ngsevalAdmix.cpp
// Function: correlateNGSRes(int, double*, double*, double, double, char**, int, int)
double correlateNGSRes(int nSites, double *r1, double *r2, double mean_r1, double mean_r2, char **keep, int ind1, int ind2){

  double cor_num=0;
  double cor_den1=0;
  double cor_den2=0;
  double d_r1=0;
  double d_r2=0;
  

  for(int j=0; j<nSites;j++){

    if(keep[j][ind1] == 1 & keep[j][ind2] == 1){
      d_r1 = (r1[j] - mean_r1);
      d_r2 = (r2[j] - mean_r2);

      cor_num += d_r1*d_r2;
      cor_den1 += d_r1*d_r1;
      cor_den2 += d_r2*d_r2;
    }
    
  }
  double cor;
  cor = cor_num/(sqrt(cor_den1)*sqrt(cor_den2));
  /*if(isnan(cor)){
    fprintf(stderr, "NaN generated when calculating residuals of individuals %i and %i \n", ind1, ind2);
    fprintf(stderr, "Numerator was %.3f, denominator was square root of %.3f times %.3f mean residual 1 was %.3f and mean residual 2 %.3f\n",cor_num, cor_den1, cor_den2, mean_r1, mean_r2);
    exit(0);
    }*/
  return cor;

}

// Assembly:
subq $0x28, %rsp
xorpd %xmm2, %xmm2
testl %edi, %edi
jle 0xc5e0
movslq %r8d, %rax
movslq %r9d, %r8
movl %edi, %edi
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
xorl %r9d, %r9d
movq (%rcx,%r9,8), %r10
cmpb $0x1, (%r10,%rax)
jne 0xc5d6
cmpb $0x1, (%r10,%r8)
jne 0xc5d6
movsd (%rsi,%r9,8), %xmm1
movhpd (%rdx,%r9,8), %xmm1     # xmm1 = xmm1[0],mem[0]
subpd %xmm0, %xmm1
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm4
mulpd %xmm1, %xmm1
addpd %xmm1, %xmm5
incq %r9
cmpq %r9, %rdi
jne 0xc59c
jmp 0xc5e8
xorpd %xmm5, %xmm5
xorpd %xmm4, %xmm4
ucomisd %xmm2, %xmm5
movapd %xmm4, 0x10(%rsp)
jb 0xc5fd
xorps %xmm2, %xmm2
sqrtsd %xmm5, %xmm2
jmp 0xc614
movapd %xmm5, %xmm0
movapd %xmm5, (%rsp)
callq 0x2190
movapd (%rsp), %xmm5
movapd %xmm0, %xmm2
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jb 0xc62b
xorps %xmm0, %xmm0
sqrtsd %xmm5, %xmm0
jmp 0xc63e
movapd %xmm5, %xmm0
movsd %xmm2, (%rsp)
callq 0x2190
movsd (%rsp), %xmm2
movapd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_co_sst.cpp
// Function: test_get_update_2()
void test_get_update_2() {
    // Test edge case with a tree of size 1.
    co_static_search_tree tree(1);
    tree.update(0, 2);
    if (tree.get(2) != 0) {
        cout << "test_get_update_2 failed: expected 2 at index 0." << endl;
        return;
    }
    tree.update(0, 5);
    if (tree.get(5) != 0) {
        cout << "test_get_update_2 failed: expected 5 at index 0." << endl;
        return;
    }
    tree.update(0, 501);
    if (tree.get(501) != 0) {
        cout << "test_get_update_2 failed: expected 501 at index 0." << endl;
        return;
    }
    cout << "test_get_update_2: OK" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x134c
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x15de
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x17bc
movl $0x30, %ebx
testl %eax, %eax
je 0x2b61
leaq 0x1726(%rip), %rsi      # 0x4285
jmp 0x2bd0
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x15de
leaq 0x8(%rsp), %rdi
movl $0x5, %esi
callq 0x17bc
testl %eax, %eax
je 0x2b8e
leaq 0x172a(%rip), %rsi      # 0x42b6
jmp 0x2bd0
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x15de
leaq 0x8(%rsp), %rdi
movl $0x1f5, %esi            # imm = 0x1F5
callq 0x17bc
testl %eax, %eax
leaq 0x1763(%rip), %rax      # 0x431a
leaq 0x1729(%rip), %rsi      # 0x42e7
cmoveq %rax, %rsi
movl $0x15, %eax
movl $0x32, %ebx
cmoveq %rax, %rbx
movq 0x4401(%rip), %r14      # 0x6fd8
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1140
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq 0x43d8(%rip), %rdi      # 0x6fd8
callq 0x1030
movq %rax, %rdi
callq 0x10b0
leaq 0x8(%rsp), %rdi
callq 0x13e6
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13e6
movq %rbx, %rdi
callq 0x11e0
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_co_sst.cpp
// Function: main
int main() {
    srand(10);
    chrono::steady_clock::time_point begin = chrono::steady_clock::now();
    test_get_update_1();
    test_get_update_2();
    test_get_update_3();
    test_get_update_4();
    test_get_update_5();
    test_range_update_small();
    test_range_update_uniform(16);
    test_range_update_uniform(20);
    test_range_update_uniform(100);
    test_range_update_uniform(500);
    test_range_update_uniform(1e6);
    chrono::steady_clock::time_point end = chrono::steady_clock::now();
    cout << "Time difference = " << chrono::duration_cast<chrono::microseconds>(end - begin).count() << "[µs]" << std::endl;

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0xa, %edi
callq 0x10f0
callq 0x1170
movq %rax, %rbx
callq 0x291c
callq 0x2b15
callq 0x2c37
callq 0x2e0e
callq 0x3013
callq 0x3252
movl $0x10, %edi
callq 0x3487
movl $0x14, %edi
callq 0x3487
movl $0x64, %edi
callq 0x3487
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x3487
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x3487
callq 0x1170
movq %rax, %r14
movq 0x3808(%rip), %r15      # 0x6fd8
leaq 0xcbc(%rip), %rsi       # 0x4493
movl $0x12, %edx
movq %r15, %rdi
callq 0x1140
subq %rbx, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x10e0
movq %rax, %rbx
leaq 0xc8f(%rip), %rsi       # 0x44a6
movl $0x5, %edx
movq %rax, %rdi
callq 0x1140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/TracyLaiMan[P]GLib_Example/GLibExample.cpp
// Function: glib::GLibExample::init()
bool GLibExample::init(){
    std::cout << "GLibExample::init" << std::endl;

    m_workerContext = g_main_context_new();

    if (nullptr == m_workerContext) {
        return false;
    }

    m_eventLoop = g_main_loop_new(m_workerContext, false);
    if (nullptr == m_eventLoop) {
        return false;
    }

    m_eventThread = std::thread(&GLibExample::mainLoopThread, this);
 
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x2b51(%rip), %r14      # 0x4fd0
leaq 0xb7e(%rip), %rsi       # 0x3004
movl $0x11, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
callq 0x21d0
movq %rax, 0x8(%rbx)
xorl %r14d, %r14d
testq %rax, %rax
je 0x2515
movq %rax, %rdi
xorl %esi, %esi
callq 0x2110
movq %rax, (%rbx)
testq %rax, %rax
je 0x2515
leaq 0x42(%rip), %rax        # 0x2526
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
leaq -0x20(%rbp), %rdx
movq %rbx, (%rdx)
leaq -0x18(%rbp), %rdi
callq 0x2618
cmpq $0x0, 0x28(%rbx)
jne 0x2521
movq -0x18(%rbp), %rax
movq %rax, 0x28(%rbx)
movb $0x1, %r14b
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2050
// File: /workspace/github_cpp_makefile_star2_O3/TracyLaiMan[P]GLib_Example/GLibExample.cpp
// Function: glib::GLibExample::mainLoopThread()
void GLibExample::mainLoopThread(){
    g_main_context_push_thread_default(m_workerContext);
    do{
        std::cout << "mainLoopThread running" << std::endl;
        g_main_loop_run(m_eventLoop);
    }while(false);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2040
movq 0x2a90(%rip), %r14      # 0x4fd0
leaq 0xacf(%rip), %rsi       # 0x3016
movl $0x16, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/TracyLaiMan[P]GLib_Example/GLibExample.cpp
// Function: glib::GLibExample::SourceEventTest()
void GLibExample::SourceEventTest(){
    
    auto source = g_idle_source_new();
    g_source_set_callback(source, reinterpret_cast<GSourceFunc>(&onEventCallback), this, nullptr);
    g_source_attach(source, m_workerContext);
    g_source_unref(source);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20a0
movq %rax, %r14
leaq 0x25(%rip), %rsi        # 0x25c6
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2220
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O3/TracyLaiMan[P]GLib_Example/main.cpp
// Function: main
int main(int argc, char **argv){

    auto example = glib::GLibExample::create();
    std::cout << "***Hi GLib***" << std::endl;
    while(1)
    {
	example->SourceEventTest();
        sleep(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rdi
callq 0x23ec
movq 0x2283(%rip), %rbx      # 0x4fd0
leaq 0x4ce(%rip), %rsi       # 0x3222
movl $0xd, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq 0x2251(%rip), %rdi      # 0x4fd0
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq -0x18(%rbp), %rdi
callq 0x2588
movl $0x1, %edi
callq 0x20f0
jmp 0x2d8c
jmp 0x2da3
movq %rax, %rbx
movq -0x10(%rbp), %rdi
testq %rdi, %rdi
je 0x2db4
callq 0x289e
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/ke6jjj[P]r-dat/RDATDecoder.cc
// Function: RDATDecoder::RDATDecoder(float)
RDATDecoder::RDATDecoder(float sampleRate)
: mSyncWindowCurPos(0), mSyncWindowSyncPos(0),
  mClockDetected(false), mClockRatioThreshold(0.97),
  mClockAlpha(1.0 / 30.0),
  //
  // A track is 196 blocks in duration. Convert that to samples and
  // add padding.
  //
  mTrackDuration((sampleRate / kSymbolRate) * 10 * 36 * 196 * 1.05),
  mTrackInProgress(false)
{
  int i;
  
  //
  // Create a filter bank/window for the clock detector.
  //
  mSyncWindowSize = sampleRate / kSymbolRate;
  mSyncWindow = new float[mSyncWindowSize];
  mSyncWindowEvalPos = mSyncWindowSize / 2;
  mSyncWindowNextEvalPos = mSyncWindowEvalPos;
  
  for (i = 0; i < mSyncWindowSize; i++)
    mSyncWindow[i] = 0.0;

  //
  // Keep a history of the sign of the last sample.
  //
  mLastSign = 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xd162(%rip), %rax      # 0xf9e0
movq %rax, (%rdi)
movq $0x0, 0x1c(%rdi)
xorl %eax, %eax
movb %al, 0x2c(%rdi)
movsd 0x6a1a(%rip), %xmm1     # 0x92b0
movsd %xmm1, 0x30(%rdi)
divss 0x6a2d(%rip), %xmm0     # 0x92d0
movss 0x6a29(%rip), %xmm1     # 0x92d4
mulss %xmm0, %xmm1
mulss 0x6a21(%rip), %xmm1     # 0x92d8
mulss 0x6a1d(%rip), %xmm1     # 0x92dc
movb %al, 0x40(%rdi)
cvtss2sd %xmm1, %xmm1
mulsd 0x6a1a(%rip), %xmm1     # 0x92e8
cvttsd2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x6a0e(%rip), %xmm1     # 0x92f0
cvttsd2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
cvttss2si %xmm0, %ebp
movq %rdx, 0x48(%rdi)
movl %ebp, 0x18(%rdi)
movslq %ebp, %r14
leaq (,%r14,4), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movl %r14d, %ecx
shrl $0x1f, %ecx
addl %ebp, %ecx
sarl %ecx
movq %rax, 0x10(%rbx)
movl %ecx, 0x24(%rbx)
movl %ecx, 0x28(%rbx)
testl %r14d, %r14d
jle 0x293f
movl %ebp, %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x20a0
movb $0x0, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ke6jjj[P]r-dat/RDATDecoder.cc
// Function: RDATDecoder::ClockDetect(float)
bool
RDATDecoder::ClockDetect(float sample)
{
  bool syncNow = false;
  
  mSyncWindow[mSyncWindowCurPos] *= (1.0 - mClockAlpha);
  mSyncWindow[mSyncWindowCurPos] += fabs(sample) * mClockAlpha;

  //
  // If we're at the currently suggested sync window position,
  // remember so.
  //
  if (mSyncWindowCurPos == mSyncWindowSyncPos) {
    syncNow = true;
    
    //
    // Do a staggered update of the sync window evaluation
    // position based on the last position calculation.
    //
    mSyncWindowEvalPos = mSyncWindowNextEvalPos;
  }

  if (mSyncWindowCurPos == mSyncWindowEvalPos) {
      //
      // Take this opportunity to rescan the window,
      // looking for the highest energy peak and thus, the
      // best synchronization point.
      //
      EvaluateClock();
  }
  
  //
  // Advance the window, wrapping if necessary.
  //
  if (++mSyncWindowCurPos == mSyncWindowSize)
    //
    // We've reached the end of the window.
    // Wrap around.
    //
    mSyncWindowCurPos = 0;  
  
  return mClockDetected && syncNow;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cvtss2sd 0x34(%rdi), %xmm1
movsd 0x6870(%rip), %xmm2     # 0x92f8
subsd %xmm1, %xmm2
movq 0x10(%rdi), %rax
movslq 0x1c(%rdi), %r14
xorps %xmm1, %xmm1
cvtss2sd (%rax,%r14,4), %xmm1
mulsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rax,%r14,4)
andps 0x680e(%rip), %xmm0     # 0x92c0
mulss 0x34(%rdi), %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%r14,4)
movl 0x20(%rdi), %ebp
cmpl %ebp, %r14d
jne 0x2ad1
movl 0x28(%rbx), %eax
movl %eax, 0x24(%rbx)
jmp 0x2ad4
movl 0x24(%rbx), %eax
movl %r14d, %ecx
cmpl %eax, %r14d
jne 0x2ae7
movq %rbx, %rdi
callq 0x2b0c
movl 0x1c(%rbx), %ecx
cmpl %ebp, %r14d
sete %al
incl %ecx
xorl %edx, %edx
cmpl 0x18(%rbx), %ecx
cmovnel %ecx, %edx
movl %edx, 0x1c(%rbx)
andb 0x2c(%rbx), %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ke6jjj[P]r-dat/RDATDecoder.cc
// Function: RDATDecoder::EvaluateClock()
void
RDATDecoder::EvaluateClock()
{
  int i, maxI, minI;
  float max = 0.0, min = 100.0, ratio;

  for (i = maxI = 0; i < mSyncWindowSize; i++) {
    //
    // Find the highest peak.
    //
    if (mSyncWindow[i] > max) {
      max = mSyncWindow[i];
      maxI = i;
    }
    //
    // And the lowest valley.
    //
    if (mSyncWindow[i] < min)
      min = mSyncWindow[i];
  }
  
  if (maxI != mSyncWindowSyncPos) {
    //
    // We've found a new sync position.
    // In the future we might calculate clock error here.
    //
    mSyncWindowSyncPos = maxI;
    mSyncWindowNextEvalPos = (maxI + mSyncWindowSize / 2) %
                              mSyncWindowSize;
  }
  
  //
  // If there is a significant difference between the highest
  // peak and the lowest valley then we have a good clock signal.
  //
  if (max > 0.0)
    ratio = min / max;
  else
    ratio = 0.0;

  if (ratio < mClockRatioThreshold) {
    if (!mClockDetected && mDecoder != NULL)
      mDecoder->ClockDetected(true);
    mClockDetected = true;
  } else {
    if (mClockDetected && mDecoder != NULL)
      mDecoder->ClockDetected(false);
    mClockDetected = false;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x2b54
movq 0x10(%rbx), %rax
xorl %esi, %esi
xorps %xmm3, %xmm3
movss 0x67b8(%rip), %xmm2     # 0x92e4
xorl %edx, %edx
movss (%rax,%rsi,4), %xmm0
ucomiss %xmm3, %xmm0
cmoval %esi, %edx
movaps %xmm0, %xmm1
maxss %xmm3, %xmm1
minss %xmm2, %xmm0
incq %rsi
movaps %xmm0, %xmm2
movaps %xmm1, %xmm3
cmpq %rsi, %rcx
jne 0x2b2e
jmp 0x2b61
xorl %edx, %edx
movss 0x6786(%rip), %xmm0     # 0x92e4
xorps %xmm1, %xmm1
cmpl 0x20(%rbx), %edx
je 0x2b7a
movl %edx, 0x20(%rbx)
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
addl %edx, %eax
cltd
idivl %ecx
movl %edx, 0x28(%rbx)
divss %xmm1, %xmm0
xorps %xmm2, %xmm2
cmpltss %xmm1, %xmm2
andps %xmm0, %xmm2
movss 0x30(%rbx), %xmm0
ucomiss %xmm2, %xmm0
movb 0x2c(%rbx), %al
jbe 0x2bb0
movb $0x1, %bpl
testb %al, %al
jne 0x2bcb
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2bcb
movq (%rdi), %rax
movl $0x1, %esi
jmp 0x2bc4
testb %al, %al
je 0x2bc9
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2bc9
movq (%rdi), %rax
xorl %ebp, %ebp
xorl %esi, %esi
callq *0x8(%rax)
jmp 0x2bcb
xorl %ebp, %ebp
movb %bpl, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::DumpWord(unsigned short, unsigned short)
void
DATWordReceiver::DumpWord(uint16_t raw, uint16_t decode)
{
  if (decode & WORD_SYNC) {
    printf("\nSYNC");
  } else if (decode & WORD_ATF2) {
    printf(" AT2");
  } else if (decode & WORD_ATF3) {
    printf(" AT3");
  } else if (decode & WORD_INVALID) {
    printf(" XXX");
  } else {
    printf(" %02x", decode);
  }
}

// Assembly:
btl $0x8, %edx
jb 0x2d87
btl $0x9, %edx
jb 0x2d90
btl $0xa, %edx
jb 0x2d99
testw %dx, %dx
js 0x2da2
leaq 0x6dd7(%rip), %rdi      # 0x9b55
movl %edx, %esi
xorl %eax, %eax
jmp 0x2040
leaq 0x6db2(%rip), %rdi      # 0x9b40
jmp 0x2da9
leaq 0x6daf(%rip), %rdi      # 0x9b46
jmp 0x2da9
leaq 0x6dab(%rip), %rdi      # 0x9b4b
jmp 0x2da9
leaq 0x6da7(%rip), %rdi      # 0x9b50
xorl %eax, %eax
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::ReceiveWord(unsigned short, unsigned short)
void
DATWordReceiver::ReceiveWord(uint16_t raw, uint16_t decode)
{
  if (decode & WORD_SYNC)
    mBlock.Reset();
  if (decode & WORD_ATF2)
    mBlockReceiver->ReceiveATFTone(2);
  if (decode & WORD_ATF3)
    mBlockReceiver->ReceiveATFTone(3);

  bool complete = mBlock.AddByte(raw, decode);

  if (complete)
    DumpCurrentBlock();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
btl $0x8, %edx
jae 0x2dce
leaq 0x8(%rbx), %rdi
callq 0x2f52
btl $0x9, %ebp
jae 0x2de6
movq 0xa0(%rbx), %rdi
movq (%rdi), %rax
movl $0x2, %esi
callq *0x10(%rax)
btl $0xa, %ebp
jae 0x2dfe
movq 0xa0(%rbx), %rdi
movq (%rdi), %rax
movl $0x3, %esi
callq *0x10(%rax)
leaq 0x8(%rbx), %r15
movzwl %r14w, %esi
movzwl %bp, %edx
movq %r15, %rdi
callq 0x2f5e
testb %al, %al
je 0x2e37
movq 0xa0(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x8(%rax)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2f52
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::TrackDetected(bool)
void
DATWordReceiver::TrackDetected(bool up)
{
  if (mDump)
    return;

  if (up == false) {
    //
    // Track is ending. Dump any pending blocks.
    //
    DumpCurrentBlock();
  }

  //
  // Notify the block receiver of the new track state.
  //
  mBlockReceiver->TrackDetected(up);
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x2e6a
retq
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testb %bl, %bl
jne 0x2e94
movq 0xa0(%r14), %rdi
leaq 0x8(%r14), %r15
movq (%rdi), %rax
movq %r15, %rsi
callq *0x8(%rax)
movq %r15, %rdi
callq 0x2f52
movq 0xa0(%r14), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movzbl %bl, %esi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O3/ke6jjj[P]r-dat/DATWordReceiver.cc
// Function: DATWordReceiver::Stop()
void
DATWordReceiver::Stop()
{
  if (mBlock.Size() > 0)
    DumpCurrentBlock();
  if (mBlockReceiver != NULL)
    mBlockReceiver->Stop();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x2f88
testq %rax, %rax
je 0x2edc
movq 0xa0(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x2f52
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x2ef5
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)