LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/iPrimal.cpp
// Function: Primal::DisplayMatrix(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&) const
void
Primal::DisplayMatrix(const mat& _m, const vector<uint>& _as) const{

  if(_m[0].size() > DISPLAY_WIDTH){
    cout<<"Matrix is big, not displaying."<<endl;
    return;
  }

  for(uint i=0; i<_m.size(); i++){
    for(uint j=0; j<_m[0].size(); j++){
      if(_as[i] == j)
        cout<<" "<<_m[i][j]<<"*\t";
      else
        cout<<" "<<_m[i][j]<<"\t";
    }
    cout<<endl;
  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq (%rsi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x50, %rcx
jbe 0x6289
movq 0x8d88(%rip), %rbx      # 0xefc8
leaq 0x5154(%rip), %rsi      # 0xb39b
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x32a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3170
movq %rsi, %r14
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x6379
xorl %r13d, %r13d
movq 0x8d25(%rip), %r15      # 0xefc8
movq (%r14), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x632d
xorl %ebp, %ebp
leaq (,%r13,2), %r12
addq %r13, %r12
movq (%rsp), %rax
movq (%rax), %rax
movl (%rax,%r13,4), %ebx
movl $0x1, %edx
movq %r15, %rdi
leaq 0x5509(%rip), %rsi      # 0xb7df
callq 0x32a0
movq (%r14), %rax
movq (%rax,%r12,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r15, %rdi
callq 0x3370
cmpl %ebx, %ebp
jne 0x6304
movl $0x2, %edx
movq %rax, %rdi
leaq 0x50b8(%rip), %rsi      # 0xb3ba
jmp 0x6313
movl $0x1, %edx
movq %rax, %rdi
leaq 0x50a8(%rip), %rsi      # 0xb3bb
callq 0x32a0
incl %ebp
movq (%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
ja 0x62bc
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq 0x8(%r14), %rax
subq (%r14), %rax
incl %r13d
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %r13, %rax
ja 0x62a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/iPrimal.cpp
// Function: Primal::ComputeCostSum(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&) const
double
Primal::ComputeCostSum(const mat& _m, const vector<uint>& _as) const{

  double sum = 0;
  for(uint i=0; i<_m.size(); i++){
    for(uint j=0; j<_m[0].size(); j++)
      if(_as[i] == j)
	sum += _m[i][j];
  }
 
  return sum;

}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
subq %rax, %rsi
je 0x64e9
pushq %r14
pushq %rbx
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdi
movq %rdi, %r8
subq %rsi, %r8
sarq $0x3, %r8
movq (%rdx), %rdx
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
cmpq %rsi, %rdi
je 0x64da
movl (%rdx,%r9,4), %r10d
leaq (%r9,%r9,2), %r11
leaq (%rax,%r11,8), %r11
xorl %ebx, %ebx
cmpl %ebx, %r10d
jne 0x64cf
movq (%r11), %r14
addsd (%r14,%rbx,8), %xmm0
incq %rbx
movl %ebx, %r14d
cmpq %r14, %r8
ja 0x64c1
incq %r9
movl %r9d, %r10d
cmpq %r10, %rcx
ja 0x64ae
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/iPrimal.cpp
// Function: Primal::DisplayTree(_tree_node*)
void
Primal::DisplayTree(tree_node* _root){

  queue<tree_node*> bfs;
  bfs.push(_root);
  while(!bfs.empty()){
    tree_node* p_n = bfs.front();
    bfs.pop(); 
    if(p_n->asgn==-1)
      _cout("  -the root is ^: ("
		<<p_n->c.row_idx<<", "<<p_n->c.col_idx<<")"<<endl);
    else if (p_n->asgn == 0)
      _cout("  -found a new 0: ("
		<<p_n->c.row_idx<<", "<<p_n->c.col_idx<<")"<<endl);
    else
      _cout("  -found a new *: ("
		<<p_n->c.row_idx<<", "<<p_n->c.col_idx<<")"<<endl);

    tree_node* p_sibling;
    if(p_n->child != NULL){
      bfs.push(p_n->child); 
      p_sibling = p_n->child;
      while(p_sibling->next_sibling != NULL){
        p_sibling = p_sibling->next_sibling;
        bfs.push(p_sibling);
      }
    }
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x801a
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x6950
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x40(%rsp)
jmp 0x695f
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8190
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
je 0x6a4e
leaq 0x10(%rsp), %rbx
movq %rsp, %r14
movq (%rax), %r15
movq 0x30(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x698e
addq $0x8, %rax
jmp 0x69c0
movq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x3260
movq 0x38(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x6a3e
addq $0x10, %r15
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x69f0
movq %rax, (%rcx)
addq $0x8, 0x40(%rsp)
jmp 0x69fb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8190
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x6a3e
movq %rax, (%rsp)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x6a2d
movq %rax, (%rcx)
addq $0x8, 0x40(%rsp)
jmp 0x6a38
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8190
movq (%rsp), %rax
jmp 0x6a02
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
jne 0x6977
leaq 0x10(%rsp), %rdi
callq 0x73d2
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6a66
jmp 0x6a66
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x73d2
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/Utils.cpp
// Function: Utils::Stats(std::vector<double, std::allocator<double>> const&, double&, double&, double&)
void
Utils::Stats(const vector<double>& _data, 
                double& _sum, double& _avg, double& _var){

  _sum = 0;
  for(uint i=0; i<_data.size(); i++){
    _sum += _data[i];
  }

  _avg = _sum/_data.size();

  _var = 0;
  for(uint i=0; i<_data.size(); i++){
    _var += (_data[i]-_avg)*(_data[i]-_avg); 
  }
  _var = sqrt(_var/_data.size());
  
}

// Assembly:
pushq %rbx
movq %r8, %rbx
movq $0x0, (%rdx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdi
movq %rdi, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rax, %rdi
je 0x8933
movsd (%rdx), %xmm0
xorl %r8d, %r8d
addsd (%rax,%r8,8), %xmm0
movsd %xmm0, (%rdx)
incq %r8
movl %r8d, %r9d
cmpq %r9, %rsi
ja 0x891e
movq %rsi, %xmm0
punpckldq 0x2b40(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2b48(%rip), %xmm0     # 0xb490
movsd (%rdx), %xmm2
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, (%rcx)
movq $0x0, (%rbx)
cmpq %rax, %rdi
je 0x898d
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
subsd (%rcx), %xmm0
mulsd %xmm0, %xmm0
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
incq %rdx
movl %edx, %edi
cmpq %rdi, %rsi
ja 0x896e
movsd (%rbx), %xmm0
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x89a5
sqrtsd %xmm0, %xmm0
jmp 0x89aa
callq 0x31d0
movsd %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/Utils.cpp
// Function: Utils::WriteMatrix(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&, char*)
void
Utils::WriteMatrix(const mat& _m, char* _fname){

  ofstream fout(_fname);
  if(!fout)
    cerr << "Cannot create output file"<<endl;
  
  for(uint i=0; i<_m.size(); i++){
    for(uint j=0; j<_m[0].size(); j++)
      fout<<_m[i][j]<<"\t";
    fout<<endl;
  }
  
  fout.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movl $0x10, %edx
callq 0x3280
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x8a2d
movq 0x6602(%rip), %r15      # 0xeff0
leaq 0x2aab(%rip), %rsi      # 0xb4a0
movl $0x19, %edx
movq %r15, %rdi
callq 0x32a0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq 0x65d0(%rip), %rdi      # 0xeff0
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x8ae1
xorl %r12d, %r12d
leaq 0x2977(%rip), %r15      # 0xb3bb
movq (%rbx), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x8a93
movl $0x1, %ebp
leaq (%r12,%r12,2), %r13
xorl %ecx, %ecx
movq (%rax,%r13,8), %rax
movsd (%rax,%rcx,8), %xmm0
movq %r14, %rdi
callq 0x3370
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32a0
movq (%rbx), %rax
movq 0x8(%rax), %rdx
subq (%rax), %rdx
movl %ebp, %ecx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x8a5b
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq 0x8(%rbx), %rax
subq (%rbx), %rax
incl %r12d
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %r12, %rax
ja 0x8a44
leaq 0x8(%rsp), %rdi
callq 0x32e0
movq 0x64ce(%rip), %rax      # 0xefc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x31f0
leaq 0x100(%rsp), %rdi
callq 0x30d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b33
jmp 0x8b33
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3310
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/Utils.cpp
// Function: Utils::WriteMatrix(Assignment&, char*)
void
Utils::WriteMatrix(Assignment& _as, char* _fname){

  ofstream fout(_fname);
  if(!fout)
    cerr << "Cannot create output file"<<endl;
  
  fout<<"# seed: "<<_as.GetSeed()<<endl;
  for(uint i=0; i<_as.GetRowSize(); i++){
    for(uint j=0; j<_as.GetColSize(); j++)
      fout<<_as.GetMatrix()[i][j]<<"\t";
    fout<<endl;
  }
  
  fout.close();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
movl $0x10, %edx
callq 0x3280
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x8bc5
movq 0x646a(%rip), %r14      # 0xeff0
leaq 0x2913(%rip), %rsi      # 0xb4a0
movl $0x19, %edx
movq %r14, %rdi
callq 0x32a0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq 0x6438(%rip), %rdi      # 0xeff0
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x28ee(%rip), %rsi      # 0xb4ba
leaq 0x8(%rsp), %rdi
movl $0x8, %edx
callq 0x32a0
movl (%rbx), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3160
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
cmpl $0x0, 0x4(%rbx)
je 0x8c94
xorl %r12d, %r12d
leaq 0x2797(%rip), %r15      # 0xb3bb
cmpl $0x0, 0x8(%rbx)
je 0x8c60
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r14, %rdi
callq 0x3370
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x32a0
incq %rbp
movl 0x8(%rbx), %eax
cmpq %rax, %rbp
jb 0x8c30
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
incq %r12
movl 0x4(%rbx), %eax
cmpq %rax, %r12
jb 0x8c24
leaq 0x8(%rsp), %rdi
callq 0x32e0
movq 0x631b(%rip), %rax      # 0xefc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x31f0
leaq 0x100(%rsp), %rdi
callq 0x30d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8ce6
jmp 0x8ce6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3310
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/./CmdParser.h
// Function: CmdParser::ParseCmd(int, char**)
void
CmdParser::ParseCmd(int argc, char **argv){

  int c;
  while ((c = getopt (argc, argv, "i:s:n:o:v:h")) != -1)
    switch (c)
    {
           case 'i':
             this->input_file = optarg;
             break;
           case 's':
             this->seed = atoi(optarg);
             break;
           case 'n':
             this->assignment_size = atoi(optarg);
             break;
           case 'o':
             this->output_file = optarg;
             break;
           case 'v':
             this->verbose_level = atoi(optarg);
	     if(this->verbose_level < VERBOSE_LEVEL){ 
		cout<<"Please undefine the DEBUG macro in \"Define.h\" and re-compile."<<endl<<endl;
                exit(0);
	     }
	     break;
	   case 'h':
	     this->GiveUsage(argv[0]);
	     break;
           case '?':
           default:
	     this->GiveUsage(argv[0]);
             exit(0);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x2481(%rip), %r15      # 0xb550
leaq 0x243e(%rip), %r13      # 0xb514
movq 0x5ed3(%rip), %r12      # 0xefb0
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3070
leal -0x68(%rax), %ecx
cmpl $0xe, %ecx
ja 0x9185
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movq (%r12), %r15
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x3100
movq 0x8(%rsp), %rdi
jmp 0x913d
movq (%r12), %rdi
callq 0x3340
cltq
movq %rax, 0x28(%r14)
jmp 0x90dd
movq (%r12), %r15
movq 0x38(%r14), %r12
movq %r15, %rdi
callq 0x3100
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
movq 0x5e67(%rip), %r12      # 0xefb0
movq %r15, %rcx
leaq 0x23fd(%rip), %r15      # 0xb550
movq %rax, %r8
callq 0x3330
jmp 0x90dd
movq (%r12), %rdi
callq 0x3340
movl %eax, 0x50(%r14)
testl %eax, %eax
jne 0x90dd
jmp 0x91a1
movq (%r12), %rdi
callq 0x3340
movl %eax, (%r14)
jmp 0x90dd
cmpl $-0x1, %eax
jne 0x9199
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rsi
callq 0x91cc
movq 0x5e20(%rip), %rdi      # 0xefc8
leaq 0x23ad(%rip), %rsi      # 0xb55c
callq 0x3240
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3110
xorl %edi, %edi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iu-vail[P]iprimal/./CmdParser.h
// Function: CmdParser::GiveUsage(char*)
void
CmdParser::GiveUsage(char *cmd)
{
   fprintf(stderr,"\nUsage:    %s \n",cmd);
   fprintf(stderr,"          -i   input an assignment file (string)\n");
   fprintf(stderr,"          -s   random generator with seed (unsigned int)\n");
   fprintf(stderr,"          -n   matrix size (size_t)\n");
   fprintf(stderr,"          -o   write into output file (string)\n");
   fprintf(stderr,"          -v   verbose level (0 or 1)\n");
   fprintf(stderr,"More details can be found in README file\n\n");
   exit(0);
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq 0x5df9(%rip), %rbx      # 0xefd0
movq (%rbx), %rdi
leaq 0x23c1(%rip), %rsi      # 0xb5a2
xorl %eax, %eax
callq 0x32f0
movq (%rbx), %rcx
leaq 0x23c0(%rip), %rdi      # 0xb5b2
movl $0x31, %esi
movl $0x1, %edx
callq 0x3420
movq (%rbx), %rcx
leaq 0x23d9(%rip), %rdi      # 0xb5e4
movl $0x39, %esi
movl $0x1, %edx
callq 0x3420
movq (%rbx), %rcx
leaq 0x23fa(%rip), %rdi      # 0xb61e
movl $0x24, %esi
movl $0x1, %edx
callq 0x3420
movq (%rbx), %rcx
leaq 0x2406(%rip), %rdi      # 0xb643
movl $0x2f, %esi
movl $0x1, %edx
callq 0x3420
movq (%rbx), %rcx
leaq 0x241d(%rip), %rdi      # 0xb673
movl $0x26, %esi
movl $0x1, %edx
callq 0x3420
movq (%rbx), %rcx
leaq 0x242b(%rip), %rdi      # 0xb69a
movl $0x2a, %esi
movl $0x1, %edx
callq 0x3420
xorl %edi, %edi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Card.cpp
// Function: Card::Card()
Card::Card() {
	content = "";
	type = ' ';
	numOfAnswers = 0;
	owner = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x4bb2(%rip), %rcx      # 0x7249
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2230
movb $0x20, 0x20(%r14)
movl $0x0, 0x24(%r14)
movq 0x30(%r14), %rdx
leaq 0x4b8e(%rip), %rcx      # 0x7249
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2230
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x26ee
movq (%r13), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22c0
movq %r12, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Card::Card(std::string c, char t, int n, std::string p) {
	content = c;
	type = t;
	numOfAnswers = n;
	owner = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movl %ecx, %r13d
movl %edx, %ebx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x38(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
callq 0x20e0
movb %bl, 0x20(%r14)
movl %r13d, 0x24(%r14)
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r12), %rdi
cmpq -0x30(%rbp), %rdi
je 0x278c
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x22da
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, int)
Card::Card(std::string c, char t, int n) {
	content = c;
	type = t;
	numOfAnswers = n;
	owner = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %rbx
movq %rbx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
callq 0x20e0
movb %r13b, 0x20(%r14)
movl %r12d, 0x24(%r14)
movq 0x30(%r14), %rdx
leaq 0x4a53(%rip), %rcx      # 0x7249
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2230
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x2828
movq (%rbx), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x22f4
movq %r12, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Card::Card(std::string c, std::string p) {
	content = c;
	type = 'w';
	numOfAnswers = 0;
	owner = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
callq 0x20e0
movb $0x77, 0x20(%r14)
movl $0x0, 0x24(%r14)
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x28b7
movq (%r13), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
movq %rbx, %rsi
callq 0x230e
movq %r15, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Player.cpp
// Function: Player::takeCard(int)
Card Player::takeCard(int index) {
	if (index > hand.size() || index < 0) {
		return Card();
	}
	Card temp = hand[index];
	hand = deleteCard(hand, index);
	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
testl %edx, %edx
js 0x2c06
movl %edx, %r15d
movq %rsi, %r14
movslq %edx, %rax
movq 0x28(%rsi), %r13
movq 0x30(%rsi), %rcx
subq %r13, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %rax, %rdx
jb 0x2c06
leaq (%rax,%rax,8), %r12
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
movq (%r13,%r12,8), %rsi
movq 0x8(%r13,%r12,8), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x313c
movq 0x20(%r13,%r12,8), %rax
movq %rax, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq 0x28(%r13,%r12,8), %rsi
movq 0x30(%r13,%r12,8), %rdx
addq %rsi, %rdx
callq 0x313c
leaq 0x28(%r14), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2fec
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl %r15d, %edx
callq 0x2c5e
xorps %xmm0, %xmm0
leaq -0x80(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x28(%r14), %rax
movups 0x30(%r14), %xmm0
leaq -0x60(%rbp), %r15
movq (%r15), %rcx
movq %rcx, 0x28(%r14)
movq 0x8(%r15), %rcx
movq %rcx, 0x30(%r14)
movq 0x10(%r15), %rcx
movq %rcx, 0x38(%r14)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r15)
movq %rdx, 0x8(%r15)
movq %rsi, 0x10(%r15)
callq 0x2f76
movq %r15, %rdi
callq 0x2f76
leaq -0x48(%rbp), %rdi
callq 0x2f76
jmp 0x2c0e
movq %rbx, %rdi
callq 0x265c
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2f76
jmp 0x2c31
movq %rax, %r14
movq %rbx, %rdi
callq 0x3090
jmp 0x2c56
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x2c56
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Player.cpp
// Function: deleteCard(std::vector<Card, std::allocator<Card>>, int)
std::vector<Card> deleteCard(std::vector<Card> cards, int index) {
	std::vector<Card> temp;
	for (int i = 0; i < (int)cards.size(); i++) {
		if (i != index) {
			temp.push_back(cards[i]);
		}
	}
	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
testl %eax, %eax
jle 0x2cd3
movl %edx, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x2cb1
addq %r12, %rsi
movq %rbx, %rdi
callq 0x2fb4
incq %r13
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0x38e38e39, %eax, %eax # imm = 0x38E38E39
cltq
addq $0x48, %r12
cmpq %rax, %r13
jl 0x2ca1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f76
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Player.cpp
// Function: Player::takeCard(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Card Player::takeCard(std::string content) {
	for (int i = 0; i < hand.size(); i++) {
		if (hand[i].content.compare(content) == 0) {
			return hand[i];
		}
	}
	return Card();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movq 0x28(%rsi), %rdi
cmpq %rdi, 0x30(%rsi)
setne %r12b
je 0x2dd8
movq %rdx, %r15
movq %rsi, %r14
movq %rdx, %rsi
callq 0x2030
testl %eax, %eax
je 0x2d74
movl $0x48, %ebx
xorl %r13d, %r13d
incq %r13
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rax
cmpq %r13, %rax
seta %r12b
jbe 0x2dd8
addq %rbx, %rdi
movq %r15, %rsi
callq 0x2030
addq $0x48, %rbx
testl %eax, %eax
jne 0x2d36
jmp 0x2d77
xorl %r13d, %r13d
movq 0x28(%r14), %r14
leaq (,%r13,8), %r15
addq %r13, %r15
movq -0x30(%rbp), %r13
leaq 0x10(%r13), %rbx
movq %rbx, (%r13)
movq (%r14,%r15,8), %rsi
movq 0x8(%r14,%r15,8), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x313c
movq 0x20(%r14,%r15,8), %rax
movq %rax, 0x20(%r13)
leaq 0x28(%r13), %rdi
leaq 0x38(%r13), %rax
movq %rax, 0x28(%r13)
movq 0x28(%r14,%r15,8), %rsi
movq 0x30(%r14,%r15,8), %rdx
addq %rsi, %rdx
callq 0x313c
testb %r12b, %r12b
je 0x2dd8
movq -0x30(%rbp), %rax
jmp 0x2de7
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x265c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq %rbx, %rdi
je 0x2e10
movq (%rbx), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Player.cpp
// Function: Player::isEqual(Player)
bool Player::isEqual(Player p) {
	if(strcmp(name.c_str(), p.getName().c_str()) == 0) {
		return true;
	}
	else {
		return false;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r14
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x313c
movq (%rbx), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f0
movl %eax, %r14d
cmpq %r15, %rbx
je 0x2e6e
movq -0x28(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x2180
testl %r14d, %r14d
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Player.cpp
// Function: Player::isEqual(Player, Player)
bool Player::isEqual(Player p, Player q) {
	if(strcmp(p.getName().c_str(), q.getName().c_str()) == 0) {
		return true;
	}
	else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x313c
movq (%rbx), %rbx
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x313c
movq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movl %eax, %ebx
cmpq %r12, %r14
je 0x2ef7
movq -0x50(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2180
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f0c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2180
testl %ebx, %ebx
sete %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f36
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Client.cpp
// Function: printAnswers(std::vector<Card, std::allocator<Card>>, int)
void printAnswers(vector<Card> answers, int numOfAnswers) {
	int count = 1;
	for (int i = 0; i < answers.size()/numOfAnswers; i++) {
		for (int j = 0; j < numOfAnswers; j++) {
			printf("%d %s\n", count, answers[i].content.c_str());
		}
		count++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, -0x2c(%rbp)
movslq %esi, %rcx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rdx, %rax
movq %rcx, -0x38(%rbp)
cmpq %rcx, %rax
jb 0x5167
movq %rdi, %r14
movl $0x1, %r15d
leaq 0x210b(%rip), %r12      # 0x7219
xorl %r13d, %r13d
movl -0x2c(%rbp), %eax
movl %eax, %ebx
testl %eax, %eax
jle 0x513d
movq (%r14), %rax
leaq (,%r13,8), %rcx
addq %r13, %rcx
movq (%rax,%rcx,8), %rdx
movq %r12, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x2040
decl %ebx
jne 0x511a
incl %r15d
movq 0x8(%r14), %rax
subq (%r14), %rax
incq %r13
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rax
xorl %edx, %edx
divq -0x38(%rbp)
cmpq %r13, %rax
ja 0x5111
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Client.cpp
// Function: splitString(char**, char*, char const*)
void splitString(char* parts[], char* target, const char* delim) {
	char* tok;
	tok = std::strtok(target, delim);
	int i = 0;
	while(tok != NULL) {
		parts[i] = tok;
		tok = strtok(NULL, delim);
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2250
testq %rax, %rax
je 0x657d
movq %rax, (%r14)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2250
addq $0x8, %r14
jmp 0x6565
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Client.cpp
// Function: countChars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
int countChars(string l, char s) {
	int elements = 0;
	for (int i = 0; i < l.length(); i++) {
		if (l[i] == s) {
			elements++;
		}
	}
	if (s == '_' && elements == 0) {
		return 1;
	}
	return elements;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x65af
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
xorl %edi, %edi
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpb %sil, (%rdx,%rdi)
sete %r8b
addl %r8d, %ecx
incq %rdi
cmpq %rdi, %rax
jne 0x6596
popq %rbp
jmp 0x65b1
xorl %ecx, %ecx
testl %ecx, %ecx
movl $0x1, %eax
cmovnel %ecx, %eax
cmpb $0x5f, %sil
cmovnel %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Client.cpp
// Function: setJudge(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void setJudge(bool j, string name) {
	if (j) {
		isJudge = true;
		judge = self;
		answers.clear();
		printf("You are the new judge!\n");
	}
	else {
		isJudge = false;
		judge.setName(name);
		answers.clear();
		printf("The new judge is %s.\n", name.c_str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %edi, %edi
je 0x6835
movb $0x1, 0x39cf(%rip)      # 0xa194
leaq 0x3c2c(%rip), %rdi      # 0xa3f8
leaq 0x3bcd(%rip), %rsi      # 0xa3a0
callq 0x20e0
movq 0x3be1(%rip), %rax      # 0xa3c0
movq %rax, 0x3c32(%rip)      # 0xa418
leaq 0x3c33(%rip), %rdi      # 0xa420
leaq 0x3bd4(%rip), %rsi      # 0xa3c8
callq 0x694e
leaq 0x3c38(%rip), %rdi      # 0xa438
leaq 0x3bd9(%rip), %rsi      # 0xa3e0
callq 0x694e
movq 0x3c5d(%rip), %rsi      # 0xa470
leaq 0x3c56(%rip), %rdi      # 0xa470
callq 0x6e82
leaq 0xfe7(%rip), %rdi       # 0x780d
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2220
movq %rsi, %rbx
movb $0x0, 0x3955(%rip)      # 0xa194
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x313c
leaq 0x3b94(%rip), %rdi      # 0xa3f8
movq %r14, %rsi
callq 0x2a9a
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x6881
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2180
movq 0x3be8(%rip), %rsi      # 0xa470
leaq 0x3be1(%rip), %rdi      # 0xa470
callq 0x6e82
movq (%rbx), %rsi
leaq 0x7f0(%rip), %rdi       # 0x708e
xorl %eax, %eax
callq 0x2040
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x68c8
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/block.cc
// Function: Block::Resize(unsigned int, bool)
ERROR_T Block::Resize(const SIZE_T newlen, const bool copy)
{
  BYTE_T *d;
  
  try {
    d = new BYTE_T [newlen];
  }
  catch (...) {
    return ERROR_NOMEM;
  }

  if (copy) { 
    memcpy(d,data,MIN(newlen,length));
  }
  
  if (data) { delete [] data; }
  data = d;

  length=newlen;

  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x2030
movq %rax, %r15
testb %bpl, %bpl
je 0x2ce8
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
cmpl %ebx, %edx
cmovael %ebx, %edx
movq %r15, %rdi
callq 0x2170
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2cf6
callq 0x2280
movq %r15, 0x8(%r14)
movl %ebx, 0x10(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x2090
callq 0x2330
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x2d00
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/block.cc
// Function: Block::~Block()
Block::~Block() 
{ 
  if (data) { delete [] data; data=0; }
  length=0;
  lastaccessed=-1;
  dirty=false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xaebb(%rip), %rax      # 0xdce8
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2e46
callq 0x2280
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/block.cc
// Function: Block::Print(std::ostream&) const
ostream & Block::Print(ostream &os) const
{
  os << "Block(length="<<length<<", data=0x";
  for (SIZE_T i=0;i<length;i++) { 
    os << high2hex(data[i]) << low2hex(data[i]);
  }
  os << ", lastaccessed="<<lastaccessed<<", dirty="<<dirty<<")";
  return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x62bb(%rip), %rsi      # 0x91db
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2230
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x2120
leaq 0x62a9(%rip), %rsi      # 0x91e9
movl $0x9, %edx
movq %rax, %rdi
callq 0x2230
cmpl $0x0, 0x10(%r14)
je 0x2fd1
xorl %r13d, %r13d
leaq 0xe(%rsp), %r15
leaq 0xf(%rsp), %r12
movq 0x8(%r14), %rax
movb (%rax,%r13), %al
movl %eax, %ecx
shrb $0x4, %cl
leal 0x30(%rcx), %edx
addb $0x57, %cl
cmpb $-0x60, %al
movzbl %dl, %eax
movzbl %cl, %ecx
cmovbl %eax, %ecx
movb %cl, 0xe(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2230
movq 0x8(%r14), %rcx
movb (%rcx,%r13), %cl
andb $0xf, %cl
leal 0x30(%rcx), %edx
leal 0x57(%rcx), %esi
cmpb $0xa, %cl
movzbl %dl, %ecx
movzbl %sil, %edx
cmovbl %ecx, %edx
movb %dl, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
incq %r13
movl 0x10(%r14), %eax
cmpq %rax, %r13
jb 0x2f61
leaq 0x621b(%rip), %rsi      # 0x91f3
movl $0xf, %edx
movq %rbx, %rdi
callq 0x2230
movsd 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x2310
movq %rax, %r15
leaq 0x6206(%rip), %rsi      # 0x9203
movl $0x8, %edx
movq %rax, %rdi
callq 0x2230
movzbl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x2340
leaq 0x672f(%rip), %rsi      # 0x974d
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/disksystem.cc
// Function: DiskSystem::DiskSystem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, double, double, double)
DiskSystem::DiskSystem(const string &filestem,
		       const bool   create,
		       const SIZE_T offset,
		       const SIZE_T blcks,
		       const SIZE_T blcksize,
		       const SIZE_T heads,
		       const SIZE_T blckspertrack,
		       const SIZE_T tracks,
		       const double avgseek,
		       const double trackseek,
		       const double rotlat) :
  bitmap(0),
  datafilefd(0),
  configfilefd(0),
  bitmapfilefd(0),
  diskfilestem(filestem), 
  offset(offset),
  numblocks(blcks),
  blocksize(blcksize),
  numheads(heads),
  blockspertrack(blckspertrack),
  numtracks(tracks),
  last_track(0),
  last_sector(0),
  averageseeklatency(avgseek),
  trackseeklatency(trackseek),
  rotationallatency(rotlat)
{
  if (create) { 
    // Only in this case are the parameters used:
    InitFromInMemoryConfig();
  } else {
    InitFromConfigFile();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movl %edx, %ebp
movq %rdi, %r14
leaq 0xacb7(%rip), %rax      # 0xdd28
movq %rax, (%rdi)
leaq 0x28(%rdi), %rbx
leaq 0x38(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq %rax, 0x8(%rsp)
movq %rax, 0x28(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4670
movl %r13d, 0x48(%r14)
movl %r12d, 0x4c(%r14)
movl %r15d, 0x50(%r14)
movl 0x60(%rsp), %eax
movl %eax, 0x54(%r14)
movl 0x68(%rsp), %eax
movl %eax, 0x58(%r14)
movl 0x70(%rsp), %eax
movl %eax, 0x5c(%r14)
movq $0x0, 0x60(%r14)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x68(%r14)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x70(%r14)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x78(%r14)
testl %ebp, %ebp
je 0x3103
movq %r14, %rdi
callq 0x3140
jmp 0x310b
movq %r14, %rdi
callq 0x33ec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x3137
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21e0
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/disksystem.cc
// Function: DiskSystem::InitFromConfigFile()
ERROR_T DiskSystem::InitFromConfigFile()
{
  string configname = diskfilestem + ".config";
  string dataname = diskfilestem + ".data";
  string bitmapname = diskfilestem + ".bitmap";
  
  if (configfilefd) { fclose(configfilefd); }
  
  if ((configfilefd = fopen(configname.c_str(),"r+"))==0) { 
    return ERROR_NOFILE;
  }

  int rc = ReadConfig();
  
  if (rc) { 
    return rc;
  }

  rc=SanityCheckConfig();

  if (rc) { 
    return rc;
  }

  if (datafilefd) { fclose(datafilefd);}

  if ((datafilefd = fopen(dataname.c_str(),"r+"))==0) { 
    return ERROR_NOFILE;
  }


  if (bitmapfilefd) { fclose(bitmapfilefd);}

  if ((bitmapfilefd = fopen(bitmapname.c_str(),"r+"))==0) { 
    return ERROR_NOFILE;
  }
  
  rc = ReadBitMap();

  if (rc) { 
    return rc;
  }

  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x4670
leaq 0x5f3e(%rip), %rsi      # 0x9361
movq %r14, %rdi
callq 0x2390
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x4670
leaq 0x5f19(%rip), %rsi      # 0x9369
leaq 0x20(%rsp), %rdi
callq 0x2390
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x4670
leaq 0x5ef1(%rip), %rsi      # 0x936f
movq %rsp, %rdi
callq 0x2390
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3494
callq 0x21c0
movq 0x40(%rsp), %rdi
leaq 0x5ed7(%rip), %rsi      # 0x9377
callq 0x2260
movq %rax, 0x18(%rbx)
movl $0xfffffff3, %ebp       # imm = 0xFFFFFFF3
testq %rax, %rax
je 0x34c9
movq %rbx, %rdi
callq 0x3930
movq %rbx, %rdi
callq 0x38d0
testl %eax, %eax
je 0x351c
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x34df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x34f6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x350d
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21e0
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x352a
callq 0x21c0
movq 0x20(%rsp), %rdi
leaq 0x5e41(%rip), %rsi      # 0x9377
callq 0x2260
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x34c9
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3552
callq 0x21c0
movq (%rsp), %rdi
leaq 0x5e1a(%rip), %rsi      # 0x9377
callq 0x2260
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x34c9
movq %rbx, %rdi
callq 0x3bc6
jmp 0x34c7
jmp 0x358c
jmp 0x3580
movq %rax, %rbx
jmp 0x35a5
jmp 0x3587
movq %rax, %rbx
jmp 0x35bc
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x35a5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x35bc
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x35d3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/disksystem.cc
// Function: DiskSystem::~DiskSystem()
DiskSystem::~DiskSystem()
{
  WriteConfig();
  WriteBitMap();
  fclose(configfilefd);
  fclose(bitmapfilefd);
  fclose(datafilefd);
  delete [] bitmap;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa741(%rip), %rax      # 0xdd28
movq %rax, (%rdi)
callq 0x3644
movq %rbx, %rdi
callq 0x385a
movq 0x18(%rbx), %rdi
callq 0x21c0
movq 0x20(%rbx), %rdi
callq 0x21c0
movq 0x10(%rbx), %rdi
callq 0x21c0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3620
callq 0x2280
movq 0x28(%rbx), %rdi
addq $0x38, %rbx
cmpq %rbx, %rdi
je 0x3639
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x21e0
popq %rbx
retq
movq %rax, %rdi
callq 0x45f7
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/disksystem.cc
// Function: DiskSystem::WriteBitMap()
ERROR_T DiskSystem::WriteBitMap()
{
  rewind(bitmapfilefd);
  
  SIZE_T numbitmapbytes = numblocks / 8 + (numblocks%8 != 0); 

  if (mywrite(bitmapfilefd,0,bitmap,numbitmapbytes)!=numbitmapbytes) { 
    cerr << "Can't write bitmap file\n";
    return ERROR_IMPLBUG;
  }
  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2050
movl 0x4c(%rbx), %eax
movl %eax, %ebp
shrl $0x3, %ebp
andl $0x7, %eax
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movq 0x8(%rbx), %rdx
movq 0x20(%rbx), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
movl %ebp, %ecx
callq 0x3b78
cmpl %ebp, %eax
je 0x38ae
movq 0xa758(%rip), %rdi      # 0xdff0
leaq 0x5a91(%rip), %rsi      # 0x9330
movl $0x18, %edx
callq 0x2230
movl $0xfffffff5, %ebx       # imm = 0xFFFFFFF5
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/disksystem.cc
// Function: mywrite(_IO_FILE*, unsigned int, unsigned char const*, int)
static SIZE_T mywrite(FILE *f, const SIZE_T off, const BYTE_T *buf, const int len)
{
  SIZE_T left=len;
  SIZE_T sent;

  fseek(f,off,SEEK_SET);
  while (left>0) {
    sent=fwrite(&(buf[len-left]),1,left,f);
    if (sent<0) {	
      return 0;
    } else if (sent==0) {
      break;
    } else {
      left-=sent;
    }
  }
  return len-left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %esi
xorl %edx, %edx
callq 0x2220
movl %ebx, %ebp
testl %ebx, %ebx
je 0x3bb6
movl %ebx, %ebp
movl %ebx, %edi
subl %ebp, %edi
addq %r14, %rdi
movl %ebp, %edx
movl $0x1, %esi
movq %r15, %rcx
callq 0x23a0
testl %eax, %eax
je 0x3bb6
subl %eax, %ebp
jne 0x3b98
subl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/disksystem.cc
// Function: DiskSystem::ReadBitMap()
ERROR_T DiskSystem::ReadBitMap()
{
  rewind(bitmapfilefd);
  
  SIZE_T numbitmapbytes = numblocks / 8 + (numblocks%8 != 0); 

  if (bitmap) { delete [] bitmap; } ;

  bitmap = new BYTE_T [numbitmapbytes];

  if (myread(bitmapfilefd,0,bitmap,numbitmapbytes,false)!=numbitmapbytes) { 
    cerr << "Can't read bitmap file\n";
    return ERROR_IMPLBUG;
  }
  return ERROR_NOERROR;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x2050
movl 0x4c(%r14), %eax
movl %eax, %ebx
shrl $0x3, %ebx
andl $0x7, %eax
cmpl $0x1, %eax
sbbl $-0x1, %ebx
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3bf6
callq 0x2280
movl %ebx, %edi
callq 0x2030
movq %rax, 0x8(%r14)
movq 0x20(%r14), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
movq %rax, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x3c3e
cmpl %ebx, %eax
je 0x3c37
movq 0xa3cf(%rip), %rdi      # 0xdff0
leaq 0x5721(%rip), %rsi      # 0x9349
movl $0x17, %edx
callq 0x2230
movl $0xfffffff5, %ebp       # imm = 0xFFFFFFF5
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpottamus[P]btree_lab/disksystem.cc
// Function: myread(_IO_FILE*, unsigned int, unsigned char*, int, bool)
static SIZE_T myread(FILE *f, const SIZE_T off, BYTE_T *buf, const int len, bool trunconeof=true)
{
  SIZE_T left=len;
  SIZE_T sent;

  fseek(f,off,SEEK_SET);
  while (left>0) {
    sent=fread(&(buf[len-left]),1,left,f);
    if (sent<0) {	
      return 0;
    } else if (sent==0) {
      // if we reached this point, the likely cause is that we
      // are trying to read a block which has not been allocated yet
      // Hence, we will try to ftruncate to this size and then retry the
      // read.  However, we don't want to loop forever doing this,
      // hence the trunconeof parameter
      if (!feof(f)) { 
	// OK, the end of file is not the problem
	break;
      } else {
	// EOF case... should we truncate and try again?
	if (!trunconeof) { 
	  break;
	} else {
	  // yes!
	  if (ftruncate(fileno(f),off+len)) { 
	    // uh oh, something weird is going on
	    break;
	  } else {
	    // OK, now retry, but don't truncate a second time
	    return myread(f,off,buf,len,false);
	  }
	}
      }
    } else {
      left-=sent;
    }
  }
  return len-left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movl %esi, %eax
movq %rax, (%rsp)
addl %ecx, %r15d
movq %r12, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x2220
movl %r13d, %ebx
testl %r13d, %r13d
je 0x3cc9
movl %r13d, %edi
subl %ebx, %edi
addq %r14, %rdi
movl %ebx, %edx
movl $0x1, %esi
movq %r12, %rcx
callq 0x22c0
testl %eax, %eax
je 0x3c98
subl %eax, %ebx
jne 0x3c77
jmp 0x3cc9
movq %r12, %rdi
callq 0x22e0
testl %eax, %eax
sete %al
notb %bpl
orb %al, %bpl
testb $0x1, %bpl
jne 0x3cc9
movq %r12, %rdi
callq 0x2210
movl %eax, %edi
movq %r15, %rsi
callq 0x2290
xorl %ebp, %ebp
testl %eax, %eax
je 0x3c61
subl %ebx, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq