LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iu-vail[P]iprimal/./iPrimal.h
// Function: less_comp<_cell>::operator()(std::pair<_cell, double> const&, std::pair<_cell, double> const&) const
bool operator() (const pair<T, double>& a,
                const pair<T, double>& b) const {
  if(!_switch) // output in increasing order
    return a.second > b.second ? true : false ;
  else       // output in decreasing order
    return a.second < b.second ? true : false ;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
jne 0x10afb
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm1
ucomisd %xmm1, %xmm0
seta %al
negb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10b1b
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
negb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4470
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x15943
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xaff0
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x158fe
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4470
movsd -0x40(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x4ae6(%rip), %xmm2     # 0x1a450
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x4aea(%rip), %xmm2     # 0x1a460
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4470
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x15a1c
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0xaff0
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0xaff0
movsd -0x50(%rbp), %xmm0
movsd (%rax), %xmm2
movq -0x20(%rbp), %rax
subsd (%rax), %xmm2
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x159a3
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4470
movsd -0x58(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x4a0d(%rip), %xmm2     # 0x1a450
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x4a11(%rip), %xmm2     # 0x1a460
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x3200
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x32e0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3130
movb %al, -0x22d(%rbp)
jmp 0x15acc
movb -0x22d(%rbp), %al
testb $0x1, %al
jne 0x15ad8
jmp 0x15b2e
movq 0x11511(%rip), %rdi     # 0x26ff0
leaq 0x498a(%rip), %rsi      # 0x1a470
callq 0x3270
movq %rax, -0x238(%rbp)
jmp 0x15af4
movq -0x238(%rbp), %rdi
movq 0x114ae(%rip), %rsi     # 0x26fb0
callq 0x32b0
jmp 0x15b09
jmp 0x15b2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x33d0
jmp 0x15c4f
movl $0x0, -0x228(%rbp)
movl -0x228(%rbp), %eax
movq %rax, -0x240(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x240(%rbp), %rax
cmpq %rcx, %rax
jae 0x15c2c
movl $0x0, -0x22c(%rbp)
movl -0x22c(%rbp), %eax
movq %rax, -0x248(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xafd0
movq %rax, %rdi
callq 0x4470
movq %rax, %rcx
movq -0x248(%rbp), %rax
cmpq %rcx, %rax
jae 0x15c01
movq -0x10(%rbp), %rdi
movl -0x228(%rbp), %eax
movl %eax, %esi
callq 0xafd0
movq %rax, %rdi
movl -0x22c(%rbp), %eax
movl %eax, %esi
callq 0xaff0
movsd (%rax), %xmm0
leaq -0x218(%rbp), %rdi
callq 0x34e0
movq %rax, -0x250(%rbp)
jmp 0x15bd6
movq -0x250(%rbp), %rdi
leaq 0x47a7(%rip), %rsi      # 0x1a38b
callq 0x3270
jmp 0x15beb
jmp 0x15bed
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x15b6b
movq 0x113a8(%rip), %rsi     # 0x26fb0
leaq -0x218(%rbp), %rdi
callq 0x32b0
jmp 0x15c16
jmp 0x15c18
movl -0x228(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x228(%rbp)
jmp 0x15b38
leaq -0x218(%rbp), %rdi
callq 0x33a0
jmp 0x15c3a
leaq -0x218(%rbp), %rdi
callq 0x33d0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x32e0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3130
movb %al, -0x22d(%rbp)
jmp 0x15cac
movb -0x22d(%rbp), %al
testb $0x1, %al
jne 0x15cb8
jmp 0x15d0e
movq 0x11331(%rip), %rdi     # 0x26ff0
leaq 0x47aa(%rip), %rsi      # 0x1a470
callq 0x3270
movq %rax, -0x238(%rbp)
jmp 0x15cd4
movq -0x238(%rbp), %rdi
movq 0x112ce(%rip), %rsi     # 0x26fb0
callq 0x32b0
jmp 0x15ce9
jmp 0x15d0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x33d0
jmp 0x15ea5
leaq 0x4775(%rip), %rsi      # 0x1a48a
leaq -0x218(%rbp), %rdi
callq 0x3270
movq %rax, -0x240(%rbp)
jmp 0x15d2a
movq -0x10(%rbp), %rdi
callq 0x161a0
movl %eax, -0x244(%rbp)
jmp 0x15d3b
movl -0x244(%rbp), %esi
movq -0x240(%rbp), %rdi
callq 0x3370
movq %rax, -0x250(%rbp)
jmp 0x15d56
movq -0x250(%rbp), %rdi
movq 0x1124c(%rip), %rsi     # 0x26fb0
callq 0x32b0
jmp 0x15d6b
movl $0x0, -0x228(%rbp)
movl -0x228(%rbp), %eax
movl %eax, -0x258(%rbp)
movq -0x10(%rbp), %rdi
callq 0x161b0
movl %eax, -0x254(%rbp)
jmp 0x15d92
movl -0x258(%rbp), %eax
movl -0x254(%rbp), %ecx
cmpl %ecx, %eax
jae 0x15e82
movl $0x0, -0x22c(%rbp)
movl -0x22c(%rbp), %eax
movl %eax, -0x260(%rbp)
movq -0x10(%rbp), %rdi
callq 0x161d0
movl %eax, -0x25c(%rbp)
jmp 0x15dcd
movl -0x260(%rbp), %eax
movl -0x25c(%rbp), %ecx
cmpl %ecx, %eax
jae 0x15e57
movq -0x10(%rbp), %rdi
callq 0x161f0
movq %rax, -0x268(%rbp)
jmp 0x15def
movq -0x268(%rbp), %rdi
movl -0x228(%rbp), %eax
movl %eax, %esi
callq 0x4330
movq %rax, %rdi
movl -0x22c(%rbp), %eax
movl %eax, %esi
callq 0x43e0
movsd (%rax), %xmm0
leaq -0x218(%rbp), %rdi
callq 0x34e0
movq %rax, -0x270(%rbp)
jmp 0x15e2c
movq -0x270(%rbp), %rdi
leaq 0x4551(%rip), %rsi      # 0x1a38b
callq 0x3270
jmp 0x15e41
jmp 0x15e43
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x15db0
movq 0x11152(%rip), %rsi     # 0x26fb0
leaq -0x218(%rbp), %rdi
callq 0x32b0
jmp 0x15e6c
jmp 0x15e6e
movl -0x228(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x228(%rbp)
jmp 0x15d75
leaq -0x218(%rbp), %rdi
callq 0x33a0
jmp 0x15e90
leaq -0x218(%rbp), %rdi
callq 0x33d0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
leaq 0x42eb(%rip), %rdx      # 0x1a5c4
callq 0x3080
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x16410
movl -0x1c(%rbp), %eax
addl $-0x3f, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x37, %eax
ja 0x163f4
movq -0x30(%rbp), %rax
leaq 0x41da(%rip), %rcx      # 0x1a4e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq 0x10c9a(%rip), %rax     # 0x26fb8
movq (%rax), %rsi
addq $0x8, %rdi
callq 0x3380
jmp 0x1640b
movq 0x10c82(%rip), %rax     # 0x26fb8
movq (%rax), %rdi
callq 0x3400
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1640b
movq 0x10c66(%rip), %rax     # 0x26fb8
movq (%rax), %rdi
callq 0x3400
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, 0x28(%rax)
jmp 0x1640b
movq -0x28(%rbp), %rdi
movq 0x10c41(%rip), %rax     # 0x26fb8
movq (%rax), %rsi
addq $0x30, %rdi
callq 0x3380
jmp 0x1640b
movq 0x10c29(%rip), %rax     # 0x26fb8
movq (%rax), %rdi
callq 0x3400
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x50(%rax)
cmpl $0x1, 0x50(%rax)
jae 0x163de
movq 0x10c1b(%rip), %rdi     # 0x26fc8
leaq 0x421c(%rip), %rsi      # 0x1a5d0
callq 0x3270
movq %rax, %rdi
movq 0x10bed(%rip), %rsi     # 0x26fb0
callq 0x32b0
movq %rax, %rdi
movq 0x10bde(%rip), %rsi     # 0x26fb0
callq 0x32b0
xorl %edi, %edi
callq 0x3320
jmp 0x1640b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x16420
jmp 0x1640b
jmp 0x163f4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x16420
xorl %edi, %edi
callq 0x3320
jmp 0x162cb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x10b99(%rip), %rax     # 0x26fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x41d1(%rip), %rsi      # 0x1a616
movb $0x0, %al
callq 0x33b0
movq 0x10b7d(%rip), %rax     # 0x26fd0
movq (%rax), %rdi
leaq 0x41c9(%rip), %rsi      # 0x1a626
movb $0x0, %al
callq 0x33b0
movq 0x10b65(%rip), %rax     # 0x26fd0
movq (%rax), %rdi
leaq 0x41e3(%rip), %rsi      # 0x1a658
movb $0x0, %al
callq 0x33b0
movq 0x10b4d(%rip), %rax     # 0x26fd0
movq (%rax), %rdi
leaq 0x4205(%rip), %rsi      # 0x1a692
movb $0x0, %al
callq 0x33b0
movq 0x10b35(%rip), %rax     # 0x26fd0
movq (%rax), %rdi
leaq 0x4212(%rip), %rsi      # 0x1a6b7
movb $0x0, %al
callq 0x33b0
movq 0x10b1d(%rip), %rax     # 0x26fd0
movq (%rax), %rdi
leaq 0x422a(%rip), %rsi      # 0x1a6e7
movb $0x0, %al
callq 0x33b0
movq 0x10b05(%rip), %rax     # 0x26fd0
movq (%rax), %rdi
leaq 0x4239(%rip), %rsi      # 0x1a70e
movb $0x0, %al
callq 0x33b0
xorl %edi, %edi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: iu-vail[P]iprimal/./CmdParser.h
// Function: CmdParser::DisplayInput()
void
CmdParser::DisplayInput(void){

  if(this->input_file != "")
    _cout("  Accept new input file: "<<input_file<<endl);
  
  if(this->seed != SEED)
    _cout("  Accept new seed: "<<seed<<endl);

  if(this->assignment_size != COL_SIZE)
    _cout("  Accept new assignment size: "<<assignment_size<<endl);

  if(this->output_file != OUTPUT_FILE)
    _cout("  Accept new output file: "<<output_file<<endl);

  if(this->verbose_level != VERBOSE_LEVEL)
    _cout("  Accept new verbose level: "<<verbose_level<<endl);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
leaq 0x3e7d(%rip), %rsi      # 0x1a38c
callq 0x16cb0
testb $0x1, %al
jne 0x1651a
jmp 0x1651c
jmp 0x1651c
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x16527
jmp 0x16527
movq -0x10(%rbp), %rax
cmpq $0x5, 0x28(%rax)
je 0x16534
jmp 0x16534
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
leaq 0x40cb(%rip), %rsi      # 0x1a60e
callq 0x16cb0
testb $0x1, %al
jne 0x1654e
jmp 0x16550
jmp 0x16550
movq -0x10(%rbp), %rax
cmpl $0x1, 0x50(%rax)
je 0x1655c
jmp 0x1655c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iu-vail[P]iprimal/./iPrimal.h
// Function: Primal::Primal(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
Primal(mat& m){ 
	row_size = m.size();
	col_size = m[0].size();
	assert(row_size <= col_size);  //currently assume they are equal 
	orig_matrix = m;
	oprt_matrix = m;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
movq %rdi, -0x88(%rbp)
callq 0x4400
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x80(%rbp)
callq 0x4400
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x78(%rbp)
callq 0x4400
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x70(%rbp)
callq 0xa8a0
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
movq %rdi, -0x68(%rbp)
callq 0xa8a0
movq -0x28(%rbp), %rdi
addq $0xb0, %rdi
movq %rdi, -0x60(%rbp)
callq 0x17570
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x17570
movq -0x28(%rbp), %rdi
addq $0xe0, %rdi
movq %rdi, -0x50(%rbp)
callq 0x17640
movq -0x28(%rbp), %rdi
addq $0xf8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x17080
movq -0x28(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
movq %rdi, -0x40(%rbp)
callq 0x17660
movq -0x28(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movq %rdi, -0x38(%rbp)
callq 0x17680
movq -0x28(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq %rdi, -0x30(%rbp)
callq 0x17680
movq -0x10(%rbp), %rdi
callq 0x4580
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4330
movq %rax, %rdi
callq 0x4470
movq -0x28(%rbp), %rcx
movl %eax, 0x4(%rcx)
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
ja 0x16fa5
jmp 0x16fc4
leaq 0x394c(%rip), %rdi      # 0x1a8f8
leaq 0x395a(%rip), %rsi      # 0x1a90d
movl $0x1c, %edx
leaq 0x395a(%rip), %rcx      # 0x1a919
callq 0x3190
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xb0, %rdi
callq 0x176a0
jmp 0x16fda
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xc8, %rdi
callq 0x176a0
jmp 0x16ff0
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x178f0
movq -0x38(%rbp), %rdi
callq 0x178f0
movq -0x40(%rbp), %rdi
callq 0x17950
movq -0x48(%rbp), %rdi
callq 0x170a0
movq -0x50(%rbp), %rdi
callq 0x17970
movq -0x58(%rbp), %rdi
callq 0x179d0
movq -0x60(%rbp), %rdi
callq 0x179d0
movq -0x68(%rbp), %rdi
callq 0xaac0
movq -0x70(%rbp), %rdi
callq 0xaac0
movq -0x78(%rbp), %rdi
callq 0x4490
movq -0x80(%rbp), %rdi
callq 0x4490
movq -0x88(%rbp), %rdi
callq 0x4490
movq -0x18(%rbp), %rdi
callq 0x3490
nopl (%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Card.cpp
// Function: Card::Card()
Card::Card() {
	content = "";
	type = ' ';
	numOfAnswers = 0;
	owner = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x22d0
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x22d0
movq -0x20(%rbp), %rdi
leaq 0x7a52(%rip), %rsi      # 0xa20e
callq 0x22c0
jmp 0x27c3
movq -0x30(%rbp), %rdi
movb $0x20, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
addq $0x28, %rdi
leaq 0x7a31(%rip), %rsi      # 0xa20e
callq 0x22c0
jmp 0x27e4
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x23e8
movq -0x20(%rbp), %rdi
callq 0x23e8
movq -0x10(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %r8, -0x58(%rbp)
movq %rsi, -0x38(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x22d0
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x48(%rbp)
callq 0x22d0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2050
jmp 0x2878
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movb -0x11(%rbp), %al
movb %al, 0x20(%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x24(%rdi)
addq $0x28, %rdi
callq 0x2050
jmp 0x2897
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x23e8
movq -0x40(%rbp), %rdi
callq 0x23e8
movq -0x28(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x22d0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x22d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2050
jmp 0x2920
movq -0x48(%rbp), %rdi
movb -0x11(%rbp), %al
movb %al, 0x20(%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x24(%rdi)
addq $0x28, %rdi
leaq 0x78d3(%rip), %rsi      # 0xa20e
callq 0x22c0
jmp 0x2942
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x23e8
movq -0x38(%rbp), %rdi
callq 0x23e8
movq -0x20(%rbp), %rdi
callq 0x2360
nop
// File: 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
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x22d0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x22d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2050
jmp 0x29c0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
movb $0x77, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
addq $0x28, %rdi
callq 0x2050
jmp 0x29de
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x23e8
movq -0x38(%rbp), %rdi
callq 0x23e8
movq -0x20(%rbp), %rdi
callq 0x2360
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x28, %rdi
callq 0x3280
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
ja 0x2dac
cmpl $0x0, -0x14(%rbp)
jge 0x2dba
movq -0x78(%rbp), %rdi
callq 0x2780
jmp 0x2e6a
movq -0x68(%rbp), %rdi
movb $0x0, -0x15(%rbp)
addq $0x28, %rdi
movq %rdi, -0x80(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x32b0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x32d0
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3340
jmp 0x2dee
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2e80
jmp 0x2e00
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
leaq -0x30(%rbp), %rsi
callq 0x3430
leaq -0x30(%rbp), %rdi
callq 0x31b0
leaq -0x48(%rbp), %rdi
callq 0x31b0
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x2e5d
jmp 0x2e54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2e5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31b0
jmp 0x2e5f
movq -0x78(%rbp), %rdi
callq 0x3460
jmp 0x2e6a
movq -0x78(%rbp), %rdi
callq 0x3460
jmp 0x2e77
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2360
// File: 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
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x3190
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0x3280
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2f14
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x2f07
movq -0x48(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x32b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x3210
jmp 0x2eee
jmp 0x2f07
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31b0
jmp 0x2f31
jmp 0x2f09
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2eb2
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x2f27
movq -0x40(%rbp), %rdi
callq 0x31b0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2360
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x28, %rdi
callq 0x3280
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2fe1
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x32b0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x2040
cmpl $0x0, %eax
jne 0x2fd4
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x32b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x32d0
jmp 0x2fea
jmp 0x2fd6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2f72
movq -0x38(%rbp), %rdi
callq 0x2780
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2c30
leaq -0x38(%rbp), %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x23e8
movl -0x3c(%rbp), %eax
cmpl $0x0, %eax
jne 0x305d
movb $0x1, -0x1(%rbp)
jmp 0x3061
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2c30
movq -0x88(%rbp), %rdi
callq 0x20f0
movq -0x80(%rbp), %rsi
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2c30
jmp 0x30ba
leaq -0x60(%rbp), %rdi
callq 0x20f0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x22e0
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x23e8
leaq -0x40(%rbp), %rdi
callq 0x23e8
movl -0x8c(%rbp), %eax
cmpl $0x0, %eax
jne 0x310f
movb $0x1, -0x1(%rbp)
jmp 0x3113
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x23e8
jmp 0x3121
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2360
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3280
movslq -0xc(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x6947
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6930
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x32b0
movq %rax, %rdi
callq 0x20f0
movl -0x2c(%rbp), %esi
movq %rax, %rdx
leaq 0x3df3(%rip), %rdi      # 0xa711
movb $0x0, %al
callq 0x2060
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x68ee
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x68c1
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Client.cpp
// Function: substitute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char)
string substitute(string target, string replacement[], char subChar) {
	string newString = target;
	int s = 0;
	for (int i = 0; i < newString.length(); i++) {
		if (newString[i] == subChar) {
			newString = newString.substr(0, i) + replacement[s] + newString.substr(i+1);
			s++;
		}
	}
	return newString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x2100
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0xc8(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0xd0(%rbp)
callq 0x2300
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0x6e96
movq -0xc8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x23d0
movq %rax, -0xd8(%rbp)
jmp 0x6d57
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6e86
movq -0xc8(%rbp), %rsi
movslq -0x24(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x98(%rbp), %rdi
callq 0x2220
jmp 0x6d8a
movq -0x18(%rbp), %rdx
movslq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdx
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x8550
jmp 0x6dab
movq -0xc8(%rbp), %rsi
movl -0x24(%rbp), %eax
incl %eax
movslq %eax, %rdx
leaq -0xb8(%rbp), %rdi
movq $-0x1, %rcx
callq 0x2220
jmp 0x6dcf
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x8640
jmp 0x6de5
movq -0xc8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2280
leaq -0x58(%rbp), %rdi
callq 0x23e8
leaq -0xb8(%rbp), %rdi
callq 0x23e8
leaq -0x78(%rbp), %rdi
callq 0x23e8
leaq -0x98(%rbp), %rdi
callq 0x23e8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6ebc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6e78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6e6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x23e8
leaq -0x78(%rbp), %rdi
callq 0x23e8
leaq -0x98(%rbp), %rdi
callq 0x23e8
jmp 0x6ebc
jmp 0x6e88
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6d14
movb $0x1, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
jne 0x6eac
movq -0xc8(%rbp), %rdi
callq 0x23e8
movq -0xc0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x23e8
movq -0x30(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: muzuka[P]Cards-Against-Humanity-Online/Client.cpp
// Function: composeSENDMessage[abi:cxx11](char, Card)
string composeSENDMessage(char type, Card cardToSend) {
	char* t;
	if(type == 'n') {
		return "ANSWER " + self.getName() + "\n" + cardToSend.content;
	}
	else if(type == 'd') {
		return "ADD " + self.getName() + "\n" + cardToSend.content;
	}
	else {
		return "";
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdx, -0x110(%rbp)
movq %rdi, -0x108(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x6e, %eax
jne 0x7d37
leaq 0x67cb(%rip), %rsi      # 0xe430
leaq -0x80(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x2c30
movq -0x118(%rbp), %rdx
leaq 0x2b66(%rip), %rsi      # 0xa7e9
leaq -0x60(%rbp), %rdi
callq 0x85f0
jmp 0x7c8e
leaq 0x2578(%rip), %rdx      # 0xa20d
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x85a0
jmp 0x7ca4
movq -0x110(%rbp), %rdx
movq -0x108(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8550
jmp 0x7cbd
leaq -0x40(%rbp), %rdi
callq 0x23e8
leaq -0x60(%rbp), %rdi
callq 0x23e8
leaq -0x80(%rbp), %rdi
callq 0x23e8
jmp 0x7e98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x7d29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x7d20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x23e8
leaq -0x60(%rbp), %rdi
callq 0x23e8
leaq -0x80(%rbp), %rdi
callq 0x23e8
jmp 0x7ea8
movsbl -0x9(%rbp), %eax
cmpl $0x64, %eax
jne 0x7e3b
leaq 0x66e5(%rip), %rsi      # 0xe430
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x2c30
movq -0x120(%rbp), %rdx
leaq 0x2a85(%rip), %rsi      # 0xa7f1
leaq -0xd0(%rbp), %rdi
callq 0x85f0
jmp 0x7d7a
leaq 0x248c(%rip), %rdx      # 0xa20d
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x85a0
jmp 0x7d96
movq -0x110(%rbp), %rdx
movq -0x108(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x8550
jmp 0x7db2
leaq -0xb0(%rbp), %rdi
callq 0x23e8
leaq -0xd0(%rbp), %rdi
callq 0x23e8
leaq -0xf0(%rbp), %rdi
callq 0x23e8
jmp 0x7e98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x7e2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x7e21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x23e8
leaq -0xd0(%rbp), %rdi
callq 0x23e8
leaq -0xf0(%rbp), %rdi
callq 0x23e8
jmp 0x7ea8
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x2370
movq -0x108(%rbp), %rdi
movq -0x128(%rbp), %rdx
leaq 0x23ab(%rip), %rsi      # 0xa20e
callq 0x8350
jmp 0x7e6a
leaq -0xf1(%rbp), %rdi
callq 0x2240
jmp 0x7e98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xf1(%rbp), %rdi
callq 0x2240
jmp 0x7ea8
movq -0x100(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2330
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7f1f
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x2330
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7eec
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2300
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x7f9f
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x23d0
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7f92
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7f94
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7f54
movsbl -0x11(%rbp), %eax
cmpl $0x5f, %eax
jne 0x7fb7
cmpl $0x0, -0x18(%rbp)
jne 0x7fb7
movl $0x1, -0x4(%rbp)
jmp 0x7fbd
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
testb $0x1, -0x1(%rbp)
je 0x8284
movb $0x1, 0x5fcf(%rip)      # 0xe224
leaq 0x622c(%rip), %rdi      # 0xe488
leaq 0x61cd(%rip), %rsi      # 0xe430
callq 0x84c0
leaq 0x6291(%rip), %rdi      # 0xe500
callq 0x8530
leaq 0x2556(%rip), %rdi      # 0xa7d1
movb $0x0, %al
callq 0x2060
jmp 0x82f6
movq -0x48(%rbp), %rsi
movb $0x0, 0x5f95(%rip)      # 0xe224
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2100
movq -0x50(%rbp), %rsi
leaq 0x61e1(%rip), %rdi      # 0xe488
callq 0x2c60
jmp 0x82ae
leaq -0x30(%rbp), %rdi
callq 0x23e8
leaq 0x6242(%rip), %rdi      # 0xe500
callq 0x8530
movq -0x48(%rbp), %rdi
callq 0x20f0
movq %rax, %rsi
leaq 0x1fb2(%rip), %rdi      # 0xa288
movb $0x0, %al
callq 0x2060
jmp 0x82f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x23e8
jmp 0x82fc
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x38(%rbp)
jmp 0x44ae
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x44de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3090
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
callq 0x33d0
jmp 0x4567
testb $0x1, -0x15(%rbp)
je 0x4526
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x8(%rcx), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x4508
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x4512
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x3190
movq -0x40(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x454e
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x454c
movq -0x60(%rbp), %rdi
callq 0x3310
jmp 0x454e
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x125d5(%rip), %rcx     # 0x16cd0
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x4730
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4724
movq -0x18(%rbp), %rdi
callq 0x3310
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movsd 0xba85(%rip), %xmm0     # 0x101c8
movsd %xmm0, 0x18(%rax)
movb $0x0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb920(%rip), %rsi      # 0x101e3
callq 0x31f0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x3320
movq %rax, %rdi
leaq 0xb910(%rip), %rsi      # 0x101f1
callq 0x31f0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x4953
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %edi
callq 0x49b0
movq -0x30(%rbp), %rdi
movsbl %al, %esi
callq 0x32c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movzbl (%rax,%rcx), %edi
callq 0x4a00
movq -0x28(%rbp), %rdi
movsbl %al, %esi
callq 0x32c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x48ed
movq -0x10(%rbp), %rdi
leaq 0xb89d(%rip), %rsi      # 0x101fb
callq 0x31f0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x3440
movq %rax, %rdi
leaq 0xb88d(%rip), %rsi      # 0x1020b
callq 0x31f0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3420
movq %rax, %rdi
leaq 0xbdbc(%rip), %rsi      # 0x1075d
callq 0x31f0
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movl 0x20(%rbp), %edx
movl 0x18(%rbp), %edx
movl 0x10(%rbp), %edx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0x12287(%rip), %rax     # 0x16d10
addq $0x10, %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x30b0
movq -0x50(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x48(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x4c(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x50(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x54(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x58(%rax)
movl 0x20(%rbp), %ecx
movl %ecx, 0x5c(%rax)
movl $0x0, 0x60(%rax)
movl $0x0, 0x64(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x68(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x70(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x78(%rax)
testb $0x1, -0x11(%rbp)
je 0x4b3f
movq -0x50(%rbp), %rdi
callq 0x4b60
jmp 0x4b26
jmp 0x4b4c
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3120
jmp 0x4b52
movq -0x50(%rbp), %rdi
callq 0x4fa0
jmp 0x4b4a
jmp 0x4b4c
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3400
nopl (%rax,%rax)
// File: cpottamus[P]btree_lab/disksystem.cc
// Function: DiskSystem::~DiskSystem()
DiskSystem::~DiskSystem()
{
  WriteConfig();
  WriteBitMap();
  fclose(configfilefd);
  fclose(bitmapfilefd);
  fclose(datafilefd);
  delete [] bitmap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x11a55(%rip), %rax     # 0x16d20
movq %rax, (%rdi)
callq 0x5350
jmp 0x52d5
movq -0x10(%rbp), %rdi
callq 0x55a0
jmp 0x52e0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3200
jmp 0x52ef
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3200
jmp 0x52fe
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3200
jmp 0x530d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5328
movq -0x18(%rbp), %rdi
callq 0x3310
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x3120
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x43a0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rax), %rdi
callq 0x3040
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %ecx
shrl $0x3, %ecx
movl 0x4c(%rax), %edx
andl $0x7, %edx
cmpl $0x0, %edx
setne %dl
andb $0x1, %dl
movzbl %dl, %edx
addl %edx, %ecx
movl %ecx, -0x14(%rbp)
movq 0x20(%rax), %rdi
movq 0x8(%rax), %rdx
movl -0x14(%rbp), %ecx
xorl %esi, %esi
callq 0x5a50
cmpl -0x14(%rbp), %eax
je 0x5611
movq 0x119f4(%rip), %rdi     # 0x16ff0
leaq 0xad3d(%rip), %rsi      # 0x10340
callq 0x31f0
movl $0xfffffff5, -0x4(%rbp) # imm = 0xFFFFFFF5
jmp 0x5618
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)