LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/redpony[P]cpyp/./cpyp/crp.h
// Function: cpyp::crp<int, std::hash<int>>::update_llh_add_customer_to_table_seating(unsigned int)
void update_llh_add_customer_to_table_seating(unsigned n) {
    unsigned t = 0;
    if (n == 0) {
      t = 1;
    }
    llh_ -= log(strength_ + num_customers_);
    if (t == 1) {
      llh_ += log(discount_) + log(strength_ / discount_ + num_tables_);
    }
    if (n > 0) {
      llh_ += log(n - discount_);
    }
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cvtsi2sd %rax, %xmm0
addsd 0x48(%rdi), %xmm0
callq 0x2150
movsd 0x70(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x70(%rbx)
testl %ebp, %ebp
je 0x7742
movl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd 0x40(%rbx), %xmm0
callq 0x2150
jmp 0x7773
movsd 0x40(%rbx), %xmm0
callq 0x2150
movsd %xmm0, (%rsp)
movsd 0x48(%rbx), %xmm1
divsd 0x40(%rbx), %xmm1
movl (%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addsd %xmm1, %xmm0
callq 0x2150
addsd (%rsp), %xmm0
addsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/redpony[P]cpyp/./cpyp/mf_crp.h
// Function: cpyp::mf_crp<2u, unsigned int, std::hash<unsigned int>>::check_hyperparameters()
void check_hyperparameters() {
    if (discount_ < 0.0 || discount_ >= 1.0) {
      std::cerr << "Bad discount: " << discount_ << std::endl;
      abort();
    }
    if (strength_ <= -discount_) {
      std::cerr << "Bad strength: " << strength_ << " (discount=" << discount_ << ")" << std::endl;
      abort();
    }

    llh_ = lgamma(strength_) - lgamma(strength_ / discount_);
    if (has_discount_prior())
      llh_ = Md::log_beta_density(discount_, discount_prior_strength_, discount_prior_beta_);
    if (has_strength_prior())
      llh_ += Md::log_gamma_density(strength_ + discount_, strength_prior_shape_, strength_prior_rate_);
    if (num_tables_ > 0) llh_ = log_likelihood(discount_, strength_);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x40(%rdi), %rbx
movsd 0x40(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x7dea
ucomisd 0x22f4(%rip), %xmm1     # 0xa010
jae 0x7dea
movq %rdi, %r14
leaq 0x48(%rdi), %r15
movsd 0x48(%rdi), %xmm0
xorpd 0x238a(%rip), %xmm1     # 0xa0c0
ucomisd %xmm0, %xmm1
jae 0x7e0b
callq 0x2130
movsd %xmm0, (%rsp)
movsd 0x48(%r14), %xmm0
divsd 0x40(%r14), %xmm0
callq 0x2130
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x70(%r14)
movsd 0x50(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x7d8c
leaq 0x50(%r14), %rsi
leaq 0x58(%r14), %rdx
movq %rbx, %rdi
callq 0x6288
movsd %xmm0, 0x70(%r14)
movsd 0x60(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x7dc6
movsd 0x48(%r14), %xmm0
addsd 0x40(%r14), %xmm0
leaq 0x60(%r14), %rsi
leaq 0x8(%rsp), %rdi
movsd %xmm0, (%rdi)
leaq 0x68(%r14), %rdx
callq 0x640c
addsd 0x70(%r14), %xmm0
movsd %xmm0, 0x70(%r14)
cmpl $0x0, (%r14)
je 0x7de0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7e62
movsd %xmm0, 0x70(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x61ff(%rip), %rdi      # 0xdff0
leaq 0x2996(%rip), %rsi      # 0xa78e
callq 0x21a0
movsd (%rbx), %xmm0
movq %rax, %rdi
callq 0x22a0
jmp 0x7e55
movq 0x61de(%rip), %rdi      # 0xdff0
leaq 0x2984(%rip), %rsi      # 0xa79d
callq 0x21a0
movsd (%r15), %xmm0
movq %rax, %rdi
callq 0x22a0
leaq 0x297a(%rip), %rsi      # 0xa7ac
movq %rax, %rdi
callq 0x21a0
movsd (%rbx), %xmm0
movq %rax, %rdi
callq 0x22a0
leaq 0x2604(%rip), %rsi      # 0xa451
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x2090
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/redpony[P]cpyp/./cpyp/mf_crp.h
// Function: cpyp::mf_crp<2u, unsigned int, std::hash<unsigned int>>::update_llh_remove_customer_from_table_seating(unsigned int)
void update_llh_remove_customer_from_table_seating(unsigned n) {
    unsigned t = 0;
    if (n == 1) t = 1;
    llh_ += log(strength_ + num_customers_ - 1);
    if (t == 1) llh_ -= log(discount_) + log(strength_ / discount_ + num_tables_ - 1);
    if (n > 1) llh_ -= log(n - discount_ - 1);
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cvtsi2sd %rax, %xmm0
addsd 0x48(%rdi), %xmm0
addsd 0x16d5(%rip), %xmm0     # 0xa080
callq 0x2150
addsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x70(%rbx)
cmpl $0x1, %ebp
jne 0x8a07
movsd 0x40(%rbx), %xmm0
callq 0x2150
movsd 0x48(%rbx), %xmm2
divsd 0x40(%rbx), %xmm2
movl (%rbx), %eax
cvtsi2sd %rax, %xmm1
movsd %xmm0, (%rsp)
addsd %xmm2, %xmm1
addsd 0x1695(%rip), %xmm1     # 0xa080
movapd %xmm1, %xmm0
callq 0x2150
addsd (%rsp), %xmm0
movsd 0x70(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x70(%rbx)
cmpl $0x2, %ebp
jb 0x8a36
movl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd 0x40(%rbx), %xmm0
addsd 0x165d(%rip), %xmm0     # 0xa080
callq 0x2150
movsd 0x70(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/redpony[P]cpyp/./cpyp/crp.h
// Function: cpyp::crp<int, std::hash<int>>::print(std::ostream*) const
void print(std::ostream* out) const {
    (*out) << "PYP(d=" << discount_ << ",c=" << strength_
           << ") customers=" << num_customers_ << std::endl;
    for (auto& dish_loc : dish_locs_)
      (*out) << dish_loc.first << " : " << dish_loc.second << std::endl;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1cac(%rip), %rsi      # 0xaad7
movl $0x6, %edx
movq %rbx, %rdi
callq 0x21c0
movsd 0x40(%r14), %xmm0
movq %rbx, %rdi
callq 0x2230
movq %rax, %r15
leaq 0x1c8e(%rip), %rsi      # 0xaade
movl $0x3, %edx
movq %rax, %rdi
callq 0x21c0
movsd 0x48(%r14), %xmm0
movq %r15, %rdi
callq 0x2230
movq %rax, %r15
leaq 0x1c6d(%rip), %rsi      # 0xaae2
movl $0xc, %edx
movq %rax, %rdi
callq 0x21c0
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x20f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%r14), %r12
testq %r12, %r12
je 0x8f28
leaq 0x1c27(%rip), %r14      # 0xaaef
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x2260
movq %rax, %r15
movl $0x3, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x8f34
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%r12), %r12
testq %r12, %r12
jne 0x8ec8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ridgelab[P]Kmer-SSR/test/src/arguments.cpp
// Function: test1()
bool test1()
{
	try
	{
		int argc = 5;
		char* argv[] = {
			(char*)("test1"),
			(char*)("-i"),
			(char*)("example/input.fasta"),
			(char*)("-o"),
			(char*)("test/arg1.tsv")
		};
		
		Arguments* args = new Arguments(argc, argv);

		if (args->getInFileName() != "example/input.fasta")
		{
			return false;
		}
		if (args->getOutFileName() != "test/arg1.tsv")
		{
			return false;
		}

		delete args;
	}
	catch(string error)
	{
		cerr << error << endl;
		return false;
	}
	catch(const char* error)
	{
		cerr << error << endl;
		return false;
	}

	return true; // success
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x94e8(%rip), %rax      # 0xbcb0
movq %rax, 0x20(%rsp)
movaps 0x94cc(%rip), %xmm0     # 0xbca0
movaps %xmm0, 0x10(%rsp)
movaps 0x94b0(%rip), %xmm0     # 0xbc90
movaps %xmm0, (%rsp)
movl $0xf0, %edi
callq 0x21d0
movq %rax, %rbx
movq %rsp, %rdx
movq %rax, %rdi
movl $0x5, %esi
callq 0x31a2
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x4878
leaq 0x483f(%rip), %rsi      # 0x7054
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2090
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x38(%rsp), %r15
cmpq %r15, %rdi
je 0x283e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
jne 0x287e
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x489c
leaq 0x4815(%rip), %rsi      # 0x706b
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2090
movl %eax, %ebp
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x287a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
je 0x288b
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x45cc
movl $0xf0, %esi
movq %rbx, %rdi
callq 0x21e0
movb $0x1, %al
jmp 0x2880
jmp 0x28bd
jmp 0x28bd
movq %rdx, %r15
movq %rax, %r14
movl $0xf0, %esi
movq %rbx, %rdi
callq 0x21e0
jmp 0x28c3
movq %rdx, %r15
movq %rax, %r14
cmpl $0x2, %r15d
jne 0x2929
movq %r14, %rdi
callq 0x2240
leaq 0x10(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x2fd6
movq %r14, %rdi
callq 0x20c0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x96e4(%rip), %rdi      # 0xbfe8
callq 0x2230
movq %rax, %rdi
callq 0x20e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x294e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x294e
cmpl $0x1, %r15d
jne 0x2980
movq %r14, %rdi
callq 0x20c0
movq 0x96aa(%rip), %rdi      # 0xbfe8
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
callq 0x22e0
jmp 0x287e
movq %rax, %r14
callq 0x22e0
jmp 0x2980
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x297b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
callq 0x22e0
movq %r14, %rdi
callq 0x2300
movq %rax, %rdi
callq 0x2fcb
// File: /workspace/github_cpp_makefile_star2_O1/ridgelab[P]Kmer-SSR/test/src/arguments.cpp
// Function: test2()
bool test2()
{
	try
	{
		int argc = 1;
		char* argv[] = {
			(char*)("test2")
		};
		
		Arguments* args = new Arguments(argc, argv);

		if (args->getInFileName() != "/dev/stdin")
		{
			return false;
		}
		if (args->getOutFileName() != "/dev/stdout")
		{
			return false;
		}

		delete args;
	}
	catch(string error)
	{
		cerr << error << endl;
		return false;
	}
	catch(const char* error)
	{
		cerr << error << endl;
		return false;
	}

	return true; // success
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x46d8(%rip), %rax      # 0x7079
movq %rax, 0x20(%rsp)
movl $0xf0, %edi
callq 0x21d0
movq %rax, %rbx
leaq 0x20(%rsp), %rdx
movq %rax, %rdi
movl $0x1, %esi
callq 0x31a2
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4878
leaq 0x46a8(%rip), %rsi      # 0x707f
movq %rsp, %r14
movq %r14, %rdi
callq 0x2090
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x10(%rsp), %r15
cmpq %r15, %rdi
je 0x29fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
jne 0x2a3a
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x489c
leaq 0x4676(%rip), %rsi      # 0x708a
movq %rsp, %r14
movq %r14, %rdi
callq 0x2090
movl %eax, %ebp
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x2a36
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
testl %ebp, %ebp
je 0x2a47
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x45cc
movl $0xf0, %esi
movq %rbx, %rdi
callq 0x21e0
movb $0x1, %al
jmp 0x2a3c
jmp 0x2a79
jmp 0x2a79
movq %rdx, %r15
movq %rax, %r14
movl $0xf0, %esi
movq %rbx, %rdi
callq 0x21e0
jmp 0x2a7f
movq %rdx, %r15
movq %rax, %r14
cmpl $0x2, %r15d
jne 0x2ae5
movq %r14, %rdi
callq 0x2240
leaq 0x10(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x2fd6
movq %r14, %rdi
callq 0x20c0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x9528(%rip), %rdi      # 0xbfe8
callq 0x2230
movq %rax, %rdi
callq 0x20e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x2b0a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x2b0a
cmpl $0x1, %r15d
jne 0x2b3c
movq %r14, %rdi
callq 0x20c0
movq 0x94ee(%rip), %rdi      # 0xbfe8
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
callq 0x22e0
jmp 0x2a3a
movq %rax, %r14
callq 0x22e0
jmp 0x2b3c
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x2b37
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
callq 0x22e0
movq %r14, %rdi
callq 0x2300
movq %rax, %rdi
callq 0x2fcb
// File: /workspace/github_cpp_makefile_star2_O1/siolag161[P]louvain-original/graph.cpp
// Function: Graph::Graph(char*, int)
Graph::Graph(char *filename, int type) {
  ifstream finput;
  finput.open(filename,fstream::in);

  int nb_links=0;

  while (!finput.eof()) {
    unsigned int src, dest;
    double weight=1.;

    if (type==WEIGHTED) {
      finput >> src >> dest >> weight;
    } else {
      finput >> src >> dest;
    }
    
    if (finput) {
      if (links.size()<=max(src,dest)+1) {
        links.resize(max(src,dest)+1);
      }
      
      links[src].push_back(make_pair(dest,weight));
      if (src!=dest)
        links[dest].push_back(make_pair(src,weight));

      nb_links++;
    }
  }

  finput.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
callq 0x21c0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x20f0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x25a1
movabsq $0x3ff0000000000000, %r13 # imm = 0x3FF0000000000000
leaq 0x20(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r13, 0x18(%rsp)
testl %ebp, %ebp
je 0x24bd
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
movq %rax, %rdi
movq %r12, %rsi
callq 0x2280
jmp 0x24e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
movq %rax, %rdi
movq %r12, %rsi
callq 0x2280
movq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2100
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x258d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movl 0xc(%rsp), %ecx
movl 0x8(%rsp), %esi
cmpl %esi, %ecx
cmoval %ecx, %esi
incl %esi
cmpq %rsi, %rax
ja 0x2529
movq %rbx, %rdi
callq 0x2e02
movl 0xc(%rsp), %eax
leaq (%rax,%rax,2), %rdi
shlq $0x3, %rdi
addq (%rbx), %rdi
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss 0x18(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x3286
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
cmpl %ecx, %eax
je 0x258d
leaq (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq (%rbx), %rdi
movl %eax, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss 0x18(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x3286
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
je 0x249c
leaq 0x20(%rsp), %rdi
callq 0x2060
leaq 0x20(%rsp), %rdi
callq 0x2070
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25d4
jmp 0x25d4
movq %rax, %r14
jmp 0x25e1
jmp 0x25d4
jmp 0x25d4
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2e3e
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]codecon/src/apples.cc
// Function: main
int main() {
  long long a0, o0, m0, x, y, mf;
  std::cin >> a0 >> o0 >> m0 >> x >> y >> mf;

  const auto dm = mf - m0;
  const auto mm = a0 * x + o0 * y - dm;

  const auto a = findSolution(mm, x, y);
  const auto o = findSolution(mm, y, x);

  if (a == -1 || o == -1) {
    std::cout << "Impossible\n";
  } else {
    std::cout << a << ' ' << o << '\n';
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x2e1f(%rip), %rdi      # 0x3fe0
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
leaq 0x28(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x1060
leaq 0x20(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x1060
leaq 0x18(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x1060
leaq 0x10(%rsp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
leaq 0x8(%rsp), %rbp
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1060
movq (%rbp), %r11
movq (%r15), %rcx
movq %rcx, %rsi
subq %r11, %rsi
movq (%r12), %r10
movq (%rbx), %rbx
imulq %r10, %rbx
movq (%r13), %r9
movq (%r14), %r14
imulq %r9, %r14
addq %rbx, %rsi
addq %r14, %rsi
movq %rsi, %rdi
testq %rsi, %rsi
jle 0x1279
leaq (%rcx,%r14), %rdi
addq %rbx, %rdi
subq %r11, %rdi
movq %rsi, %r8
movq %r8, %rax
cqto
idivq %r10
testq %rdx, %rdx
je 0x1276
subq %r9, %r8
subq %r9, %rdi
testq %rdi, %rdi
jg 0x125c
jmp 0x1279
movq %r8, %rdi
testq %rdi, %rdi
jle 0x128b
movq %rdi, %rax
cqto
idivq %r10
movq %rax, %r8
jmp 0x1292
movq $-0x1, %r8
testq %rsi, %rsi
jle 0x12ba
addq %rbx, %rcx
addq %r14, %rcx
subq %r11, %rcx
movq %rsi, %rax
cqto
idivq %r9
testq %rdx, %rdx
je 0x12ba
subq %r10, %rsi
subq %r10, %rcx
testq %rcx, %rcx
jg 0x12a0
jmp 0x12bd
movq %rsi, %rcx
testq %rcx, %rcx
jle 0x12cf
movq %rcx, %rax
cqto
idivq %r9
movq %rax, %rbx
jmp 0x12d6
movq $-0x1, %rbx
cmpq $-0x1, %r8
je 0x1328
cmpq $-0x1, %rbx
je 0x1328
movq 0x2ce7(%rip), %rdi      # 0x3fd0
movq %r8, %rsi
callq 0x1030
leaq 0x7(%rsp), %r14
movb $0x20, (%r14)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1030
movb $0xa, (%r14)
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
movq %rax, %rdi
jmp 0x133b
movq 0x2ca1(%rip), %rdi      # 0x3fd0
leaq 0xcce(%rip), %rsi       # 0x2004
movl $0xb, %edx
callq 0x1050
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH04_Expressions/examples/overflow.cc
// Function: main
int main() 
{
	short short_value = 32767; // max value if shorts are 16 bits

	short_value += 1; // this calculation overflows
	cout << "short_value: " << short_value << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2def(%rip), %rbx      # 0x3fd8
leaq 0xe14(%rip), %rsi       # 0x2004
movl $0xd, %edx
movq %rbx, %rdi
callq 0x1080
movq %rbx, %rdi
movl $0xffff8000, %esi       # imm = 0xFFFF8000
callq 0x1060
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/myudelson[P]hmm-scalable/inputconvert.cpp
// Function: main
int main (int argc, char ** argv) {
    
	clock_t tm0 = clock();
	char input_file[1024];
	char output_file[1024];
    
	set_task_defaults(&task);
	parse_arguments(argc, argv, input_file, output_file);
    
    if( source_format=='t') {
        InputUtilSt::readTxt(input_file, &task);
//        // vvv temporary
//        FILE *fid = fopen(output_file,"w");
//        for(NCAT i=0; i<task.map_group_bwd->size(); i++) {
//            fprintf(fid,"%s\n",task.map_group_bwd->find((NCAT)i)->second.c_str());
//        }
//        fclose(fid);
//        // ^^^ temporary
        InputUtilSt::toBin(&task, output_file);
    }
    else {
        InputUtilSt::readBin(input_file, &task);
    }
	// free data
	destroy_input_data(&task);
	
	if(task.quiet == 0)
		printf("overall time running is %8.6f seconds\n",(NUMBER)(clock()-tm0)/CLOCKS_PER_SEC);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r14
movl %edi, %ebp
callq 0x2120
movq %rax, %rbx
leaq 0xb6ed(%rip), %rdi      # 0xe228
callq 0x61be
movq %rsp, %rdx
leaq 0x400(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x2973
cmpb $0x74, 0xb694(%rip)     # 0xe1f0
jne 0x2b82
leaq 0xb6c3(%rip), %r14      # 0xe228
movq %rsp, %rdi
movq %r14, %rsi
callq 0x6f22
leaq 0x400(%rsp), %rsi
movq %r14, %rdi
callq 0x8cf6
jmp 0x2b91
leaq 0xb69f(%rip), %rsi      # 0xe228
movq %rsp, %rdi
callq 0x83de
leaq 0xb690(%rip), %rdi      # 0xe228
callq 0x642c
cmpb $0x0, 0xb6d0(%rip)      # 0xe274
jne 0x2bc9
callq 0x2120
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x744d(%rip), %xmm0     # 0xa008
leaq 0x7570(%rip), %rdi      # 0xa132
movb $0x1, %al
callq 0x2050
xorl %eax, %eax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_server::start_accept()
void start_accept()
  {
    chat_session_ptr new_session(new chat_session(io_service_, room_));
    acceptor_.async_accept(new_session->socket(),
        boost::bind(&chat_server::handle_accept, this, new_session,
          boost::asio::placeholders::error));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl $0x2d0, %edi            # imm = 0x2D0
callq 0x52f0
movq %rax, %r14
movq (%rbx), %rsi
leaq 0x58(%rbx), %rdx
movq %rax, %rdi
callq 0xc048
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc0e0
movq (%r15), %r12
testq %r12, %r12
je 0x86c5
movq %r12, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x8653
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r14
leaq 0x3b8c(%rip), %rsi      # 0xc1f0
leaq 0x3bc4(%rip), %r9       # 0xc22f
leaq 0x20(%rsp), %rdi
movq %rsp, %r8
xorl %edx, %edx
movq %rbx, %rcx
callq 0xc14f
addq $0x18, %r12
movq 0x8(%rbx), %rdi
leaq 0x10(%rbx), %rsi
addq $0x28, %rbx
leaq 0x20(%rsp), %r8
movq %r12, %rdx
xorl %ecx, %ecx
movq %rbx, %r9
callq 0xdf52
leaq 0x40(%rsp), %rdi
callq 0xc016
movq %r15, %rdi
callq 0xc016
movq %r14, %rdi
callq 0xc016
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8e96(%rip), %rdi      # 0x11562
leaq 0x8e97(%rip), %rsi      # 0x1156a
leaq 0x8ebc(%rip), %rcx      # 0x11596
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x5200
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xc016
jmp 0x86f6
movq %rax, %rbx
movq %r15, %rdi
callq 0xc016
movq %r14, %rdi
callq 0xc016
jmp 0x8718
movq %rax, %rbx
movl $0x2d0, %esi            # imm = 0x2D0
movq %r14, %rdi
callq 0x5300
movq %rbx, %rdi
callq 0x54f0
// File: /workspace/github_cpp_makefile_star2_O1/jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::deliver(chat_message const&)
void deliver(const chat_message& msg)
  {
    bool write_in_progress = !write_msgs_.empty();
    write_msgs_.push_back(msg);
    if (!write_in_progress)
    {
      boost::asio::async_write(socket_,
          boost::asio::buffer(write_msgs_.front().data(),
            write_msgs_.front().length()),
          boost::bind(&chat_session::handle_write, shared_from_this(),
            boost::asio::placeholders::error));
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x290(%rdi), %r15
movq 0x2b0(%rdi), %r14
movq $-0x210, %rax           # imm = 0xFDF0
addq 0x2c0(%rdi), %rax
cmpq %rax, %r14
je 0xc2e1
movl $0x210, %edx            # imm = 0x210
movq %r14, %rdi
callq 0x5280
addq $0x210, 0x2b0(%rbx) # imm = 0x210
jmp 0xc2ed
leaq 0x280(%rbx), %rdi
callq 0xc62e
cmpq %r15, %r14
jne 0xc370
movq 0x290(%rbx), %rax
movq 0x208(%rax), %rcx
addq $0x4, %rcx
movq %rax, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc5e4
leaq 0x180(%rip), %rsi       # 0xc4a6
leaq -0xfe(%rip), %r8        # 0xc22f
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc40e
addq $0x18, %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x7(%rsp), %rcx
callq 0xc858
leaq 0x40(%rsp), %rdi
callq 0xc016
leaq 0x10(%rsp), %rdi
callq 0xc016
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xc016
jmp 0xc38c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc016
movq %rbx, %rdi
callq 0x54f0
// File: /workspace/github_cpp_makefile_star2_O1/jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::handle_write(boost::system::error_code const&)
void handle_write(const boost::system::error_code& error)
  {
    if (!error)
    {
      write_msgs_.pop_front();
      if (!write_msgs_.empty())
      {
        boost::asio::async_write(socket_,
            boost::asio::buffer(write_msgs_.front().data(),
              write_msgs_.front().length()),
            boost::bind(&chat_session::handle_write, shared_from_this(),
              boost::asio::placeholders::error));
      }
    }
    else
    {
      room_.leave(shared_from_this());
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0xc512
movq 0x68(%rbx), %r14
addq $0x8, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc5e4
movups (%r15), %xmm0
leaq 0x50(%rsp), %r15
movups %xmm0, -0x8(%r15)
leaq 0x20(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rbx)
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0xd91e
movq %r14, %rdi
movq %rax, %rsi
callq 0xd99c
movq %r15, %rdi
callq 0xc016
movq %rbx, %rdi
jmp 0xc5a0
leaq 0x280(%rbx), %rdi
callq 0xd8ca
movq 0x290(%rbx), %rax
cmpq %rax, 0x2b0(%rbx)
je 0xc5a5
movq 0x208(%rax), %rcx
addq $0x4, %rcx
movq %rax, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc5e4
leaq -0xb5(%rip), %rsi       # 0xc4a6
leaq -0x333(%rip), %r8       # 0xc22f
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc40e
addq $0x18, %rbx
leaq 0x58(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x7(%rsp), %rcx
callq 0xc858
leaq 0x30(%rsp), %rdi
callq 0xc016
leaq 0x10(%rsp), %rdi
callq 0xc016
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xc016
jmp 0xc5c1
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0xc5d6
movq %rax, %r14
movq %r15, %rdi
callq 0xc016
movq %rbx, %rdi
callq 0xc016
movq %r14, %rdi
callq 0x54f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::start()
void start()
  {
    room_.join(shared_from_this());
    boost::asio::async_read(socket_,
        boost::asio::buffer(read_msg_.data(), chat_message::header_length),
        boost::bind(
          &chat_session::handle_read_header, shared_from_this(),
          boost::asio::placeholders::error));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r13
leaq 0x8(%rdi), %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc5e4
movups (%r15), %xmm0
leaq 0x50(%rsp), %r12
movups %xmm0, -0x8(%r12)
leaq 0x20(%rsp), %r15
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%r15)
leaq 0x48(%rsp), %rsi
movq %r13, %rdi
callq 0xed82
movq %r12, %rdi
callq 0xc016
movq %r15, %rdi
callq 0xc016
leaq 0x70(%rbx), %rax
movq %rax, 0x38(%rsp)
movq $0x4, 0x40(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc5e4
leaq 0x192(%rip), %rsi       # 0xee88
leaq -0x2ace(%rip), %r8      # 0xc22f
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0xc40e
addq $0x18, %rbx
leaq 0x58(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x7(%rsp), %rcx
callq 0xf20c
leaq 0x30(%rsp), %rdi
callq 0xc016
leaq 0x10(%rsp), %rdi
callq 0xc016
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc016
jmp 0xed60
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xed75
movq %rax, %rbx
movq %r12, %rdi
callq 0xc016
movq %r15, %rdi
callq 0xc016
movq %rbx, %rdi
callq 0x54f0
// File: /workspace/github_cpp_makefile_star2_O1/jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::handle_read_header(boost::system::error_code const&)
void handle_read_header(const boost::system::error_code& error)
  {
    if (!error && read_msg_.decode_header())
    {
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
          boost::bind(&chat_session::handle_read_body, shared_from_this(),
            boost::asio::placeholders::error));
    }
    else
    {
      room_.leave(shared_from_this());
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
jne 0xef1f
leaq 0x70(%rbx), %rdi
callq 0xfcbe
testb %al, %al
je 0xef1f
leaq 0x74(%rbx), %rax
movq 0x278(%rbx), %rcx
movq %rax, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc5e4
leaq 0xe36(%rip), %rsi       # 0xfd0e
leaq -0x2cb0(%rip), %r8      # 0xc22f
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc40e
addq $0x18, %rbx
leaq 0x58(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x7(%rsp), %rcx
callq 0xf20c
leaq 0x30(%rsp), %rdi
callq 0xc016
leaq 0x10(%rsp), %rdi
jmp 0xef74
movq 0x68(%rbx), %r14
addq $0x8, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc5e4
movups (%r15), %xmm0
leaq 0x50(%rsp), %r15
movups %xmm0, -0x8(%r15)
leaq 0x20(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rbx)
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0xd91e
movq %r14, %rdi
movq %rax, %rsi
callq 0xd99c
movq %r15, %rdi
callq 0xc016
movq %rbx, %rdi
callq 0xc016
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xc016
jmp 0xef95
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0xefaa
movq %rax, %r14
movq %r15, %rdi
callq 0xc016
movq %rbx, %rdi
callq 0xc016
movq %r14, %rdi
callq 0x54f0
// File: /workspace/github_cpp_makefile_star2_O1/jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::handle_read_body(boost::system::error_code const&)
void handle_read_body(const boost::system::error_code& error)
  {
    if (!error)
    {
      room_.deliver(read_msg_);
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.data(), chat_message::header_length),
          boost::bind(&chat_session::handle_read_header, shared_from_this(),
            boost::asio::placeholders::error));
    }
    else
    {
      room_.leave(shared_from_this());
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r14
cmpb $0x0, 0x4(%rsi)
je 0xfd77
addq $0x8, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc5e4
movups (%r15), %xmm0
leaq 0x50(%rsp), %r15
movups %xmm0, -0x8(%r15)
leaq 0x20(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rbx)
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0xd91e
movq %r14, %rdi
movq %rax, %rsi
callq 0xd99c
movq %r15, %rdi
callq 0xc016
movq %rbx, %rdi
jmp 0xfdf1
leaq 0x70(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xfe34
movq %r15, 0x38(%rsp)
movq $0x4, 0x40(%rsp)
leaq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc5e4
leaq -0xf24(%rip), %rsi      # 0xee88
leaq -0x3b84(%rip), %r8      # 0xc22f
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc40e
addq $0x18, %rbx
leaq 0x58(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x7(%rsp), %rcx
callq 0xf20c
leaq 0x30(%rsp), %rdi
callq 0xc016
leaq 0x10(%rsp), %rdi
callq 0xc016
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xc016
jmp 0xfe12
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0xfe27
movq %rax, %r14
movq %r15, %rdi
callq 0xc016
movq %rbx, %rdi
callq 0xc016
movq %r14, %rdi
callq 0x54f0
// File: /workspace/github_cpp_makefile_star2_O1/jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_room::deliver(chat_message const&)
void deliver(const chat_message& msg)
  {
    recent_msgs_.push_back(msg);
    while (recent_msgs_.size() > max_recent_msgs)
      recent_msgs_.pop_front();

    std::for_each(participants_.begin(), participants_.end(),
        boost::bind(&chat_participant::deliver, _1, boost::ref(msg)));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rdi), %r15
movq 0x60(%rdi), %rdi
movq $-0x210, %rax           # imm = 0xFDF0
addq 0x70(%r14), %rax
cmpq %rax, %rdi
je 0xfe71
movl $0x210, %edx            # imm = 0x210
movq %rbx, %rsi
callq 0x5280
addq $0x210, 0x60(%r14)      # imm = 0x210
jmp 0xfe7c
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc62e
movabsq $0xf83e0f83e0f83e1, %r12 # imm = 0xF83E0F83E0F83E1
movq 0x78(%r14), %rax
movq %rax, %rcx
subq 0x58(%r14), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
movq 0x50(%r14), %rax
movq 0x60(%r14), %rdx
subq 0x68(%r14), %rdx
sarq $0x4, %rdx
imulq %r12, %rdx
addq %rcx, %rdx
subq 0x40(%r14), %rax
sarq $0x4, %rax
imulq %r12, %rax
addq %rdx, %rax
cmpq $0x65, %rax
jb 0xfed3
movq %r15, %rdi
callq 0xd8ca
jmp 0xfe86
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xfefd
movq 0x20(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq %r15, %rdi
callq 0x5370
movq %rax, %r15
cmpq %r14, %rax
jne 0xfee0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: skip(std::basic_ifstream<char, std::char_traits<char>>&)
void skip(ifstream& jpegfile) {
    char c1, c2;
    jpegfile.read(&c1, 1);
    jpegfile.read(&c2, 1);
    
    unsigned int length = to_num(c1, c2);

    if (debug)
        cout << length << endl;

    jpegfile.seekg(length - 2, ios::cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x1a(%rbp), %r14
movl $0x1, %edx
movq %r14, %rsi
callq 0x2220
leaq -0x19(%rbp), %r15
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movzbl (%r14), %r14d
movzbl (%r15), %eax
shll $0x8, %r14d
orl %eax, %r14d
cmpb $0x1, 0x6d16(%rip)      # 0x91fa
jne 0x251f
movl %r14d, %esi
movq 0x6ae0(%rip), %rdi      # 0x8fd0
callq 0x2110
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
addl $-0x2, %r14d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2250
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: process_SOI(std::basic_ifstream<char, std::char_traits<char>>&)
bool process_SOI(ifstream& jpegfile) {
    char c1, c2;
    jpegfile.read(&c1, 1);
    jpegfile.read(&c2, 1);

    /* test file format is jpeg */
    if (to_uint(c1) == TAG && to_uint(c2) == SOI) {
        if (debug)
            cout << "[SOI]" << endl;
        return 0;
    } else {
        cout << "[Error] invalid file format." << endl;
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x1a(%rbp), %r14
movl $0x1, %edx
movq %r14, %rsi
callq 0x2220
leaq -0x19(%rbp), %r15
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movb (%r14), %al
notb %al
movb (%r15), %cl
xorb $-0x28, %cl
orb %al, %cl
setne %bl
je 0x29dd
movq 0x6601(%rip), %rdi      # 0x8fd0
leaq 0x3700(%rip), %rsi      # 0x60d6
movl $0x1c, %edx
jmp 0x29f9
cmpb $0x1, 0x6816(%rip)      # 0x91fa
jne 0x2a2c
movq 0x65e3(%rip), %rdi      # 0x8fd0
leaq 0x36dc(%rip), %rsi      # 0x60d0
movl $0x5, %edx
callq 0x2210
movq 0x65cb(%rip), %r14      # 0x8fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: init_qtable()
qtable_t init_qtable() {
    qtable_t qtable = new uint8_t*[4];
    for (int i = 0; i < 4; i++) {
        qtable[i] = new uint8_t[64];
    }
    return qtable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x20, %edi
callq 0x2030
movq %rax, %rbx
xorl %r14d, %r14d
movl $0x40, %edi
callq 0x2030
movq %rax, (%rbx,%r14,8)
incq %r14
cmpq $0x4, %r14
jne 0x2a50
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: print_DQT(unsigned char**)
void print_DQT(qtable_t qtable) {
    cout << "[Quantization Table]" << endl;
    int rows = 8, cols = 8;
    
    for (int i = 0; i < 4; i++) {
        cout << "  qid = " << i << endl;
        
        for (int r = 0; r < rows; r++) {
            cout << "    ";
            
            for (int c = 0; c < cols; c++) {
                printf("%2d ", (int)qtable[i][r * cols + c]);
            }
            cout << endl;
        }
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x6549(%rip), %rbx      # 0x8fd0
leaq 0x3665(%rip), %rsi      # 0x60f3
movl $0x14, %edx
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
leaq 0x364d(%rip), %r13      # 0x6116
xorl %r15d, %r15d
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x362d(%rip), %rsi      # 0x6108
callq 0x2210
movq %rbx, %rdi
movl %r15d, %esi
callq 0x22e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
xorl %r12d, %r12d
xorl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x35e4(%rip), %rsi      # 0x6111
callq 0x2210
xorl %ebx, %ebx
movq (%r14,%r15,8), %rax
addq %r12, %rax
movzbl (%rbx,%rax), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
incq %rbx
cmpq $0x8, %rbx
jne 0x2b34
movq 0x6477(%rip), %rbx      # 0x8fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movq -0x30(%rbp), %rax
incq %rax
addq $0x8, %r12
cmpq $0x8, %rax
jne 0x2b1a
incq %r15
cmpq $0x4, %r15
jne 0x2acc
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: process_DQT(std::basic_ifstream<char, std::char_traits<char>>&, unsigned char**)
bool process_DQT(ifstream& jpegfile, qtable_t qtable) {
    unsigned int pointer = 0;
    char c1, c2;

    /* DQT Length */
    jpegfile.read(&c1, 1); pointer++;
    jpegfile.read(&c2, 1); pointer++;

    unsigned int len = to_num(c1, c2);

    if (debug)
        cout << "[DQT] len = " << len << endl;

    /* Fill in Quantization Table */
    while (pointer < len) {
        char c;
        jpegfile.read(&c, 1); pointer += 1;

        c = to_uint(c);
        unsigned int precision = c >> 4;
        unsigned int qid = c & 0x0F;

        for (int i = 0; i < 64; i++) {
            jpegfile.read(&c, 1); pointer += 1;
            qtable[qid][i] = (uint8_t)to_uint(c);
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x2b(%rbp), %r15
movl $0x1, %edx
movq %r15, %rsi
callq 0x2220
leaq -0x2a(%rbp), %r12
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2220
movzbl (%r15), %r13d
movzbl (%r12), %eax
shll $0x8, %r13d
orl %eax, %r13d
cmpb $0x1, 0x65d4(%rip)      # 0x91fa
jne 0x2c78
movq 0x63a1(%rip), %r15      # 0x8fd0
leaq 0x34e5(%rip), %rsi      # 0x611b
movl $0xc, %edx
movq %r15, %rdi
callq 0x2210
movl %r13d, %esi
movq %r15, %rdi
callq 0x2110
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
cmpl $0x3, %r13d
jb 0x2cdd
movl $0x2, %eax
leaq -0x29(%rbp), %r15
movl %r13d, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movzbl -0x29(%rbp), %r13d
andl $0xf, %r13d
xorl %r12d, %r12d
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movb -0x29(%rbp), %al
movq (%rbx,%r13,8), %rcx
movb %al, (%rcx,%r12)
incq %r12
cmpq $0x40, %r12
jne 0x2caa
movl -0x34(%rbp), %eax
addl $0x41, %eax
movl -0x30(%rbp), %r13d
cmpl %r13d, %eax
jb 0x2c8b
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: print_DHT(std::map<std::pair<unsigned char, unsigned short>, unsigned char, std::less<std::pair<unsigned char, unsigned short>>, std::allocator<std::pair<std::pair<unsigned char, unsigned short> const, unsigned char>>>*)
void print_DHT(htable_t* htable) {
    cout << "[Huffman Table]" << endl;
    
    for (unsigned int i = 0; i < 4; i++) {
        cout << "  hid = " << i << endl;
        htable_t::iterator iter;

        for (htable_t::iterator iter = htable[i].begin(); iter != htable[i].end(); iter++) {
            uint8_t length = iter->first.first;
            uint16_t symbol = iter->first.second;
            uint8_t code = iter->second;
            printf("    length = %2d, symbol = %04X, code = %02X\n", length, symbol, code);
        }
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movq 0x5dde(%rip), %rbx      # 0x8fd0
leaq 0x2f9a(%rip), %rsi      # 0x6193
movl $0xf, %edx
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
leaq 0x2f78(%rip), %r12      # 0x61ac
xorl %r13d, %r13d
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x2f5d(%rip), %rsi      # 0x61a3
callq 0x2210
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2110
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
leaq (,%r13,2), %rax
addq %r13, %rax
shlq $0x4, %rax
movq -0x30(%rbp), %rcx
leaq (%rcx,%rax), %r14
addq $0x8, %r14
movq 0x10(%r14), %r15
cmpq %r14, %r15
je 0x32cd
movzbl 0x20(%r15), %esi
movzwl 0x22(%r15), %edx
movzbl 0x24(%r15), %ecx
movq %r12, %rdi
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
cmpq %r14, %rax
jne 0x32a4
incq %r13
cmpq $0x4, %r13
jne 0x3237
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: init_image(int, int, int)
image_t init_image(int d1, int d2, int d3) {
    image_t image = new int16_t**[d1];

    for (int i = 0; i < d1; i++) {
        image[i] = new int16_t*[d2];

        for (int j = 0; j < d2; j++) {
            image[i][j] = new int16_t[d3];
        }
    }

    return image;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r12d
movl %esi, -0x2c(%rbp)
movl %edi, %r13d
movslq %edi, %r14
leaq (,%r14,8), %rdi
testl %r14d, %r14d
movq $-0x1, %rbx
cmovsq %rbx, %rdi
callq 0x2030
movq %rax, -0x38(%rbp)
testl %r14d, %r14d
jle 0x39e7
movslq -0x2c(%rbp), %rax
leaq (,%rax,8), %rcx
testl %eax, %eax
cmovsq %rbx, %rcx
movq %rcx, -0x48(%rbp)
movslq %r12d, %rcx
leaq (%rcx,%rcx), %r12
testl %ecx, %ecx
cmovsq %rbx, %r12
movl %r13d, %ecx
movq %rcx, -0x40(%rbp)
movl %eax, %r14d
xorl %r15d, %r15d
movq -0x48(%rbp), %rdi
callq 0x2030
movq %rax, %r13
movq -0x38(%rbp), %rax
movq %r13, (%rax,%r15,8)
cmpl $0x0, -0x2c(%rbp)
jle 0x39de
xorl %ebx, %ebx
movq %r12, %rdi
callq 0x2030
movq %rax, (%r13,%rbx,8)
incq %rbx
cmpq %rbx, %r14
jne 0x39c9
incq %r15
cmpq -0x40(%rbp), %r15
jne 0x39ad
movq -0x38(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: delete_image(short***, int, int, int)
void delete_image(image_t image, int d1, int d2, int d3) {
    for (int i = 0; i < d1; i++) {
        for (int j = 0; j < d2; j++) {
            delete[] image[i][j];
        }
        delete[] image[i];
    }
    delete[] image;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, -0x2c(%rbp)
movq %rdi, %rbx
testl %esi, %esi
jle 0x3a55
movl %esi, %r15d
movl -0x2c(%rbp), %r12d
xorl %r13d, %r13d
cmpl $0x0, -0x2c(%rbp)
jle 0x3a3f
xorl %r14d, %r14d
movq (%rbx,%r13,8), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x3a37
callq 0x2230
incq %r14
cmpq %r14, %r12
jne 0x3a25
movq (%rbx,%r13,8), %rdi
testq %rdi, %rdi
je 0x3a4d
callq 0x2230
incq %r13
cmpq %r15, %r13
jne 0x3a1c
testq %rbx, %rbx
je 0x3a70
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2230
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: to_bitmap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, short***, sof&)
void to_bitmap(string filename, image_t rgb, sof_t& sof){
    bitmap_image bmp(sof.X, sof.Y);

    for (unsigned int py = 0; py < sof.Y; py++) {
        for (unsigned int px = 0; px < sof.X; px++) {
            bmp.set_pixel(
                px, py,
                (uint8_t)rgb[R][py][px],
                (uint8_t)rgb[G][py][px],
                (uint8_t)rgb[B][py][px]
            );
        }
    }

    size_t dot_i = filename.find_last_of(".");
    bmp.save_image(filename.substr(0, dot_i) + ".bmp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rdx), %edx
movl 0x8(%r14), %esi
leaq -0xa8(%rbp), %rdi
callq 0x4ee8
cmpl $0x0, 0x4(%r14)
je 0x3b2f
xorl %eax, %eax
cmpl $0x0, 0x8(%r14)
je 0x3b23
xorl %ecx, %ecx
movq (%r15), %rdx
movq 0x8(%r15), %rsi
movq (%rdx,%rax,8), %rdx
movb (%rdx,%rcx,2), %dl
movq (%rsi,%rax,8), %rsi
movb (%rsi,%rcx,2), %sil
movq 0x10(%r15), %rdi
movq (%rdi,%rax,8), %rdi
movb (%rdi,%rcx,2), %dil
movl -0x80(%rbp), %r8d
imull %eax, %r8d
movl -0x7c(%rbp), %r9d
imull %ecx, %r9d
leal (%r9,%r8), %r10d
movq -0x70(%rbp), %r11
movb %dil, (%r11,%r10)
leal (%r9,%r8), %edi
incl %edi
movq -0x70(%rbp), %r10
movb %sil, (%r10,%rdi)
leal (%r9,%r8), %esi
addl $0x2, %esi
movq -0x70(%rbp), %rdi
movb %dl, (%rdi,%rsi)
incq %rcx
movl 0x8(%r14), %edx
cmpq %rdx, %rcx
jb 0x3abd
incq %rax
movl 0x4(%r14), %ecx
cmpq %rcx, %rax
jb 0x3ab4
leaq 0x276b(%rip), %rsi      # 0x62a1
movl $0x1, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x2320
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21d0
leaq 0x26d6(%rip), %rsi      # 0x6238
leaq -0x58(%rbp), %rdi
callq 0x2310
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3b8f
movq %rdx, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x3b96
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0xa8(%rbp), %rdi
callq 0x4f86
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x3bcb
callq 0x21a0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bdd
callq 0x21a0
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x3beb
callq 0x21a0
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c00
callq 0x21a0
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x3c24
callq 0x21a0
jmp 0x3c24
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c3b
callq 0x21a0
jmp 0x3c3b
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x52b0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: process_EOI(bool&)
bool process_EOI(bool &eoi) {
    if (debug)
        cout << "[EOI]" << endl;
    eoi = true;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x47e3(%rip)      # 0x91fa
jne 0x4a5b
movq 0x45b0(%rip), %r14      # 0x8fd0
leaq 0x18af(%rip), %rsi      # 0x62d6
movl $0x5, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movb $0x1, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq