LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: GenisGE[P]evalAdmix/filereader_and_conversions.cpp
// Function: getNext(iArray*, int)
int getNext(iArray *list,int i){
  if(i>=list->x)
    return -1;
  for(int j=i;j<list->x;j++){
    // printf("i:%d\tj:%d\tiar:%d\n",i,j,list->array[i]);
    if(list->array[j]==1)
      return j;
  }
  return -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jl 0xc410
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0xc45a
movl -0x14(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc452
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0xc443
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xc45a
jmp 0xc445
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xc418
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nop
// File: GenisGE[P]evalAdmix/filereader_and_conversions.cpp
// Function: numberOfLines(char const*)
int numberOfLines(const char *filename){
  const int SIZE=500000;
  char buffer[SIZE];
  int numLines=0;
  std::ifstream pFile (filename,std::ios::in);
  
  if(!pFile){
fileError(filename);
    return 0;
  }
  while(!pFile.eof()){
    pFile.getline(buffer,SIZE);
    numLines++;
  }
  return numLines;
}

// Assembly:
subq $0x7a3a8, %rsp          # imm = 0x7A3A8
movq %rdi, 0x7a398(%rsp)
movl $0x7a120, 0x7a394(%rsp) # imm = 0x7A120
movl $0x0, 0x26c(%rsp)
movq 0x7a398(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movl $0x8, %edx
callq 0x3540
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x60(%rsp,%rax), %rdi
callq 0x3120
movb %al, 0x27(%rsp)
jmp 0xd085
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xd092
jmp 0xd146
movq 0x7a398(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3500
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x9280
jmp 0xd0c4
leaq 0x30(%rsp), %rdi
callq 0xa100
jmp 0xd0d0
leaq 0x30(%rsp), %rdi
callq 0x3170
leaq 0x2f(%rsp), %rdi
callq 0x32e0
movl $0x0, 0x7a3a4(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0xd1af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xd1c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xd137
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3170
leaq 0x2f(%rsp), %rdi
callq 0x32e0
jmp 0xd1c8
jmp 0xd148
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x60(%rsp,%rax), %rdi
callq 0x3550
movb %al, 0xf(%rsp)
jmp 0xd161
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd16d
jmp 0xd199
leaq 0x60(%rsp), %rdi
leaq 0x270(%rsp), %rsi
movl $0x7a120, %edx          # imm = 0x7A120
callq 0x30c0
jmp 0xd186
movl 0x26c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x26c(%rsp)
jmp 0xd148
movl 0x26c(%rsp), %eax
movl %eax, 0x7a3a4(%rsp)
movl $0x1, 0x28(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3080
movl 0x7a3a4(%rsp), %eax
addq $0x7a3a8, %rsp          # imm = 0x7A3A8
retq
leaq 0x60(%rsp), %rdi
callq 0x3080
movq 0x58(%rsp), %rdi
callq 0x34f0
nopl (%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(iArray*, iMatrix*)
iMatrix *extractOK(iArray *okList,iMatrix *matr){
  iMatrix *returnMatrix = allocIntMatrix(matr->x,okList->x);
  for(int j=0;j<matr->x;j++)
    for(int i=0;i<okList->x;i++)
      returnMatrix->matrix[j][i] = matr->matrix [j] [okList->array[i]];
  return returnMatrix;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %edi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0x13c40
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10b0d
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10afe
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10aa3
jmp 0x10b00
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10a8e
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(iArray*, usiMatrix*)
usiMatrix *extractOK(iArray *okList,usiMatrix *matr){
  usiMatrix *returnMatrix = allocUSIntMatrix(matr->x,okList->x);
  for(int j=0;j<matr->x;j++)
    for(int i=0;i<okList->x;i++)
      returnMatrix->matrix[j][i] = matr->matrix [j] [okList->array[i]];
  return returnMatrix;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %edi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0x13e70
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10bd2
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10bc0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movw (%rax,%rcx,2), %dx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10b63
jmp 0x10bc2
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10b4e
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(iArray*, dMatrix*)
dMatrix *extractOK(iArray *okList,dMatrix *matr){
  dMatrix *returnMatrix = allocDoubleMatrix(matr->x,okList->x);
  for(int j=0;j<matr->x;j++)
    for(int i=0;i<okList->x;i++)
      returnMatrix->matrix[j][i] = matr->matrix [j] [okList->array[i]];
  return returnMatrix;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %edi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0x14480
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10c94
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10c82
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10c23
jmp 0x10c84
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10c0e
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(iArray*, iArray*)
iArray *extractOK(iArray *okList,iArray *array){
  iArray *returnArray = allocIntArray(okList->x);
  for(int j=0;j<okList->x;j++)
    returnArray->array[j] = array->array[okList->array[j]];
  return returnArray;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movslq (%rax), %rdi
callq 0x14740
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10d11
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0xc(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10cc8
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(iArray*, dArray*)
dArray *extractOK(iArray *okList,dArray *array){
  dArray *returnArray = allocDoubleArray(okList->x);
  int extractIndex;
  double var;
  for(int j=0;j<okList->x;j++){
    extractIndex = okList->array[j];
    var = array->array[extractIndex];
    returnArray->array[j] = var;
  }
  return returnArray;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %edi
callq 0x14a30
movq %rax, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10da8
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10d47
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(bArray*, dArray*)
dArray *extractOK(bArray *okList,dArray *array){
  dArray *returnArray = allocDoubleArray(okList->numTrue);
  int inPlace = 0;
  for(int j=0 ; j<okList->x ; j++){
    if(okList->array[j] == 1){
      returnArray->array[inPlace] = array->array[j];
      inPlace++;
    }
  }
  return returnArray;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x14a30
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10e51
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x10e42
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10e44
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10df0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(bArray*, iArray*)
iArray *extractOK(bArray *okList,iArray *array){
  iArray *returnArray = allocIntArray(okList->numTrue);
  int inPlace = 0;
  for(int j=0 ; j<okList->x ; j++){
    if(okList->array[j] == 1){
      returnArray->array[inPlace] = array->array[j];
      inPlace++;
    }
  }
  return returnArray;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movslq 0x4(%rax), %rdi
callq 0x14740
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10eee
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x10edf
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10ee1
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10e91
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(bArray*, iMatrix*)
iMatrix *extractOK(bArray *okList,iMatrix *matr){
  iMatrix *returnMatrix = allocIntMatrix(matr->x,okList->numTrue);
  int atPos =0;
  for(int i=0;i<matr->y;i++)
    if(okList->array[i]){
      for(int j=0;j<matr->x;j++)
	returnMatrix->matrix[j][atPos] = matr->matrix [j] [i];
      atPos++;
    }
  return returnMatrix;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %edi
movq 0x20(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x13c40
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x10fd0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x10fbe
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10fb3
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x10f65
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10fc0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10f37
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extractOK(bArray*, usiMatrix*)
usiMatrix *extractOK(bArray *okList,usiMatrix *matr){
  usiMatrix *returnMatrix = allocUSIntMatrix(matr->x,okList->numTrue);
  int atPos =0;
  for(int i=0;i<matr->y;i++)
    if(okList->array[i]){
      for(int j=0;j<matr->x;j++)
	returnMatrix->matrix[j][atPos] = matr->matrix [j] [i];
      atPos++;
    }
  return returnMatrix;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %edi
movq 0x20(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x13e70
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x110b2
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x8(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x110a0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x11095
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movw (%rax,%rcx,2), %dx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x11045
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x110a2
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x11017
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extract(dMatrix*, iArray*)
dArray *extract( dMatrix *var,iArray *choose){
  dArray *retVal = allocDoubleArray(choose->x-1);
   for (int i=1;i<var->y;i++){
    retVal->array[i-1]=var->matrix[choose->array[i]][i];
  }
  return retVal;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %edi
subl $0x1, %edi
callq 0x14a30
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x11146
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0xc(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x110ea
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
// File: GenisGE[P]evalAdmix/extractors.cpp
// Function: extract(iArray*, iArray*)
iArray *extract(iArray *var,iArray *choose){
  iArray *retVal = allocIntArray(var->x-1);
  for (int i=1;i<var->x;i++)
    retVal->array[i-1]=var->array[i-1-choose->array[i]];
  return retVal;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
movslq %eax, %rdi
callq 0x14740
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x111d4
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movq 0x18(%rsp), %rdx
movq 0x8(%rdx), %rdx
movslq 0xc(%rsp), %rsi
subl (%rdx,%rsi,4), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1117d
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: GenisGE[P]evalAdmix/asort.cpp
// Function: comp(dats const&, dats const&)
bool comp(const dats& first,const dats& second){
  if(first.chr==second.chr)
    return first.pos<second.pos;
  else
    return first.chr<second.chr;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x1121d
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x11234
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x143c7
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x32b0
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x14130
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x14130
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x14475
movq 0x8(%rsp), %rdi
movl $0x78, %esi
callq 0x32b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movl $0x10, %edi
callq 0x32a0
movq %rax, 0x18(%rsp)
jmp 0x1449d
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, 0x58(%rsp)
movslq 0x64(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rsp)
jmp 0x144d4
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x64(%rsp), %eax
movl 0x60(%rsp), %ecx
imull %ecx, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, 0x8(%rsp)
jmp 0x1450d
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x64(%rsp), %eax
jge 0x145e6
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x60(%rsp), %ecx
movq 0x38(%rsp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1451f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x14687
movq 0x50(%rsp), %rdi
callq 0x30e0
movq %rax, 0x20(%rsp)
cvtsi2ssl 0x64(%rsp), %xmm0
movss 0x4f3f(%rip), %xmm1     # 0x194e0
mulss %xmm1, %xmm0
cvtsi2ssl 0x60(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x4f25(%rip), %xmm1     # 0x194dc
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x4f3e(%rip), %rdi      # 0x19504
movb $0x1, %al
callq 0x3040
jmp 0x145cf
leaq 0x4eae(%rip), %rdi      # 0x19484
xorl %eax, %eax
callq 0x3040
jmp 0x145df
xorl %edi, %edi
callq 0x3340
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x64(%rsp), %eax
jge 0x14641
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x60(%rsp), %eax
jge 0x14632
movq 0x40(%rsp), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x2c(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x14600
jmp 0x14634
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x145ee
movq 0x40(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x64(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, (%rax)
movl 0x60(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x58(%rsp), %rax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x34b0
jmp 0x14685
jmp 0x14687
movq 0x50(%rsp), %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x94a0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movss %xmm0, 0x1c(%rsp)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x14480
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x1472a
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x1471b
movss 0x1c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x146de
jmp 0x1471d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x146cc
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, 0x18(%rsp)
jmp 0x14770
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x10, %edi
callq 0x32a0
movq %rax, 0x10(%rsp)
jmp 0x1478b
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3140
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpq 0x50(%rsp), %rax
jae 0x148a4
movq 0x48(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl $0x0, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x147ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x148e1
movq 0x40(%rsp), %rdi
callq 0x30e0
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x8(%rsp)
testq %rax, %rax
movss %xmm0, 0xc(%rsp)
js 0x14846
movss 0x8(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
movss 0x4c8c(%rip), %xmm1     # 0x194e0
mulss %xmm1, %xmm0
movss 0x4c7c(%rip), %xmm1     # 0x194dc
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x4c95(%rip), %rdi      # 0x19504
movb $0x1, %al
callq 0x3040
jmp 0x14878
movq 0x50(%rsp), %rsi
leaq 0x4ca8(%rip), %rdi      # 0x1952c
xorl %eax, %eax
callq 0x3040
jmp 0x1488d
leaq 0x4bf0(%rip), %rdi      # 0x19484
xorl %eax, %eax
callq 0x3040
jmp 0x1489d
xorl %edi, %edi
callq 0x3340
movq 0x50(%rsp), %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x48(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x34b0
jmp 0x148df
jmp 0x148e1
movq 0x40(%rsp), %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x94a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movslq 0x44(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, 0x8(%rsp)
jmp 0x1492f
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x10, %edi
callq 0x32a0
movq %rax, (%rsp)
jmp 0x14949
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3140
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x149d3
movq 0x38(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1496a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x14a19
movq 0x30(%rsp), %rdi
callq 0x30e0
movq %rax, 0x10(%rsp)
leaq 0x4ac1(%rip), %rdi      # 0x19484
xorl %eax, %eax
callq 0x3040
jmp 0x149cc
xorl %edi, %edi
callq 0x3340
movl 0x44(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x4(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x34b0
jmp 0x14a17
jmp 0x14a19
movq 0x30(%rsp), %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x94a0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movslq 0x44(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, 0x8(%rsp)
jmp 0x14a5f
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x10, %edi
callq 0x32a0
movq %rax, (%rsp)
jmp 0x14a79
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3140
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x14b3e
movq 0x38(%rsp), %rax
movslq 0x1c(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x14a9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x14b78
movq 0x30(%rsp), %rdi
callq 0x30e0
movq %rax, 0x10(%rsp)
cvtsi2ssl 0x44(%rsp), %xmm0
movss 0x49dd(%rip), %xmm1     # 0x194e0
mulss %xmm1, %xmm0
movss 0x49cd(%rip), %xmm1     # 0x194dc
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x49e6(%rip), %rdi      # 0x19504
movb $0x1, %al
callq 0x3040
jmp 0x14b27
leaq 0x4956(%rip), %rdi      # 0x19484
xorl %eax, %eax
callq 0x3040
jmp 0x14b37
xorl %edi, %edi
callq 0x3340
movl 0x44(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x34b0
jmp 0x14b76
jmp 0x14b78
movq 0x30(%rsp), %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x94a0
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x10, %edi
callq 0x32a0
movq %rax, 0x8(%rsp)
jmp 0x14baa
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, (%rsp)
jmp 0x14be3
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x14c71
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x14bf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x14cae
movq 0x30(%rsp), %rdi
callq 0x30e0
movq %rax, 0x10(%rsp)
leaq 0x4823(%rip), %rdi      # 0x19484
xorl %eax, %eax
callq 0x3040
jmp 0x14c6a
xorl %edi, %edi
callq 0x3340
movq 0x40(%rsp), %rax
movl (%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x34b0
jmp 0x14cac
jmp 0x14cae
movq 0x30(%rsp), %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x94a0
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x142b0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14130
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x14130
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x14d45
movq 0x8(%rsp), %rdi
callq 0x158a0
movq 0x8(%rsp), %rdi
movl $0x178, %esi            # imm = 0x178
callq 0x32b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x14dbd
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x32b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x14e0b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x14e52
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x14130
movq 0x10(%rsp), %rax
cmpl $0x0, 0x78(%rax)
je 0x14e70
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x14d50
jmp 0x14e98
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x14e96
movq 0x8(%rsp), %rdi
movl $0x28, %esi
callq 0x32b0
jmp 0x14e98
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdi
callq 0x14090
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0x14130
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x14eeb
movq 0x10(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x14270
movq 0x10(%rsp), %rax
movq 0xb8(%rax), %rdi
callq 0x14130
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rdi
callq 0x14130
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x14f2a
movq (%rsp), %rdi
movl $0xf0, %esi
callq 0x32b0
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movslq 0x44(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, 0x8(%rsp)
jmp 0x1538f
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x10, %edi
callq 0x32a0
movq %rax, (%rsp)
jmp 0x153a9
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3140
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x1546e
movq 0x38(%rsp), %rax
movslq 0x1c(%rsp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x153ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x154a8
movq 0x30(%rsp), %rdi
callq 0x30e0
movq %rax, 0x10(%rsp)
cvtsi2ssl 0x44(%rsp), %xmm0
movss 0x40a5(%rip), %xmm1     # 0x194d8
mulss %xmm1, %xmm0
movss 0x409d(%rip), %xmm1     # 0x194dc
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x40b6(%rip), %rdi      # 0x19504
movb $0x1, %al
callq 0x3040
jmp 0x15457
leaq 0x4026(%rip), %rdi      # 0x19484
xorl %eax, %eax
callq 0x3040
jmp 0x15467
xorl %edi, %edi
callq 0x3340
movl 0x44(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x34b0
jmp 0x154a6
jmp 0x154a8
movq 0x30(%rsp), %rdi
callq 0x34f0
movq %rax, %rdi
callq 0x94a0
nopw (%rax,%rax)
// File: GenisGE[P]evalAdmix/evalAdmix.cpp
// Function: allocFloat2(unsigned long, unsigned long)
float **allocFloat2(size_t x,size_t y){
  float **ret= new float*[x];
  for(size_t i=0;i<x;i++)
    ret[i] = new float[y];
  //printf("\t-> Tried to allocate: %.3f gig memory\n",(float)sizeof(float)*x*y/1000000000);
  return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x15a55
movq 0x18(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x15a02
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: 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 $0x88, %rsp
movl %edi, 0x84(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movsd %xmm1, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movl %r9d, 0x50(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x84(%rsp), %eax
jge 0x161e8
movq 0x58(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x54(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movq 0x58(%rsp), %rcx
movslq 0x24(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x50(%rsp), %rdx
cmpl $0x0, (%rcx,%rdx,4)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x161d6
movq 0x78(%rsp), %rax
movslq 0x24(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
subsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x70(%rsp), %rax
movslq 0x24(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
subsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x48(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
movsd 0x40(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x161d8
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x160d8
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x31f0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x31f0
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: 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 $0x88, %rsp
movl %edi, 0x84(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movsd %xmm1, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movl %r9d, 0x50(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x84(%rsp), %eax
jge 0x16ff1
movq 0x58(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x54(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movq 0x58(%rsp), %rcx
movslq 0x24(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x50(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl $0x1, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x16fdf
movq 0x78(%rsp), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x70(%rsp), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x48(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
movsd 0x40(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x16fe1
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x16ee8
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm0
callq 0x31f0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x31f0
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movl $0x1, %esi
callq 0x1360
movq -0xd8(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x16c0
jmp 0x57d8
leaq -0xc0(%rbp), %rdi
movl $0x2, %esi
callq 0x18e0
movl %eax, -0xdc(%rbp)
jmp 0x57f1
movl -0xdc(%rbp), %eax
cmpl $0x0, %eax
je 0x585f
movq 0x47d5(%rip), %rdi      # 0x9fd8
leaq 0x19fb(%rip), %rsi      # 0x7205
callq 0x10e0
movq %rax, -0xe8(%rbp)
jmp 0x5818
movq -0xe8(%rbp), %rdi
movq 0x47a2(%rip), %rsi      # 0x9fc8
callq 0x1120
jmp 0x582d
movl $0x1, -0xd0(%rbp)
jmp 0x5989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x1420
jmp 0x599e
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x16c0
jmp 0x5874
leaq -0xc0(%rbp), %rdi
movl $0x5, %esi
callq 0x18e0
movl %eax, -0xec(%rbp)
jmp 0x588d
movl -0xec(%rbp), %eax
cmpl $0x0, %eax
je 0x58d8
movq 0x4739(%rip), %rdi      # 0x9fd8
leaq 0x1990(%rip), %rsi      # 0x7236
callq 0x10e0
movq %rax, -0xf8(%rbp)
jmp 0x58b4
movq -0xf8(%rbp), %rdi
movq 0x4706(%rip), %rsi      # 0x9fc8
callq 0x1120
jmp 0x58c9
movl $0x1, -0xd0(%rbp)
jmp 0x5989
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x16c0
jmp 0x58ed
leaq -0xc0(%rbp), %rdi
movl $0x1f5, %esi            # imm = 0x1F5
callq 0x18e0
movl %eax, -0xfc(%rbp)
jmp 0x5906
movl -0xfc(%rbp), %eax
cmpl $0x0, %eax
je 0x594e
movq 0x46c0(%rip), %rdi      # 0x9fd8
leaq 0x1948(%rip), %rsi      # 0x7267
callq 0x10e0
movq %rax, -0x108(%rbp)
jmp 0x592d
movq -0x108(%rbp), %rdi
movq 0x468d(%rip), %rsi      # 0x9fc8
callq 0x1120
jmp 0x5942
movl $0x1, -0xd0(%rbp)
jmp 0x5989
movq 0x4683(%rip), %rdi      # 0x9fd8
leaq 0x193e(%rip), %rsi      # 0x729a
callq 0x10e0
movq %rax, -0x110(%rbp)
jmp 0x596a
movq -0x110(%rbp), %rdi
movq 0x4650(%rip), %rsi      # 0x9fc8
callq 0x1120
jmp 0x597f
movl $0x0, -0xd0(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x1420
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x11b0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0xa, %edi
callq 0x10d0
callq 0x1150
movq %rax, -0x10(%rbp)
callq 0x5450
callq 0x57a0
callq 0x59b0
callq 0x5c20
callq 0x5ee0
callq 0x6250
movl $0x10, %edi
callq 0x66e0
movl $0x14, %edi
callq 0x66e0
movl $0x64, %edi
callq 0x66e0
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x66e0
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x66e0
callq 0x1150
movq %rax, -0x18(%rbp)
movq 0x3586(%rip), %rdi      # 0x9fd8
leaq 0x9ba(%rip), %rsi       # 0x7413
callq 0x10e0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x6af0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6ac0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6b40
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x11d0
movq %rax, %rdi
leaq 0x987(%rip), %rsi       # 0x7426
callq 0x10e0
movq %rax, %rdi
movq 0x351a(%rip), %rsi      # 0x9fc8
callq 0x1120
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)