LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2130
movsd 0x70(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x70(%rbx)
testl %ebp, %ebp
je 0x6a6b
movl %ebp, %eax
cvtsi2sd %rax, %xmm0
subsd 0x40(%rbx), %xmm0
callq 0x2130
jmp 0x6a99
movsd 0x40(%rbx), %xmm0
callq 0x2130
movsd %xmm0, (%rsp)
movsd 0x48(%rbx), %xmm1
divsd 0x40(%rbx), %xmm1
movl (%rbx), %eax
cvtsi2sd %rax, %xmm0
addsd %xmm1, %xmm0
callq 0x2130
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_O2/redpony[P]cpyp/./cpyp/crp_table_manager.h
// Function: cpyp::crp_table_manager<1u>::create_table(unsigned int)
inline void create_table(const unsigned floor = 0) {
    assert(floor < NumFloors);
    h[floor].increment(1);
    ++tables;
    ++customers;
  }

// Assembly:
pushq %rbx
testl %esi, %esi
jne 0x6ad2
movq %rdi, %rbx
addq $0x8, %rdi
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x6990
movq (%rbx), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movq %xmm0, (%rbx)
popq %rbx
retq
leaq 0x2e31(%rip), %rdi      # 0x990a
leaq 0x2e3c(%rip), %rsi      # 0x991c
leaq 0x2e50(%rip), %rcx      # 0x9937
pushq $0x43
popq %rdx
callq 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7366
ucomisd 0x1d78(%rip), %xmm1     # 0x9010
jae 0x7366
movq %rdi, %r14
leaq 0x48(%rdi), %r15
movsd 0x48(%rdi), %xmm0
xorpd 0x1e0e(%rip), %xmm1     # 0x90c0
ucomisd %xmm0, %xmm1
jae 0x7387
callq 0x2110
movsd %xmm0, (%rsp)
movsd 0x48(%r14), %xmm0
divsd 0x40(%r14), %xmm0
callq 0x2110
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x70(%r14)
movsd 0x50(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x7308
leaq 0x50(%r14), %rsi
leaq 0x58(%r14), %rdx
movq %rbx, %rdi
callq 0x55ae
movsd %xmm0, 0x70(%r14)
movsd 0x60(%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x7342
movsd 0x48(%r14), %xmm0
addsd 0x40(%r14), %xmm0
leaq 0x60(%r14), %rsi
leaq 0x8(%rsp), %rdi
movsd %xmm0, (%rdi)
leaq 0x68(%r14), %rdx
callq 0x56f0
addsd 0x70(%r14), %xmm0
movsd %xmm0, 0x70(%r14)
cmpl $0x0, (%r14)
je 0x735c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x73de
movsd %xmm0, 0x70(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x6c83(%rip), %rdi      # 0xdff0
leaq 0x23eb(%rip), %rsi      # 0x975f
callq 0x2170
movsd (%rbx), %xmm0
movq %rax, %rdi
callq 0x2270
jmp 0x73d1
movq 0x6c62(%rip), %rdi      # 0xdff0
leaq 0x23d9(%rip), %rsi      # 0x976e
callq 0x2170
movsd (%r15), %xmm0
movq %rax, %rdi
callq 0x2270
leaq 0x23cf(%rip), %rsi      # 0x977d
movq %rax, %rdi
callq 0x2170
movsd (%rbx), %xmm0
movq %rax, %rdi
callq 0x2270
leaq 0x2059(%rip), %rsi      # 0x9422
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x2080
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x105f(%rip), %xmm0     # 0x9080
callq 0x2130
addsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x70(%rbx)
testl %ebp, %ebp
je 0x809c
cmpl $0x1, %ebp
jne 0x8075
movsd 0x40(%rbx), %xmm0
callq 0x2130
movsd 0x48(%rbx), %xmm2
divsd 0x40(%rbx), %xmm2
movl (%rbx), %eax
cvtsi2sd %rax, %xmm1
movsd %xmm0, (%rsp)
addsd %xmm2, %xmm1
addsd 0x101b(%rip), %xmm1     # 0x9080
movapd %xmm1, %xmm0
callq 0x2130
addsd (%rsp), %xmm0
jmp 0x808e
movl %ebp, %eax
cvtsi2sd %rax, %xmm0
subsd 0x40(%rbx), %xmm0
addsd 0xff7(%rip), %xmm0      # 0x9080
callq 0x2130
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_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x17e3(%rip), %rsi      # 0x9b67
movq %rbx, %rdi
callq 0x2170
movsd 0x40(%r14), %xmm0
movq %rax, %rdi
callq 0x2200
leaq 0x17cd(%rip), %rsi      # 0x9b6e
movq %rax, %rdi
callq 0x2170
movsd 0x48(%r14), %xmm0
movq %rax, %rdi
callq 0x2200
leaq 0x17b4(%rip), %rsi      # 0x9b72
movq %rax, %rdi
callq 0x2170
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x2080
addq $0x18, %r14
leaq 0x179a(%rip), %r15      # 0x9b7f
movq (%r14), %r14
testq %r14, %r14
je 0x841a
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x8420
movq %rax, %rdi
callq 0x2080
jmp 0x83e5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/test/src/arguments.cpp
// Function: main
int main()
{
	cout << '\n';
	
	int ret_val = 0; // also used to count the number of failed tests

	vector<bool (*)()> tests = { test1, test2, test3, test4 };

	for (uint32_t i = 0; i < tests.size(); ++i)
	{
		cout << "Arguments Test #" << i + 1 << ":\t";
		if (tests[i]())
		{
			cout << "OK";
		}
		else
		{
			++ret_val;
			cout << "FAIL";
		}
		cout << '\n';

		optind = 1; // reset optind for next use of global getopt
	}
	
	string pass_or_fail_color = ret_val ? "\033[0;31m" : "\033[0;32m";
	cout << "\033[0;34mArguments Passed:\t" << pass_or_fail_color << tests.size() - ret_val << " / " << tests.size() << "\033[0m" << endl;
	
	return ret_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x8af7(%rip), %r14      # 0xafb8
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x2210
movups 0x87ad(%rip), %xmm0     # 0xac80
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0x878d(%rip), %xmm0     # 0xac70
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x2d34
xorl %ebx, %ebx
pushq $0x1
popq %r13
leaq 0x3b3f(%rip), %r12      # 0x6044
movq 0x8abc(%rip), %rbp      # 0xafc8
leal -0x1(%r13), %r15d
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x2591
movq %r14, %rdi
leaq 0x3ad7(%rip), %rsi      # 0x6004
callq 0x21b0
movl %r13d, %esi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
movq 0x8(%rsp), %rax
callq *(%rax,%r15,8)
testb %al, %al
je 0x2566
movq %r14, %rdi
leaq 0x3ab6(%rip), %rsi      # 0x6015
callq 0x21b0
jmp 0x2577
movq %r14, %rdi
leaq 0x3aa8(%rip), %rsi      # 0x6018
callq 0x21b0
incl %ebx
movq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x2210
movl $0x1, (%rbp)
incl %r13d
jmp 0x250c
testl %ebx, %ebx
leaq 0x3a8b(%rip), %rax      # 0x6025
leaq 0x3a7c(%rip), %rsi      # 0x601d
cmoveq %rax, %rsi
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2d6a
movq 0x89fd(%rip), %rdi      # 0xafb8
leaq 0x3a6b(%rip), %rsi      # 0x602d
callq 0x21b0
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x21a0
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
sarq $0x3, %rsi
movslq %ebx, %rcx
subq %rcx, %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x3a50(%rip), %rsi      # 0x6047
movq %rax, %rdi
callq 0x21b0
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x4a27(%rip), %rsi      # 0x7043
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x2368
leaq 0x8(%rsp), %rdi
callq 0x2e16
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2662
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2368
jmp 0x2665
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2e16
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x8629(%rip), %rax      # 0xacb0
movq %rax, 0x40(%rsp)
movaps 0x860d(%rip), %xmm0     # 0xaca0
movaps %xmm0, 0x30(%rsp)
movaps 0x85f1(%rip), %xmm0     # 0xac90
movaps %xmm0, 0x20(%rsp)
movl $0xf0, %edi
callq 0x21c0
movq %rax, %r14
pushq $0x5
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rax, %rdi
callq 0x2f4a
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3cec
leaq 0x3981(%rip), %rsi      # 0x6054
movq %rsp, %rdi
callq 0x2da5
movl %eax, %ebx
movq %rsp, %rdi
callq 0x2368
testb %bl, %bl
jne 0x2711
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3cfe
leaq 0x3970(%rip), %rsi      # 0x606b
movq %rsp, %rdi
callq 0x2da5
movl %eax, %ebx
movq %rsp, %rdi
callq 0x2368
testb %bl, %bl
je 0x2715
xorl %eax, %eax
jmp 0x272c
movq %r14, %rdi
callq 0x3b16
movl $0xf0, %esi
movq %r14, %rdi
callq 0x21d0
movb $0x1, %al
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x273a
jmp 0x2761
movq %rdx, %r15
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2368
jmp 0x2767
jmp 0x2761
movq %rdx, %r15
movq %rax, %rbx
movl $0xf0, %esi
movq %r14, %rdi
callq 0x21d0
jmp 0x2767
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x2, %r15d
jne 0x27af
movq %rbx, %rdi
callq 0x2220
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x20b0
movq 0x8857(%rip), %rdi      # 0xafe8
leaq 0x20(%rsp), %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x2368
jmp 0x27d4
cmpl $0x1, %r15d
jne 0x27fa
movq %rbx, %rdi
callq 0x20b0
movq 0x8824(%rip), %rdi      # 0xafe8
movq %rax, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
callq 0x22d0
jmp 0x2711
movq %rax, %rbx
callq 0x22d0
jmp 0x27fa
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2368
callq 0x22d0
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x2daf
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x385f(%rip), %rax      # 0x6079
movq %rax, 0x28(%rsp)
movl $0xf0, %edi
callq 0x21c0
movq %rax, %r14
pushq $0x1
popq %rsi
leaq 0x28(%rsp), %rdx
movq %rax, %rdi
callq 0x2f4a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3cec
leaq 0x382f(%rip), %rsi      # 0x607f
leaq 0x8(%rsp), %rdi
callq 0x2da5
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2368
testb %bl, %bl
jne 0x2898
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3cfe
leaq 0x380c(%rip), %rsi      # 0x608a
leaq 0x8(%rsp), %rdi
callq 0x2da5
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x2368
testb %bl, %bl
je 0x289c
xorl %eax, %eax
jmp 0x28b3
movq %r14, %rdi
callq 0x3b16
movl $0xf0, %esi
movq %r14, %rdi
callq 0x21d0
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x28c1
jmp 0x28ea
movq %rdx, %r15
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2368
jmp 0x28f0
jmp 0x28ea
movq %rdx, %r15
movq %rax, %rbx
movl $0xf0, %esi
movq %r14, %rdi
callq 0x21d0
jmp 0x28f0
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x2, %r15d
jne 0x2938
movq %rbx, %rdi
callq 0x2220
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x20b0
movq 0x86ce(%rip), %rdi      # 0xafe8
leaq 0x8(%rsp), %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
leaq 0x8(%rsp), %rdi
callq 0x2368
jmp 0x295d
cmpl $0x1, %r15d
jne 0x2983
movq %rbx, %rdi
callq 0x20b0
movq 0x869b(%rip), %rdi      # 0xafe8
movq %rax, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
callq 0x22d0
jmp 0x2898
movq %rax, %rbx
callq 0x22d0
jmp 0x2983
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2368
callq 0x22d0
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x2daf
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/test/src/arguments.cpp
// Function: test3()
bool test3()
{
	try
	{
		int argc = 7;
		char* argv[] = {
			(char*)("test3"),
			(char*)("-i"),
			(char*)("example/input.fasta"),
			(char*)("-o"),
			(char*)("test/arg3.tsv"),
			(char*)("-p"),
			(char*)("1-7,18")
		};
		
		Arguments* args = new Arguments(argc, argv);

		if (args->getInFileName() != "example/input.fasta")
		{
			return false;
		}
		if (args->getOutFileName() != "test/arg3.tsv")
		{
			return false;
		}
		if (!args->inPeriods(18))
		{
			return false;
		}
		for (uint32_t p = 1; p < 8; ++p)
		{
			if (!args->inPeriods(p))
			{
				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 $0x58, %rsp
movq 0x834c(%rip), %rax      # 0xacf0
movq %rax, 0x50(%rsp)
movaps 0x8330(%rip), %xmm0     # 0xace0
movaps %xmm0, 0x40(%rsp)
movaps 0x8314(%rip), %xmm0     # 0xacd0
movaps %xmm0, 0x30(%rsp)
movaps 0x82f8(%rip), %xmm0     # 0xacc0
movaps %xmm0, 0x20(%rsp)
movl $0xf0, %edi
callq 0x21c0
movq %rax, %rbx
pushq $0x7
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rax, %rdi
callq 0x2f4a
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3cec
leaq 0x3658(%rip), %rsi      # 0x6054
movq %rsp, %rdi
callq 0x2da5
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2368
testb %bpl, %bpl
jne 0x2a63
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3cfe
leaq 0x3677(%rip), %rsi      # 0x609c
movq %rsp, %rdi
callq 0x2da5
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2368
testb %bpl, %bpl
jne 0x2a63
pushq $0x12
popq %rsi
movq %rbx, %rdi
callq 0x3cc4
testb %al, %al
je 0x2a63
pushq $0x1
popq %rbp
cmpl $0x8, %ebp
je 0x2a70
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3cc4
incl %ebp
testb %al, %al
jne 0x2a4e
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x3b16
movl $0xf0, %esi
movq %rbx, %rdi
callq 0x21d0
movb $0x1, %al
jmp 0x2a65
jmp 0x2a8d
jmp 0x2ab6
movq %rdx, %r15
movq %rax, %r14
movq %rsp, %rdi
callq 0x2368
jmp 0x2abc
jmp 0x2ab6
movq %rdx, %r15
movq %rax, %r14
movl $0xf0, %esi
movq %rbx, %rdi
callq 0x21d0
jmp 0x2abc
jmp 0x2ab6
movq %rdx, %r15
movq %rax, %r14
cmpl $0x2, %r15d
jne 0x2b04
movq %r14, %rdi
callq 0x2220
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20b0
movq 0x8502(%rip), %rdi      # 0xafe8
leaq 0x20(%rsp), %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x2368
jmp 0x2b29
cmpl $0x1, %r15d
jne 0x2b4f
movq %r14, %rdi
callq 0x20b0
movq 0x84cf(%rip), %rdi      # 0xafe8
movq %rax, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
callq 0x22d0
jmp 0x2a63
movq %rax, %r14
callq 0x22d0
jmp 0x2b4f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2368
callq 0x22d0
movq %r14, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x2daf
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/test/src/arguments.cpp
// Function: test4()
bool test4()
{
	try
	{
		int argc = 13;
		char* argv[] = {
			(char*)("test4"),
			(char*)("-i"),
			(char*)("example/input.fasta"),
			(char*)("-o"),
			(char*)("test/arg4.tsv"),
			(char*)("-n"),
			(char*)("5"),
			(char*)("-N"),
			(char*)("18"),
			(char*)("-r"),
			(char*)("4"),
			(char*)("-R"),
			(char*)("8")
		};
		
		Arguments* args = new Arguments(argc, argv);

		if (args->getInFileName() != "example/input.fasta")
		{
			return false;
		}
		if (args->getOutFileName() != "test/arg4.tsv")
		{
			return false;
		}
		if (args->getMinNucleotideLength() != 5)
		{
			return false;
		}
		if (args->getMaxNucleotideLength() != 18)
		{
			return false;
		}
		if (args->getMinRepeats() != 4)
		{
			return false;
		}
		if (args->getMaxRepeats() != 8)
		{
			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 $0x88, %rsp
leaq 0x818d(%rip), %rsi      # 0xad00
pushq $0xd
popq %rcx
leaq 0x20(%rsp), %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0xf0, %edi
callq 0x21c0
movq %rax, %rbx
pushq $0xd
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rax, %rdi
callq 0x2f4a
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3cec
leaq 0x34a7(%rip), %rsi      # 0x6054
movq %rsp, %rdi
callq 0x2da5
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2368
testb %bpl, %bpl
jne 0x2cf8
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3cfe
leaq 0x34e0(%rip), %rsi      # 0x60ba
movq %rsp, %rdi
callq 0x2da5
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2368
testb %bpl, %bpl
jne 0x2cf8
movq %rbx, %rdi
callq 0x3bfe
cmpl $0x5, %eax
jne 0x2cf8
movq %rbx, %rdi
callq 0x3c06
cmpl $0x12, %eax
jne 0x2cf8
movq %rbx, %rdi
callq 0x3c0e
cmpl $0x4, %eax
jne 0x2cf8
movq %rbx, %rdi
callq 0x3c16
cmpl $0x8, %eax
jne 0x2cf8
movq %rbx, %rdi
callq 0x3b16
movl $0xf0, %esi
movq %rbx, %rdi
callq 0x21d0
movb $0x1, %al
jmp 0x2cfa
jmp 0x2c59
jmp 0x2c80
movq %rdx, %r15
movq %rax, %r14
movq %rsp, %rdi
callq 0x2368
jmp 0x2c86
jmp 0x2c80
movq %rdx, %r15
movq %rax, %r14
movl $0xf0, %esi
movq %rbx, %rdi
callq 0x21d0
jmp 0x2c86
movq %rdx, %r15
movq %rax, %r14
cmpl $0x2, %r15d
jne 0x2cce
movq %r14, %rdi
callq 0x2220
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20b0
movq 0x8338(%rip), %rdi      # 0xafe8
leaq 0x20(%rsp), %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x2368
jmp 0x2cf3
cmpl $0x1, %r15d
jne 0x2d24
movq %r14, %rdi
callq 0x20b0
movq 0x8305(%rip), %rdi      # 0xafe8
movq %rax, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
callq 0x22d0
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
callq 0x22d0
jmp 0x2d24
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2368
callq 0x22d0
movq %r14, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x2daf
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
callq 0x2170
leaq 0x20(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x20c0
movabsq $0x3ff0000000000000, %r13 # imm = 0x3FF0000000000000
leaq 0x20(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x40(%rsp,%rax)
jne 0x24cf
movq %r13, 0x18(%rsp)
testl %ebp, %ebp
je 0x2408
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
jmp 0x242b
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
movq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x20d0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x23d3
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %edx
cmpl %edx, %edi
movl %edx, %esi
cmoval %edi, %esi
incl %esi
cmpq %rsi, %rax
ja 0x2476
movq %rbx, %rdi
callq 0x2b92
movl 0xc(%rsp), %edi
movq (%rbx), %rcx
movl 0x8(%rsp), %edx
movl %edi, %eax
imulq $0x18, %rax, %rdi
addq %rcx, %rdi
movl %edx, 0x10(%rsp)
cvtsd2ss 0x18(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x3004
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
cmpl %ecx, %eax
je 0x23d3
imulq $0x18, %rcx, %rdi
addq (%rbx), %rdi
movl %eax, 0x10(%rsp)
cvtsd2ss 0x18(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x3004
jmp 0x23d3
leaq 0x20(%rsp), %rdi
callq 0x2050
leaq 0x20(%rsp), %rdi
callq 0x2060
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2502
jmp 0x2502
movq %rax, %r14
jmp 0x250f
jmp 0x2502
jmp 0x2502
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2bc8
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/siolag161[P]louvain-original/graph.cpp
// Function: Graph::renumber(int)
void
Graph::renumber(int type) {
  vector<int> linked(links.size(),-1);
  vector<int> renum(links.size(),-1);
  int nb=0;
  
  for (unsigned int i=0 ; i<links.size() ; i++) {
    for (unsigned int j=0 ; j<links[i].size() ; j++) {
      linked[i]=1;
      linked[links[i][j].first]=1;
    }
  }
  
  for (unsigned int i=0 ; i<links.size() ; i++) {
    if (linked[i]==1)
      renum[i]=nb++;
  }

  for (unsigned int i=0 ; i<links.size() ; i++) {
    if (linked[i]==1) {
      for (unsigned int j=0 ; j<links[i].size() ; j++) {
	links[i][j].first = renum[links[i][j].first];
      }
      links[renum[i]]=links[i];
    }
  }
  links.resize(nb);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x18
popq %r15
cqto
idivq %r15
leaq 0x8(%rsp), %rdx
orl $-0x1, (%rdx)
leaq 0x20(%rsp), %rdi
leaq 0x4(%rsp), %r14
movq %rax, %rsi
movq %r14, %rcx
callq 0x2bea
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r15
orl $-0x1, (%r14)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
leaq 0x3(%rsp), %rcx
movq %rax, %rsi
callq 0x2bea
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
movq %rcx, %rax
subq %rdi, %rax
cqto
idivq %r15
xorl %edx, %edx
pushq $0x1
popq %rsi
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x25d8
imulq $0x18, %rdx, %r9
movq (%rdi,%r9), %r8
movq 0x8(%rdi,%r9), %r9
subq %r8, %r9
sarq $0x3, %r9
xorl %r11d, %r11d
movq 0x20(%rsp), %r10
movl %r11d, %r11d
cmpq %r11, %r9
jbe 0x25d4
movl %esi, (%r10,%rdx,4)
movslq (%r8,%r11,8), %r14
movl %esi, (%r10,%r14,4)
incl %r11d
jmp 0x25bb
incl %edx
jmp 0x2598
movq 0x20(%rsp), %rdx
xorl %ebp, %ebp
movq 0x8(%rsp), %rsi
xorl %r8d, %r8d
movl %r8d, %r8d
cmpq %r8, %rax
jbe 0x2601
cmpl $0x1, (%rdx,%r8,4)
jne 0x25fc
movl %ebp, (%rsi,%r8,4)
incl %ebp
incl %r8d
jmp 0x25e7
xorl %r14d, %r14d
movl %r14d, %r14d
movq %rcx, %rax
subq %rdi, %rax
cqto
idivq %r15
cmpq %r14, %rax
jbe 0x267d
movq 0x20(%rsp), %rax
cmpl $0x1, (%rax,%r14,4)
jne 0x2678
imulq $0x18, %r14, %rcx
leaq (%rdi,%rcx), %rsi
movq (%rdi,%rcx), %rax
movq 0x8(%rdi,%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %r8d, %r8d
movq 0x8(%rsp), %rdx
movl %r8d, %r8d
cmpq %r8, %rcx
jbe 0x265c
movslq (%rax,%r8,8), %r9
movl (%rdx,%r9,4), %r9d
movl %r9d, (%rax,%r8,8)
incl %r8d
jmp 0x2643
movq 0x8(%rsp), %rax
movslq (%rax,%r14,4), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x2c40
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
incl %r14d
jmp 0x2604
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x2b92
leaq 0x8(%rsp), %rdi
callq 0x31c4
leaq 0x20(%rsp), %rdi
callq 0x31c4
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26ae
movq %rax, %rbx
jmp 0x26bb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x31c4
leaq 0x20(%rsp), %rdi
callq 0x31c4
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH07_Classes/examples/avg_price.cc
// Function: main
int main()
{
	Sales_data total;         // variable to hold the running sum
	if (read(cin, total))  {  // read the first transaction
		Sales_data trans;     // variable to hold data for the next transaction
		while(read(cin, trans)) {      // read the remaining transactions
			if (total.isbn() == trans.isbn())   // check the isbns
				total.combine(trans);  // update the running total
			else {
				print(cout, total) << endl;  // print the results
				total = trans;               // process the next book
			}
		}
		print(cout, total) << endl;          // print the last transaction
	} else {                                 // there was no input
		cerr << "No data?!" << endl;         // notify the user
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x2d18(%rip), %rdi      # 0x3fd8
leaq -0x58(%rbp), %rsi
callq 0x14ce
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x12f7
movq 0x2d12(%rip), %rdi      # 0x3ff0
leaq 0xd1f(%rip), %rsi       # 0x2004
callq 0x10b0
movq %rax, %rdi
callq 0x1050
jmp 0x13d5
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq -0x88(%rbp), %r14
leaq -0xa8(%rbp), %r15
leaq -0x58(%rbp), %r12
leaq -0xc8(%rbp), %r13
movq 0x2ca8(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
callq 0x14ce
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x13b1
movq %r15, %rdi
movq %r12, %rsi
callq 0x10d0
movq %r13, %rdi
movq %r14, %rsi
callq 0x10d0
movq %r15, %rdi
movq %r13, %rsi
callq 0x142c
movl %eax, %ebx
movq %r13, %rdi
callq 0x1040
movq %r15, %rdi
callq 0x1040
testb %bl, %bl
je 0x138a
movq %r12, %rdi
movq %r14, %rsi
callq 0x1542
jmp 0x1329
movq 0x2c37(%rip), %rdi      # 0x3fc8
movq %r12, %rsi
callq 0x1592
movq %rax, %rdi
callq 0x1050
movq %r12, %rdi
movq %r14, %rsi
callq 0x1450
jmp 0x1329
movq 0x2c10(%rip), %rdi      # 0x3fc8
leaq -0x58(%rbp), %rsi
callq 0x1592
movq %rax, %rdi
callq 0x1050
leaq -0x88(%rbp), %rdi
callq 0x1040
leaq -0x58(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x140c
movq %rax, %rbx
jmp 0x141b
jmp 0x140c
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x1040
jmp 0x140f
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x1040
leaq -0x58(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2e0f(%rip), %rdi      # 0x3fe0
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x1070
leaq 0x28(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
leaq 0x20(%rsp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x1070
leaq 0x18(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x1070
leaq 0x10(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x1070
leaq 0x8(%rsp), %rbp
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1070
movq (%r13), %rax
subq (%rbp), %rax
movq (%r15), %rsi
movq (%rbx), %rcx
imulq %rsi, %rcx
addq %rax, %rcx
movq (%r12), %rdx
movq (%r14), %rbx
imulq %rdx, %rbx
addq %rcx, %rbx
movq %rbx, %rdi
callq 0x12cf
movq %rax, %r14
movq (%r12), %rsi
movq (%r15), %rdx
movq %rbx, %rdi
callq 0x12cf
movq %rax, %rbx
cmpq $-0x1, %r14
setne %al
cmpq $-0x1, %rbx
setne %cl
movq 0x2d4d(%rip), %rdi      # 0x3fd0
testb %cl, %al
jne 0x1295
leaq 0xd76(%rip), %rsi       # 0x2004
callq 0x1050
jmp 0x12be
movq %r14, %rsi
callq 0x1030
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1030
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x1060
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_O2/kdungs[P]codecon/src/apples.cc
// Function: long long findSolution<long long>(long long, long long, long long)
T findSolution(T max_money, const T my_price, const T other_price) {
  while (max_money > 0 && (max_money % my_price) != 0) {
    max_money -= other_price;
  }
  if (max_money <= 0) {
    return -1;
  }
  return max_money / my_price;
}

// Assembly:
movq %rdx, %r8
pushq $-0x1
popq %rcx
testq %rdi, %rdi
jle 0x12ef
movq %rdi, %rax
cqto
idivq %rsi
testq %rdx, %rdx
je 0x12ec
subq %r8, %rdi
jmp 0x12d5
movq %rax, %rcx
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2110
movq %rax, %rbx
leaq 0x9b16(%rip), %rdi      # 0xc248
callq 0x4a2d
movq %rsp, %rdx
leaq 0x400(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x2541
cmpb $0x74, 0x9abd(%rip)     # 0xc210
jne 0x2779
leaq 0x9aec(%rip), %r14      # 0xc248
movq %rsp, %rdi
movq %r14, %rsi
callq 0x57e6
leaq 0x400(%rsp), %rsi
movq %r14, %rdi
callq 0x6f8a
jmp 0x2788
leaq 0x9ac8(%rip), %rsi      # 0xc248
movq %rsp, %rdi
callq 0x6824
leaq 0x9ab9(%rip), %rdi      # 0xc248
callq 0x4c36
cmpb $0x0, 0x9af9(%rip)      # 0xc294
jne 0x27c0
callq 0x2110
subq %rbx, %rax
cvtsi2sd %rax, %xmm0
divsd 0x5856(%rip), %xmm0     # 0x8008
leaq 0x5979(%rip), %rdi      # 0x8132
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_O2/jflemer[P]boost-chat-server/chat_server.cpp
// Function: main
int main(int argc, char* argv[])
{
  try
  {
    if (argc < 2)
    {
      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
      return 1;
    }

    boost::asio::io_service io_service;

    chat_server_list servers;
    for (int i = 1; i < argc; ++i)
    {
      using namespace std; // For atoi.
      tcp::endpoint endpoint(tcp::v4(), atoi(argv[i]));
      chat_server_ptr server(new chat_server(io_service, endpoint));
      servers.push_back(server);
    }

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x1, %edi
jg 0x579a
movq 0x14862(%rip), %rdi     # 0x19fe8
leaq 0x98a3(%rip), %rsi      # 0xf030
callq 0x52e0
pushq $0x1
popq %rax
jmp 0x5858
movq %rsi, %rbx
movl %edi, %ebp
movq %rsp, %rdi
callq 0x5a8c
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x2c(%rsp), %r15
movl %ebp, %r12d
pushq $0x1
popq %r13
leaq 0x10(%rsp), %rbp
cmpq %r13, %r12
je 0x583c
movq (%rbx,%r13,8), %rdi
callq 0x5490
andl $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
rolw $0x8, %ax
movw $0x2, 0x24(%rsp)
movw %ax, 0x26(%rsp)
andl $0x0, 0x28(%rsp)
movl $0xd8, %edi
callq 0x52f0
movq %rax, %r14
movq %rax, %rdi
movq %rsp, %rsi
leaq 0x24(%rsp), %rdx
callq 0x5af0
movq %rbp, %rdi
movq %r14, %rsi
callq 0x5b48
leaq 0x40(%rsp), %rdi
movq %rbp, %rsi
callq 0x5b7c
leaq 0x18(%rsp), %rdi
callq 0xacf6
incq %r13
jmp 0x57c9
movq %rsp, %rdi
callq 0x5b88
leaq 0x40(%rsp), %rdi
callq 0xe762
movq %rsp, %rdi
callq 0x5bc8
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x589a
jmp 0x586b
movq %rdx, %r15
movq %rax, %rbx
jmp 0x58b2
movq %rdx, %r15
movq %rax, %rbx
movl $0xd8, %esi
movq %r14, %rdi
callq 0x5300
jmp 0x58a0
movq %rdx, %r15
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xacf6
jmp 0x58a0
movq %rdx, %r15
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xe762
movq %rsp, %rdi
callq 0x5bc8
cmpl $0x1, %r15d
jne 0x590e
movq %rbx, %rdi
callq 0x5150
movq %rax, %rbx
movq 0x1471e(%rip), %rdi     # 0x19fe8
leaq 0x9787(%rip), %rsi      # 0xf058
callq 0x52e0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x52e0
leaq 0x9762(%rip), %rsi      # 0xf056
movq %rax, %rdi
callq 0x52e0
callq 0x54b0
jmp 0x5856
movq %rax, %rbx
callq 0x54b0
movq %rbx, %rdi
callq 0x54e0
movq %rax, %rdi
callq 0x59d9
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl $0x2d0, %edi            # imm = 0x2D0
callq 0x52f0
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x58(%r14), %rdx
movq %rax, %rdi
callq 0xad30
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xad9c
movq %r15, %rdi
callq 0xadec
movq %rax, %r12
movq (%r15), %rcx
movq 0x8(%r15), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x7ba8
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %rbx
leaq 0x32fd(%rip), %rsi      # 0xaeb6
leaq 0x3319(%rip), %r9       # 0xaed9
leaq 0x20(%rsp), %rdi
movq %rsp, %r8
xorl %edx, %edx
movq %r14, %rcx
callq 0xae15
addq $0x18, %r12
addq $0x8, %r14
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xadd0
leaq 0x40(%rsp), %rdi
callq 0xacf6
movq %r15, %rdi
callq 0xacf6
movq %rbx, %rdi
callq 0xacf6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xacf6
jmp 0x7c24
movq %rax, %r14
movq %r15, %rdi
callq 0xacf6
movq %rbx, %rdi
callq 0xacf6
jmp 0x7c46
movq %rax, %r14
movl $0x2d0, %esi            # imm = 0x2D0
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x54e0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rdi, %rbx
addq $0x280, %rdi            # imm = 0x280
movq 0x2b0(%rbx), %r14
movq 0x290(%rbx), %r15
callq 0xb03e
cmpq %r15, %r14
jne 0xafc1
movq 0x290(%rbx), %rax
movq 0x208(%rax), %rcx
addq $0x4, %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
leaq 0x8(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xb25a
leaq 0x1b3(%rip), %rsi       # 0xb132
leaq -0xad(%rip), %r8        # 0xaed9
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xb09a
addq $0x18, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb073
leaq 0x38(%rsp), %rdi
callq 0xacf6
leaq 0x8(%rsp), %rdi
callq 0xacf6
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xacf6
jmp 0xafdd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xacf6
movq %rbx, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
je 0xb192
movq 0x68(%rbx), %r12
addq $0x8, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xb25a
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r14
movaps -0x8(%r14), %xmm0
movaps %xmm0, -0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r14)
leaq 0x40(%rsp), %rsi
movq %r12, %rdi
callq 0xc440
movq %r15, %rdi
callq 0xacf6
movq %r14, %rdi
jmp 0xb214
leaq 0x280(%rbx), %rdi
callq 0xc3e4
movq 0x290(%rbx), %rax
cmpq %rax, 0x2b0(%rbx)
je 0xb219
movq 0x208(%rax), %rcx
addq $0x4, %rcx
movq %rax, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
leaq 0x8(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xb25a
leaq -0xa9(%rip), %rsi       # 0xb132
leaq -0x309(%rip), %r8       # 0xaed9
movq %rsp, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xb09a
addq $0x18, %rbx
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb073
leaq 0x18(%rsp), %rdi
callq 0xacf6
leaq 0x28(%rsp), %rdi
callq 0xacf6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xacf6
jmp 0xb237
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xb24c
movq %rax, %rbx
movq %r15, %rdi
callq 0xacf6
movq %r14, %rdi
callq 0xacf6
movq %rbx, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x50, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r13
leaq 0x8(%rdi), %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0xb25a
leaq 0x48(%rsp), %r12
leaq 0x8(%rsp), %r15
movaps -0x8(%r15), %xmm0
movaps %xmm0, -0x8(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
leaq 0x40(%rsp), %rsi
movq %r13, %rdi
callq 0xd6ba
movq %r12, %rdi
callq 0xacf6
movq %r15, %rdi
callq 0xacf6
leaq 0x70(%rbx), %rax
movq %rax, 0x30(%rsp)
movq $0x4, 0x38(%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb25a
leaq 0x17a(%rip), %rsi       # 0xd7b4
leaq -0x2768(%rip), %r8      # 0xaed9
movq %rsp, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0xb09a
addq $0x18, %rbx
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xd78c
leaq 0x18(%rsp), %rdi
callq 0xacf6
leaq 0x28(%rsp), %rdi
callq 0xacf6
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xacf6
jmp 0xd698
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xd6ad
movq %rax, %rbx
movq %r12, %rdi
callq 0xacf6
movq %r15, %rdi
callq 0xacf6
movq %rbx, %rdi
callq 0x54e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4(%rsi)
jne 0xd83d
leaq 0x70(%rbx), %rdi
callq 0xe508
testb %al, %al
je 0xd83d
leaq 0x74(%rbx), %rax
movq 0x278(%rbx), %rcx
movq %rax, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
leaq 0x8(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xb25a
leaq 0xd4e(%rip), %rsi       # 0xe550
leaq -0x2930(%rip), %r8      # 0xaed9
movq %rsp, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xb09a
addq $0x18, %rbx
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xd78c
leaq 0x18(%rsp), %rdi
callq 0xacf6
leaq 0x28(%rsp), %rdi
jmp 0xd884
movq 0x68(%rbx), %r12
addq $0x8, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xb25a
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r14
movaps -0x8(%r14), %xmm0
movaps %xmm0, -0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r14)
leaq 0x40(%rsp), %rsi
movq %r12, %rdi
callq 0xc440
movq %r15, %rdi
callq 0xacf6
movq %r14, %rdi
callq 0xacf6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xacf6
jmp 0xd8a7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xd8bc
movq %rax, %rbx
movq %r15, %rdi
callq 0xacf6
movq %r14, %rdi
callq 0xacf6
movq %rbx, %rdi
callq 0x54e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %r15
cmpb $0x0, 0x4(%rsi)
je 0xe5ae
addq $0x8, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xb25a
leaq 0x48(%rsp), %r12
leaq 0x8(%rsp), %r14
movaps -0x8(%r14), %xmm0
movaps %xmm0, -0x8(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r14)
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0xc440
movq %r12, %rdi
callq 0xacf6
movq %r14, %rdi
jmp 0xe61c
leaq 0x70(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xe662
movq %r14, 0x30(%rsp)
movq $0x4, 0x38(%rsp)
leaq 0x8(%rbx), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xb25a
leaq -0xe2f(%rip), %rsi      # 0xd7b4
leaq -0x3711(%rip), %r8      # 0xaed9
movq %rsp, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0xb09a
addq $0x18, %rbx
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xd78c
leaq 0x18(%rsp), %rdi
callq 0xacf6
leaq 0x28(%rsp), %rdi
callq 0xacf6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xacf6
jmp 0xe63f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xe654
movq %rax, %rbx
movq %r12, %rdi
callq 0xacf6
movq %r14, %rdi
callq 0xacf6
movq %rbx, %rdi
callq 0x54e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0xb03e
movq %r15, %rdi
callq 0xb324
cmpq $0x65, %rax
jb 0xe695
movq %r15, %rdi
callq 0xc3e4
jmp 0xe67d
movq 0x18(%rbx), %rsi
addq $0x8, %rbx
movq $0x11, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
movq %rbx, %rdx
callq 0xe6db
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x22(%rbp), %r14
pushq $0x1
popq %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x21f0
leaq -0x21(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x21f0
movzbl (%r14), %r14d
movzbl (%r12), %eax
shll $0x8, %r14d
orl %eax, %r14d
cmpb $0x1, 0x6d50(%rip)      # 0x91da
jne 0x24a3
movl %r14d, %esi
movq 0x6b3a(%rip), %rdi      # 0x8fd0
callq 0x2110
movq %rax, %rdi
callq 0x20e0
addl $-0x2, %r14d
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x22(%rbp), %r14
pushq $0x1
popq %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x21f0
leaq -0x21(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x21f0
movb (%r14), %al
notb %al
movb (%r12), %cl
xorb $-0x28, %cl
orb %al, %cl
setne %bl
je 0x2949
leaq 0x378f(%rip), %rsi      # 0x60d6
jmp 0x2959
cmpb $0x1, 0x688a(%rip)      # 0x91da
jne 0x296d
leaq 0x3777(%rip), %rsi      # 0x60d0
movq 0x6670(%rip), %rdi      # 0x8fd0
callq 0x2190
movq %rax, %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq