LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::sum_from(aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary> const&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static summary_type sum_from(const aggregator_type& ag,
				 node *start, node *root)
    {
	summary_type sum = ag.nothing();
	node *n = start;

	while (n != root) {
	    if (n != start)
		sum = ag.combine(sum, n->value);

	    sum = ag.combine(sum, sum_tree(ag, n->right));

	    // Ascend to an ancestor which is lexicographically after n.
	    while (is_right_child(n) && n->parent != root)
		n = n->parent;

	    n = n->parent;
	}

	return sum;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
je 0x2e3b
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rsi, %r12
cmpq %r14, %r12
je 0x2e0f
addl 0x20(%r12), %ebp
movq 0x38(%r12), %rsi
movq %r15, %rdi
callq 0x2f04
movq %r12, %rcx
movq 0x40(%rcx), %r12
cmpq %rbx, %r12
je 0x2e32
cmpq %rcx, 0x38(%r12)
movq %r12, %rcx
je 0x2e1f
addl %eax, %ebp
cmpq %rbx, %r12
jne 0x2e05
jmp 0x2e3d
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::concestor(summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static node *concestor(node *a, node *b)
    {
	int da = depth_of(a);
	int db = depth_of(b);

	// Make sure b is the deeper of the two
	if (da > db) {
	    std::swap(da, db);
	    std::swap(a, b);
	}

	// Climb up b until we find an ancestor of the same depth as a
	while (da < db) {
	    b = b->parent;
	    db--;
	}

	// Climb both simultaneously until we meet
	while (a != b) {
	    a = a->parent;
	    b = b->parent;
	}

	return a;
    }

// Assembly:
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rdi, %rax
movq 0x40(%rax), %rax
incl %ecx
testq %rax, %rax
jne 0x2e50
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %rsi, %rax
movq 0x40(%rax), %rax
incl %r8d
testq %rax, %rax
jne 0x2e64
cmpl %r8d, %ecx
jbe 0x2e7d
movq %rsi, %rax
movl %r8d, %edx
jmp 0x2e88
movq %rdi, %rax
movq %rsi, %rdi
movl %ecx, %edx
movl %r8d, %ecx
cmpl %ecx, %edx
jae 0x2ea0
movq 0x40(%rdi), %rdi
decl %ecx
cmpl %ecx, %edx
jl 0x2e8c
jmp 0x2ea0
movq 0x40(%rax), %rax
movq 0x40(%rdi), %rdi
cmpq %rdi, %rax
jne 0x2e98
retq
// File: /workspace/github_cpp_makefile_star2_O3/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::sum_to(aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary> const&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static summary_type sum_to(const aggregator_type& ag,
			       node *end, node *root)
    {
	summary_type sum = ag.nothing();
	node *n = end;

	while (n != root) {
	    if (n != end)
		sum = ag.combine(n->value, sum);

	    sum = ag.combine(sum_tree(ag, n->left), sum);

	    // Ascend to an ancestor which is lexicographically before
	    // n.
	    while (is_left_child(n) && n->parent != root)
		n = n->parent;

	    n = n->parent;
	}

	return sum;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq %rdx, %rsi
je 0x2ef7
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rsi, %r12
cmpq %r14, %r12
je 0x2ecb
addl 0x20(%r12), %ebp
movq 0x30(%r12), %rsi
movq %r15, %rdi
callq 0x2f04
movq %r12, %rcx
movq 0x40(%rcx), %r12
cmpq %rbx, %r12
je 0x2eee
cmpq %rcx, 0x30(%r12)
movq %r12, %rcx
je 0x2edb
addl %eax, %ebp
cmpq %rbx, %r12
jne 0x2ec1
jmp 0x2ef9
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::sum_tree(aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary> const&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static summary_type sum_tree(const aggregator_type& ag, node *n)
    {
	if (!n)
	    return ag.nothing();

	if (!(n->flags & node::SUM_VALID)) {
	    n->sum =
		ag.combine(
		    ag.combine(sum_tree(ag, n->left), ag.summarize(n->value)),
		    sum_tree(ag, n->right));
	    n->flags |= node::SUM_VALID;
	}

	return n->sum;
    }

// Assembly:
testq %rsi, %rsi
je 0x2f3e
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testb $0x2, 0x2c(%rsi)
jne 0x2f41
movq %rdi, %r14
movq 0x30(%rbx), %rsi
callq 0x2f04
movl %eax, %ebp
addl 0x20(%rbx), %ebp
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x2f04
addl %ebp, %eax
movl %eax, 0x28(%rbx)
orb $0x2, 0x2c(%rbx)
jmp 0x2f44
xorl %eax, %eax
retq
movl 0x28(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	cuckoohash_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		h.upsert(get_key(n, x), [&z](uint32_t &v) { z += ++v; }); // FIXME: not sure if this is correct...
		++z;
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x40000, %esi          # imm = 0x40000
callq 0x2968
xorl %r14d, %r14d
testl %ebx, %ebx
je 0x28f8
movl %ebx, %r13d
shrl $0x2, %r13d
xorl %r14d, %r14d
leaq 0x18(%rsp), %r15
leaq 0x50(%rsp), %r12
movl %ebp, %eax
shll $0xf, %eax
notl %eax
addl %ebp, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ebp
shrl $0x10, %ebp
xorl %eax, %ebp
movl %ebp, %eax
xorl %edx, %edx
divl %r13d
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
xorl %eax, %ecx
movl %ecx, 0x4(%rsp)
movl %eax, %edx
shrl $0x8, %edx
xorl %eax, %edx
movq %rcx, 0x8(%rsp)
movb %dl, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2d46
movq 0x8(%rsp), %rdx
movl 0x10(%rsp), %ecx
leaq 0x38(%rsp), %rdi
movq %r12, %rsi
movq %r15, %r8
leaq 0x4(%rsp), %r9
callq 0x2dc6
cmpl $0x0, 0x48(%rsp)
movq 0x38(%rsp), %rsi
je 0x28b3
leaq (%rsi,%rsi,4), %rax
shlq $0x3, %rax
addq 0x68(%rsp), %rax
movq 0x40(%rsp), %rcx
movl 0x4(%rax,%rcx,8), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rax,%rcx,8)
addl %edx, %r14d
incl %r14d
jmp 0x28ca
movq 0x40(%rsp), %rdx
movzbl 0x10(%rsp), %ecx
movq %r12, %rdi
leaq 0x4(%rsp), %r8
callq 0x2ee8
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x28d7
movb $0x0, (%rax)
movq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x28ed
movb $0x0, (%rax)
incl %r14d
decl %ebx
jne 0x27e5
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movl %r14d, %esi
movq %rbx, %rdx
callq 0x2528
movl (%rbx), %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x294c
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2936
movb $0x0, (%rax)
movq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x294c
movb $0x0, (%rax)
leaq 0x70(%rsp), %rdi
callq 0x2a8a
leaq 0x58(%rsp), %rdi
callq 0x2acc
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::size() const
size_type size() const {
    if (all_locks_.size() == 0) {
      return 0;
    }
    counter_type s = 0;
    for (spinlock &lock : get_current_locks()) {
      s += lock.elem_counter();
    }
    assert(s >= 0);
    return static_cast<size_type>(s);
  }

// Assembly:
pushq %rax
cmpq $0x0, 0x30(%rdi)
je 0x2a86
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
cmpq %rdx, %rcx
je 0x2a86
xorl %eax, %eax
addq 0x8(%rcx), %rax
addq $0x40, %rcx
cmpq %rdx, %rcx
jne 0x2a55
testq %rax, %rax
jns 0x2a88
leaq 0x3d71(%rip), %rdi      # 0x67df
leaq 0x2809(%rip), %rsi      # 0x527e
leaq 0x3d6a(%rip), %rcx      # 0x67e6
movl $0x157, %edx            # imm = 0x157
callq 0x20f0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::destroy_buckets()
void destroy_buckets() noexcept {
    if (buckets_ == nullptr) {
      return;
    }
    // The bucket default constructor is nothrow, so we don't have to
    // worry about dealing with exceptions when constructing all the
    // elements.
    static_assert(std::is_nothrow_destructible<bucket>::value,
                  "libcuckoo_bucket_container requires bucket to be nothrow "
                  "destructible");
    clear();
    for (size_type i = 0; i < size(); ++i) {
      traits_::destroy(allocator_, &buckets_[i]);
    }
    bucket_allocator_.deallocate(buckets_, size());
    buckets_ = nullptr;
  }

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x2b76
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl $0x1, %eax
movl $0x24, %edx
movq 0x10(%rbx), %rcx
movl (%rcx,%rdx), %esi
testb $0x1, %sil
je 0x2afa
movb $0x0, (%rcx,%rdx)
movd %esi, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3]
pextrw $0x2, %xmm0, %esi
testb $0x1, %sil
je 0x2b16
movb $0x0, 0x1(%rcx,%rdx)
pextrw $0x4, %xmm0, %esi
testb $0x1, %sil
je 0x2b26
movb $0x0, 0x2(%rcx,%rdx)
pextrw $0x6, %xmm0, %esi
testb $0x1, %sil
je 0x2b36
movb $0x0, 0x3(%rcx,%rdx)
movq 0x8(%rbx), %rcx
movq %rax, %rsi
shrq %cl, %rsi
incq %rax
addq $0x28, %rdx
testq %rsi, %rsi
je 0x2ae9
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq %rax, %rdx
shrq %cl, %rdx
incq %rax
testq %rdx, %rdx
je 0x2b4e
movq 0x10(%rbx), %rdi
movq 0x8(%rbx), %rax
callq 0x2140
movq $0x0, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::reserve_calc(unsigned long)
static size_type reserve_calc(const size_type n) {
    const size_type buckets = (n + slot_per_bucket() - 1) / slot_per_bucket();
    size_type blog2;
    for (blog2 = 0; (size_type(1) << blog2) < buckets; ++blog2)
      ;
    assert(n <= buckets * slot_per_bucket() && buckets <= hashsize(blog2));
    return blog2;
  }

// Assembly:
leaq 0x3(%rdi), %rax
movq %rax, %rdx
shrq $0x2, %rdx
movq $-0x1, %rcx
incq %rcx
movl $0x1, %esi
shlq %cl, %rsi
cmpq %rdx, %rsi
jb 0x2b8a
andq $-0x4, %rax
cmpq %rdi, %rax
jb 0x2ba7
movq %rcx, %rax
retq
pushq %rax
leaq 0x2690(%rip), %rdi      # 0x523f
leaq 0x26c8(%rip), %rsi      # 0x527e
leaq 0x26d5(%rip), %rcx      # 0x5292
movl $0x71f, %edx            # imm = 0x71F
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::libcuckoo_bucket_container(unsigned long, std::allocator<std::pair<unsigned int const, unsigned int>> const&)
libcuckoo_bucket_container(size_type hp, const allocator_type &allocator)
      : allocator_(allocator), bucket_allocator_(allocator), hashpower_(hp),
        buckets_(bucket_allocator_.allocate(size())) {
    // The bucket default constructor is nothrow, so we don't have to
    // worry about dealing with exceptions when constructing all the
    // elements.
    static_assert(std::is_nothrow_constructible<bucket>::value,
                  "libcuckoo_bucket_container requires bucket to be nothrow "
                  "constructible");
    for (size_type i = 0; i < size(); ++i) {
      traits_::construct(allocator_, &buckets_[i]);
    }
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq %rdi
movq %rsi, 0x8(%rbx)
movq 0x8(%rbx), %rcx
movl $0x1, %r14d
movl $0x1, %esi
shlq %cl, %rsi
xorl %edx, %edx
callq 0x2c26
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
movl $0x24, %eax
movq 0x10(%rbx), %rcx
movl $0x0, (%rcx,%rax)
movq 0x8(%rbx), %rcx
movq %r14, %rdx
shrq %cl, %rdx
incq %r14
addq $0x28, %rax
testq %rdx, %rdx
je 0x2bfc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::TwoBuckets cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::snapshot_and_lock_two<std::integral_constant<bool, false>>(cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::hash_value const&) const
TwoBuckets snapshot_and_lock_two(const hash_value &hv) const {
    while (true) {
      // Keep the current hashpower and locks we're using to compute the buckets
      const size_type hp = hashpower();
      const size_type i1 = index_hash(hp, hv.hash);
      const size_type i2 = alt_index(hp, hv.partial, i1);
      try {
        return lock_two(hp, i1, i2, TABLE_MODE());
      } catch (hashpower_changed &) {
        // The hashpower changed while taking the locks. Try again.
        continue;
      }
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movabsq $0x46a4a7935bd1e995, %r12 # imm = 0x46A4A7935BD1E995
movq 0x10(%r15), %rcx
movq $-0x1, %rdx
shlq %cl, %rdx
movq (%rbx), %rax
notq %rdx
movzbl 0x8(%rbx), %r8d
imulq %r12, %r8
addq %r12, %r8
xorq %rax, %r8
andq %rdx, %rax
andq %rdx, %r8
movq %r14, %rdi
movq %r15, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x2f46
jmp 0x2db1
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x2dc0
callq 0x2090
callq 0x21e0
jmp 0x2d61
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::table_position cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::cuckoo_insert_loop<std::integral_constant<bool, false>, unsigned int>(cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::hash_value, cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::TwoBuckets&, unsigned int&)
table_position cuckoo_insert_loop(hash_value hv, TwoBuckets &b, K &key) {
    table_position pos;
    while (true) {
      const size_type hp = hashpower();
      pos = cuckoo_insert<TABLE_MODE>(hv, b, key);
      switch (pos.status) {
      case ok:
      case failure_key_duplicated:
        return pos;
      case failure_table_full:
        // Expand the table and try again, re-grabbing the locks
        cuckoo_fast_double<TABLE_MODE, automatic_resize>(hp);
        b = snapshot_and_lock_two<TABLE_MODE>(hv);
        break;
      case failure_under_expansion:
        // The table was under expansion while we were cuckooing. Re-grab the
        // locks and try again.
        b = snapshot_and_lock_two<TABLE_MODE>(hv);
        break;
      default:
        assert(false);
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %rax
movq %rdx, (%rax)
movb %cl, 0x8(%rax)
leaq 0x222e(%rip), %r13      # 0x5020
movq 0x10(%r12), %rbp
movq 0x28(%rsp), %rdx
movl 0x30(%rsp), %ecx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %r8
movq %rbx, %r9
callq 0x3000
movl 0x10(%r15), %eax
cmpq $0x5, %rax
ja 0x2ec9
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3316
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
leaq 0x28(%rsp), %rdx
callq 0x2d46
movups 0x8(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x18(%rsp), %rcx
movq $0x0, 0x18(%rsp)
movq 0x10(%r14), %rax
movq %rcx, 0x10(%r14)
testq %rax, %rax
je 0x2e6d
movb $0x0, (%rax)
movq 0x20(%rsp), %rcx
movq $0x0, 0x20(%rsp)
movq 0x18(%r14), %rax
movq %rcx, 0x18(%r14)
testq %rax, %rax
je 0x2e98
movb $0x0, (%rax)
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2e98
movb $0x0, (%rax)
movq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2df2
movb $0x0, (%rax)
jmp 0x2df2
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2512(%rip), %rdi      # 0x53e2
leaq 0x23a7(%rip), %rsi      # 0x527e
leaq 0x250a(%rip), %rcx      # 0x53e8
movl $0x447, %edx            # imm = 0x447
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: void cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::add_to_bucket<unsigned int>(unsigned long, unsigned long, unsigned char, unsigned int&&)
void setKV(size_type ind, size_type slot, partial_t p, K &&k,
             Args &&... args) {
    bucket &b = buckets_[ind];
    assert(!b.occupied(slot));
    b.partial(slot) = p;
    traits_::construct(allocator_, std::addressof(b.storage_kvpair(slot)),
                       std::piecewise_construct,
                       std::forward_as_tuple(std::forward<K>(k)),
                       std::forward_as_tuple(std::forward<Args>(args)...));
    // This must occur last, to enforce a strong exception guarantee
    b.occupied(slot) = true;
  }

// Assembly:
leaq (%rsi,%rsi,4), %rax
shlq $0x3, %rax
addq 0x18(%rdi), %rax
cmpb $0x1, 0x24(%rdx,%rax)
je 0x2f26
movb %cl, 0x20(%rax,%rdx)
movl (%r8), %ecx
movl %ecx, (%rax,%rdx,8)
movl $0x0, 0x4(%rax,%rdx,8)
movb $0x1, 0x24(%rax,%rdx)
movq 0x28(%rdi), %rax
movzwl %si, %ecx
movq 0x10(%rax), %rax
shll $0x6, %ecx
incq 0x8(%rax,%rcx)
retq
pushq %rax
leaq 0x30db(%rip), %rdi      # 0x6009
leaq 0x21a2(%rip), %rsi      # 0x50d7
leaq 0x3723(%rip), %rcx      # 0x665f
movl $0xc9, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::lock_two(unsigned long, unsigned long, unsigned long, std::integral_constant<bool, false>) const
TwoBuckets lock_two(size_type hp, size_type i1, size_type i2,
                      normal_mode) const {
    size_type l1 = lock_ind(i1);
    size_type l2 = lock_ind(i2);
    if (l2 < l1) {
      std::swap(l1, l2);
    }
    locks_t &locks = get_current_locks();
    locks[l1].lock();
    check_hashpower(hp, locks[l1]);
    if (l2 != l1) {
      locks[l2].lock();
    }
    return TwoBuckets(locks, i1, i2, normal_mode());
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0xffff, %eax           # imm = 0xFFFF
movq %rcx, %r9
andq %rax, %r9
andq %r8, %rax
cmpq %r9, %rax
movq %r9, %r11
cmovbq %rax, %r11
movq 0x28(%rsi), %r10
movl %r11d, %ebx
shll $0x6, %ebx
addq 0x10(%r10), %rbx
movb $0x1, %bpl
xchgb %bpl, (%rbx)
testb %bpl, %bpl
jne 0x2f70
cmpq %r9, %rax
movq %r9, %rbx
cmovaq %rax, %rbx
movq 0x10(%r10), %r14
movq 0x10(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x2fdb
cmpl %r9d, %eax
je 0x2fa6
shll $0x6, %ebx
addq 0x10(%r10), %rbx
movb $0x1, %dl
xchgb %dl, (%rbx)
testb %dl, %dl
jne 0x2f9e
movq %rcx, (%rdi)
movq %r8, 0x8(%rdi)
movq 0x10(%r10), %rcx
movl %r9d, %edx
shll $0x6, %edx
addq %rcx, %rdx
movl %eax, %esi
shll $0x6, %esi
addq %rcx, %rsi
xorl %ecx, %ecx
cmpq %r9, %rax
movq %rdx, 0x10(%rdi)
cmovneq %rsi, %rcx
movq %rcx, 0x18(%rdi)
movq %rdi, %rax
popq %rbx
popq %r14
popq %rbp
retq
shll $0x6, %r11d
movb $0x0, (%r14,%r11)
movl $0x1, %edi
callq 0x20b0
leaq 0x5ce3(%rip), %rsi      # 0x8cd8
movq %rax, %rdi
xorl %edx, %edx
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::table_position cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::cuckoo_find<unsigned int>(unsigned int const&, unsigned char, unsigned long, unsigned long) const
table_position cuckoo_find(const K &key, const partial_t partial,
                             const size_type i1, const size_type i2) const {
    int slot = try_read_from_bucket(buckets_[i1], partial, key);
    if (slot != -1) {
      return table_position{i1, static_cast<size_type>(slot), ok};
    }
    slot = try_read_from_bucket(buckets_[i2], partial, key);
    if (slot != -1) {
      return table_position{i2, static_cast<size_type>(slot), ok};
    }
    return table_position{0, 0, failure_key_not_found};
  }

// Assembly:
movq %rdi, %rax
movq 0x18(%rsi), %rsi
leaq (%r8,%r8,4), %rcx
leaq (%rsi,%rcx,8), %rdi
movl (%rdx), %ecx
xorl %edx, %edx
cmpb $0x1, 0x24(%rdi,%rdx)
jne 0x3655
cmpl %ecx, (%rdi,%rdx,8)
je 0x3692
incq %rdx
cmpq $0x4, %rdx
jne 0x3649
leaq (%r9,%r9,4), %rdx
leaq (%rsi,%rdx,8), %rsi
xorl %edx, %edx
cmpb $0x1, 0x24(%rsi,%rdx)
jne 0x3674
cmpl %ecx, (%rsi,%rdx,8)
je 0x3697
incq %rdx
cmpq $0x4, %rdx
jne 0x3668
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x2, %ecx
jmp 0x36a0
movq %r8, (%rax)
jmp 0x369a
movq %r9, (%rax)
movq %rdx, 0x8(%rax)
xorl %ecx, %ecx
movl %ecx, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::lock_one(unsigned long, unsigned long, std::integral_constant<bool, false>) const
LockManager lock_one(size_type hp, size_type i, normal_mode) const {
    locks_t &locks = get_current_locks();
    spinlock &lock = locks[lock_ind(i)];
    lock.lock();
    check_hashpower(hp, lock);
    return LockManager(&lock);
  }

// Assembly:
pushq %rax
movq 0x28(%rsi), %r8
movzwl %cx, %eax
shll $0x6, %eax
addq 0x10(%r8), %rax
movb $0x1, %cl
xchgb %cl, (%rax)
testb %cl, %cl
jne 0x3dbf
movq 0x10(%rsi), %rcx
cmpq %rdx, %rcx
jne 0x3dd8
movq %rax, (%rdi)
movq %rdi, %rax
popq %rcx
retq
movb $0x0, (%rax)
movl $0x1, %edi
callq 0x20b0
leaq 0x4eec(%rip), %rsi      # 0x8cd8
movq %rax, %rdi
xorl %edx, %edx
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::b_queue::dequeue()
b_slot dequeue() {
      assert(!empty());
      assert(first_ < last_);
      b_slot &x = slots_[first_++];
      return x;
    }

// Assembly:
pushq %rax
movq 0x2aa0(%rdi), %rcx
cmpq 0x2aa8(%rdi), %rcx
je 0x3e23
jae 0x3e42
leaq 0x1(%rcx), %rax
movq %rax, 0x2aa0(%rdi)
shlq $0x4, %rcx
movq (%rdi,%rcx), %rax
movq 0x8(%rdi,%rcx), %rdx
popq %rcx
retq
leaq 0x1f2a(%rip), %rdi      # 0x5d54
leaq 0x144d(%rip), %rsi      # 0x527e
leaq 0x1f25(%rip), %rcx      # 0x5d5d
movl $0x5c1, %edx            # imm = 0x5C1
callq 0x20f0
leaq 0x201e(%rip), %rdi      # 0x5e67
leaq 0x142e(%rip), %rsi      # 0x527e
leaq 0x1f06(%rip), %rcx      # 0x5d5d
movl $0x5c2, %edx            # imm = 0x5C2
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::lock_three(unsigned long, unsigned long, unsigned long, unsigned long, std::integral_constant<bool, false>) const
std::pair<TwoBuckets, LockManager> lock_three(size_type hp, size_type i1,
                                                size_type i2, size_type i3,
                                                normal_mode) const {
    std::array<size_type, 3> l{{lock_ind(i1), lock_ind(i2), lock_ind(i3)}};
    // Lock in order.
    if (l[2] < l[1])
      std::swap(l[2], l[1]);
    if (l[2] < l[0])
      std::swap(l[2], l[0]);
    if (l[1] < l[0])
      std::swap(l[1], l[0]);
    locks_t &locks = get_current_locks();
    locks[l[0]].lock();
    check_hashpower(hp, locks[l[0]]);
    if (l[1] != l[0]) {
      locks[l[1]].lock();
    }
    if (l[2] != l[1]) {
      locks[l[2]].lock();
    }
    return std::make_pair(TwoBuckets(locks, i1, i2, normal_mode()),
                          LockManager((lock_ind(i3) == lock_ind(i1) ||
                                       lock_ind(i3) == lock_ind(i2))
                                          ? nullptr
                                          : &locks[lock_ind(i3)]));
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffff, %r11d          # imm = 0xFFFF
movq %rcx, %rax
andq %r11, %rax
movq %r8, %r10
andq %r11, %r10
andq %r11, %r9
cmpq %r10, %r9
movq %r10, %r14
cmovbq %r9, %r14
movq %r10, %r11
cmovaq %r9, %r11
cmpq %rax, %r11
movq %rax, %r15
cmovbq %r11, %r15
cmpq %r15, %r14
movq %r15, %r12
cmovbq %r14, %r12
movq 0x28(%rsi), %rbx
movl %r12d, %r13d
shll $0x6, %r13d
addq 0x10(%rbx), %r13
movb $0x1, %bpl
xchgb %bpl, (%r13)
testb %bpl, %bpl
jne 0x3eb6
cmpq %rax, %r11
cmovbeq %rax, %r11
cmpq %r15, %r14
movq %r15, %r13
cmovaq %r14, %r13
movq 0x10(%rbx), %rbp
movq 0x10(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x3f6f
cmpl %r15d, %r14d
je 0x3efe
movl %r13d, %edx
shll $0x6, %edx
addq 0x10(%rbx), %rdx
movb $0x1, %sil
xchgb %sil, (%rdx)
testb %sil, %sil
jne 0x3ef3
cmpl %r13d, %r11d
je 0x3f14
shll $0x6, %r11d
addq 0x10(%rbx), %r11
movb $0x1, %dl
xchgb %dl, (%r11)
testb %dl, %dl
jne 0x3f0b
movq 0x10(%rbx), %rdx
movl %eax, %esi
shll $0x6, %esi
addq %rdx, %rsi
movl %r10d, %r11d
shll $0x6, %r11d
addq %rdx, %r11
movl %r9d, %ebx
shll $0x6, %ebx
addq %rdx, %rbx
xorl %edx, %edx
cmpq %r10, %rax
cmoveq %rdx, %r11
cmpq %r10, %r9
cmoveq %rdx, %rbx
cmpq %rax, %r9
movq %rcx, (%rdi)
movq %r8, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movq %r11, 0x18(%rdi)
cmoveq %rdx, %rbx
movq %rbx, 0x20(%rdi)
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shll $0x6, %r12d
movb $0x0, (%rbp,%r12)
movl $0x1, %edi
callq 0x20b0
leaq 0x4d4e(%rip), %rsi      # 0x8cd8
movq %rax, %rdi
xorl %edx, %edx
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::snapshot_and_lock_all(std::integral_constant<bool, false>)
AllLocksManager snapshot_and_lock_all(normal_mode) {
    // all_locks_ should never decrease in size, so if it is non-empty now, it
    // will remain non-empty
    assert(!all_locks_.empty());
    auto first_locked = all_locks_.end();
    --first_locked;
    auto current_locks = first_locked;
    while (current_locks != all_locks_.end()) {
      locks_t &locks = *current_locks;
      for (spinlock &lock : locks) {
        lock.lock();
      }
      ++current_locks;
    }
    // Once we have taken all the locks of the "current" container, nobody
    // else can do locking operations on the table.
    return AllLocksManager(this, AllUnlocker{first_locked});
  }

// Assembly:
pushq %rax
leaq 0x20(%rsi), %rax
cmpq %rax, 0x20(%rsi)
je 0x3fdd
movq 0x28(%rsi), %rcx
cmpq %rax, %rcx
je 0x3fd1
movq %rcx, %rdx
movq 0x10(%rdx), %r8
movq 0x18(%rdx), %r9
cmpq %r9, %r8
je 0x3fc9
movb $0x1, %r10b
xchgb %r10b, (%r8)
testb %r10b, %r10b
jne 0x3fb8
addq $0x40, %r8
jmp 0x3fb3
movq (%rdx), %rdx
cmpq %rax, %rdx
jne 0x3fab
movq %rcx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0x21c3(%rip), %rdi      # 0x61a7
leaq 0x1293(%rip), %rsi      # 0x527e
leaq 0x21c9(%rip), %rcx      # 0x61bb
movl $0x3d2, %edx            # imm = 0x3D2
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::maybe_resize_locks(unsigned long)
void maybe_resize_locks(size_type new_bucket_count) {
    locks_t &current_locks = get_current_locks();
    if (!(current_locks.size() < kMaxNumLocks &&
          current_locks.size() < new_bucket_count)) {
      return;
    }

    locks_t new_locks(std::min(size_type(kMaxNumLocks), new_bucket_count),
                      spinlock(), get_allocator());
    for (spinlock &lock : new_locks) {
      lock.lock();
    }
    assert(new_locks.size() > current_locks.size());
    std::copy(current_locks.begin(), current_locks.end(), new_locks.begin());
    all_locks_.emplace_back(std::move(new_locks));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
andq $-0x40, %rsp
subq $0xc0, %rsp
movq 0x28(%rdi), %r15
movq 0x18(%r15), %rax
subq 0x10(%r15), %rax
sarq $0x6, %rax
cmpq $0x10000, %rax          # imm = 0x10000
setae %cl
cmpq %rsi, %rax
setae %al
orb %cl, %al
jne 0x43ff
movq %rdi, %rbx
movl $0x10000, %eax          # imm = 0x10000
cmpq %rax, %rsi
cmovbq %rsi, %rax
leaq 0x40(%rsp), %rdx
movq $0x0, 0x8(%rdx)
xorl %ecx, %ecx
xchgb %cl, (%rdx)
leaq 0x20(%rsp), %r14
leaq 0x1f(%rsp), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2c9c
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x4377
movb $0x1, %dl
xchgb %dl, (%rax)
testb %dl, %dl
jne 0x435a
addq $0x40, %rax
cmpq %rcx, %rax
jne 0x435a
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rsi
jmp 0x437a
movq %rax, %rsi
subq %rax, %rsi
movq 0x10(%r15), %rcx
movq 0x18(%r15), %rdx
subq %rcx, %rdx
cmpq %rdx, %rsi
jbe 0x440a
sarq $0x6, %rdx
testq %rdx, %rdx
jle 0x43b3
incq %rdx
movl $0x8, %esi
movq (%rcx,%rsi), %rdi
movq %rdi, (%rax,%rsi)
decq %rdx
addq $0x40, %rsi
cmpq $0x1, %rdx
ja 0x439e
movl $0x28, %edi
callq 0x2150
leaq 0x20(%rbx), %rsi
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x20(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq %rax, %rdi
callq 0x2040
incq 0x30(%rbx)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x43ff
callq 0x2140
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2113(%rip), %rdi      # 0x6524
leaq 0xe66(%rip), %rsi       # 0x527e
leaq 0x212d(%rip), %rcx      # 0x654c
movl $0x6a3, %edx            # imm = 0x6A3
callq 0x20f0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x443b
callq 0x2140
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O3/conp-solutions[P]cnfmiter/AtLeastTwoSolutions.cc
// Function: generate_equivalence(CNFMITER::Formula&, CNFMITER::Lit, CNFMITER::Lit, CNFMITER::Lit)
void generate_equivalence(Formula &f, Lit a, Lit b, Lit c)
{
    static std::vector<Lit> C(3, a);

    C[0] = a;
    C[1] = b;
    C[2] = c;
    f.addClause_(C);

    C[0] = ~a;
    C[1] = ~b;
    C[2] = c;
    f.addClause_(C);

    C[0] = a;
    C[1] = ~b;
    C[2] = ~c;
    f.addClause_(C);

    C[0] = ~a;
    C[1] = b;
    C[2] = ~c;
    f.addClause_(C);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r13
movb 0x3cfd(%rip), %al       # 0x6198
testb %al, %al
je 0x2548
leaq 0x3cd6(%rip), %rsi      # 0x6180
movq 0x3ccf(%rip), %rax      # 0x6180
movl %r12d, (%rax)
movl %r14d, 0x4(%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %r13
movq %r13, %rdi
callq 0x3bd8
movl %r12d, %r15d
xorl $0x1, %r12d
movq 0x3cab(%rip), %rax      # 0x6180
movl %r12d, (%rax)
movl %r14d, -0x2c(%rbp)
xorl $0x1, %r14d
movl %r14d, 0x4(%rax)
movl %ebx, 0x8(%rax)
movq %r13, %rdi
leaq 0x3c8f(%rip), %rsi      # 0x6180
callq 0x3bd8
movq 0x3c83(%rip), %rax      # 0x6180
movl %r15d, (%rax)
movl %r14d, 0x4(%rax)
xorl $0x1, %ebx
movl %ebx, 0x8(%rax)
movq %r13, %rdi
leaq 0x3c6c(%rip), %r14      # 0x6180
movq %r14, %rsi
callq 0x3bd8
movq 0x3c5d(%rip), %rax      # 0x6180
movl %r12d, (%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl %ebx, 0x8(%rax)
movq %r13, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3bd8
leaq 0x3c49(%rip), %rdi      # 0x6198
callq 0x2280
testl %eax, %eax
je 0x24a3
xorps %xmm0, %xmm0
movups %xmm0, 0x3c1a(%rip)     # 0x6180
movq $0x0, 0x3c1f(%rip) # 0x6190
movl $0xc, %edi
callq 0x2180
movq %rax, 0x3bfe(%rip)      # 0x6180
movq %rax, %rcx
addq $0xc, %rcx
movq %rcx, 0x3c00(%rip)      # 0x6190
xorl %edx, %edx
movl %r12d, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0xc, %rdx
jne 0x2592
movq %rcx, 0x3be1(%rip)      # 0x6188
leaq 0x3bd2(%rip), %rsi      # 0x6180
leaq 0x158f(%rip), %rdi      # 0x3b44
leaq 0x3ba4(%rip), %rdx      # 0x6160
callq 0x2140
leaq 0x3bd0(%rip), %rdi      # 0x6198
callq 0x20e0
jmp 0x24a3
movq %rax, %rbx
leaq 0x3bbc(%rip), %rdi      # 0x6198
callq 0x20d0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/conp-solutions[P]cnfmiter/./ParseUtils.h
// Function: int CNFMITER::parseInt<CNFMITER::StreamBuffer>(CNFMITER::StreamBuffer&)
static int parseInt(B &in)
{
    int val = 0;
    bool neg = false;
    skipWhitespace(in);
    if (*in == '-')
        neg = true, ++in;
    else if (*in == '+')
        ++in;
    if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
    while (*in >= '0' && *in <= '9') val = val * 10 + (*in - '0'), ++in;
    return neg ? -val : val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3a40
movslq 0x100008(%rbx), %rax
cmpl 0x10000c(%rbx), %eax
jge 0x3ac1
movzbl 0x8(%rbx,%rax), %eax
cmpl $0x2d, %eax
je 0x3ac6
cmpl $0x2b, %eax
jne 0x3ac1
xorl %r14d, %r14d
jmp 0x3ac9
xorl %r14d, %r14d
jmp 0x3ad1
movb $0x1, %r14b
movq %rbx, %rdi
callq 0x3e7e
movl 0x100008(%rbx), %eax
cmpl 0x10000c(%rbx), %eax
jge 0x3b3a
movslq %eax, %rcx
movzbl 0x8(%rbx,%rcx), %edi
leal -0x3a(%rdi), %ecx
cmpb $-0xa, %cl
jb 0x3b3f
xorl %r15d, %r15d
cltq
movzbl 0x8(%rbx,%rax), %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x3b23
leal (%r15,%r15,4), %ecx
leal (%rax,%rcx,2), %r15d
addl $-0x30, %r15d
movq %rbx, %rdi
callq 0x3e7e
movl 0x100008(%rbx), %eax
cmpl 0x10000c(%rbx), %eax
jl 0x3af2
movl %r15d, %eax
negl %eax
testb %r14b, %r14b
cmovel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2335
// File: /workspace/github_cpp_makefile_star2_O3/m1c0l[P]http-client-server/HttpMessage.cpp
// Function: HttpMessage::decodeHeaderLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int HttpMessage::decodeHeaderLine(string line)
{
	string key, value;
	size_t i = 0;
	i = line.find(":");

	if (i == string::npos || i == 0 || i == line.size() - 1) {
		return 400;
	}

	key = line.substr(0, i);
	i++;
	while(line[i] == ' ')
		i++;
	value = line.substr(i, line.size());
	setHeader(key, value);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x474e(%rip), %rsi      # 0x9004
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x4530
movq %rax, %r15
incq %rax
movl $0x190, %ebp            # imm = 0x190
cmpq $0x2, %rax
jb 0x4a1c
movq 0x8(%r14), %rax
decq %rax
cmpq %rax, %r15
je 0x4a1c
movq %r12, %rbp
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x43a0
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %r12
movq %r12, %rsi
callq 0x4420
movq (%r12), %rdi
leaq 0x98(%rsp), %r12
cmpq %r12, %rdi
je 0x4938
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x4370
movq (%r14), %rax
cmpb $0x20, 0x1(%rax,%r15)
leaq 0x1(%r15), %r15
je 0x493b
movq 0x8(%r14), %rcx
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x43a0
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %r14
movq %r14, %rsi
callq 0x4420
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x498b
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x4370
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
movq %rbp, %r12
callq 0x50d2
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x50d2
addq $0x28, %rbx
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x5168
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x41c0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a03
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x68(%rsp), %rdi
xorl %ebp, %ebp
cmpq %r14, %rdi
je 0x4a1c
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4a33
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a4a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4370
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4a86
jmp 0x4a67
jmp 0x4a67
movq %rax, %rbx
jmp 0x4a9d
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a86
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x4a9d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4ab4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4acb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4370
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/m1c0l[P]http-client-server/web-server.cpp
// Function: codeToDescription[abi:cxx11](int)
string codeToDescription (int code)
{
	switch (code) {
		case 200:
			return "OK";
		case 400:
			return "Bad request";
		case 404:
			return "Not found";
		case 408:
			return "Request timeout";
		case 501:
			return "Not implemented";
		case 505:
			return "HTTP version not supported";
		default:
			perror("code number");
			return "";
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x197, %esi            # imm = 0x197
jg 0x6552
cmpl $0xc8, %esi
je 0x6581
cmpl $0x190, %esi            # imm = 0x190
je 0x65af
cmpl $0x194, %esi            # imm = 0x194
jne 0x65e8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2b43(%rip), %rsi      # 0x9089
leaq 0x2b45(%rip), %rdx      # 0x9092
jmp 0x65db
cmpl $0x198, %esi            # imm = 0x198
je 0x6598
cmpl $0x1f5, %esi            # imm = 0x1F5
je 0x65c6
cmpl $0x1f9, %esi            # imm = 0x1F9
jne 0x65e8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2b3b(%rip), %rsi      # 0x90b3
leaq 0x2b4e(%rip), %rdx      # 0x90cd
jmp 0x65db
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2aeb(%rip), %rsi      # 0x907a
leaq 0x2ae6(%rip), %rdx      # 0x907c
jmp 0x65db
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2aed(%rip), %rsi      # 0x9093
leaq 0x2af5(%rip), %rdx      # 0x90a2
jmp 0x65db
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2ac0(%rip), %rsi      # 0x907d
leaq 0x2ac4(%rip), %rdx      # 0x9088
jmp 0x65db
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2acf(%rip), %rsi      # 0x90a3
leaq 0x2ad7(%rip), %rdx      # 0x90b2
movq %rbx, %rdi
callq 0x55e8
movq %rbx, %rax
popq %rbx
retq
movq %rbx, %rdi
callq 0x45f1
jmp 0x65e3
// File: /workspace/github_cpp_makefile_star2_O3/m1c0l[P]http-client-server/web-server.cpp
// Function: int waitFor<long>(std::future<long>&)
int waitFor(future<T>& promise) {
  chrono::seconds timer(timeout);

  if (promise.wait_for(timer) == future_status::timeout) {
    cerr << "Connection timed out.\n"; 
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rax
movq %rsp, %rsi
movq $0xa, (%rsi)
callq 0x8a28
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x7845
movq 0x57c1(%rip), %rdi      # 0xcff0
leaq 0x1982(%rip), %rsi      # 0x91b8
movl $0x16, %edx
callq 0x4400
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jBlinden[P]private-codis/ProtocolClient.cpp
// Function: main
int main(int argc, const char **argv)
{
  if (argc < 5)
  {
    cout << "usage: ./ProtocolClient ProtocolArgsFile clientDataDir addr port" << endl;
    return 1;
  }

  srand(time(NULL));

  int port = atoi(argv[4]);

  string pArgsFile(argv[1]);
  string clientDataDir(argv[2]);

  StartClient(argv[3], port, pArgsFile, clientDataDir);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $0x4, %edi
jg 0x36ca
movq 0x5953(%rip), %rbx      # 0x8fd8
leaq 0x2d1b(%rip), %rsi      # 0x63a7
movl $0x40, %edx
movq %rbx, %rdi
callq 0x22c0
movq (%rbx), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movl $0x1, %eax
jmp 0x37ab
xorl %edi, %edi
movq %rsi, %r14
callq 0x2200
movl %eax, %edi
callq 0x2220
movq 0x20(%r14), %rdi
callq 0x2370
movq 0x8(%r14), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl %eax, %ebx
callq 0x2100
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2100
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x18(%r14), %r14
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x38aa
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x38aa
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x3255
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3774
callq 0x2210
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x3783
callq 0x2210
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3796
callq 0x2210
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37a9
callq 0x2210
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28(%rsp), %rdi
movq %rax, %rbx
cmpq %r12, %rdi
je 0x37d1
callq 0x2210
jmp 0x37d1
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x37e5
callq 0x2210
jmp 0x37e5
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37fd
callq 0x2210
jmp 0x37fd
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3810
callq 0x2210
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/jBlinden[P]private-codis/./socket.h
// Function: CSocket::Close()
void Close() {
    if (m_hSock == INVALID_SOCKET) {
      return;
    }
    
    shutdown(m_hSock, SHUT_WR);
    close(m_hSock);
  
    m_hSock = INVALID_SOCKET; 
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
cmpl $-0x1, %edi
je 0x383a
movl $0x1, %esi
callq 0x2320
movl (%rbx), %edi
callq 0x2460
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
popq %rbx
retq