LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rsi
shlq %cl, %rsi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x2aac
movq %rax, 0x10(%rbx)
pushq $0x24
popq %rax
movq 0x8(%rbx), %rcx
movq %r14, %rdx
shrq %cl, %rdx
testq %rdx, %rdx
jne 0x2a91
movq 0x10(%rbx), %rcx
andl $0x0, (%rcx,%rax)
incq %r14
addq $0x28, %rax
jmp 0x2a71
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movabsq $0x46a4a7935bd1e995, %r12 # imm = 0x46A4A7935BD1E995
pushq $-0x1
popq %r13
movq 0x10(%r15), %rcx
movq %r13, %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 0x2e9c
jmp 0x2d5c
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x2d69
callq 0x2090
callq 0x21e0
jmp 0x2d10
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x10(%rsp)
movq %r8, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rsp, %rax
movq %rdx, (%rax)
movb %cl, 0x8(%rax)
leaq 0x2286(%rip), %rbx      # 0x5020
leaq 0x18(%rsp), %rbp
movq 0x10(%r12), %r13
movq (%rsp), %rdx
movl 0x8(%rsp), %ecx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %r8
movq 0x10(%rsp), %r9
callq 0x2fb4
movl 0x10(%r15), %eax
cmpq $0x5, %rax
ja 0x2e2a
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
movq %r12, %rdi
movq %r13, %rsi
callq 0x3276
movq %rbp, %rdi
movq %r12, %rsi
movq %rsp, %rdx
callq 0x2cf0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3382
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2e03
movb $0x0, (%rax)
andq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x2d9f
movb $0x0, (%rax)
jmp 0x2d9f
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25c1(%rip), %rdi      # 0x53f2
leaq 0x2456(%rip), %rsi      # 0x528e
leaq 0x25b9(%rip), %rcx      # 0x53f8
movl $0x447, %edx            # imm = 0x447
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, 0x18(%rsp)
movl $0xffff, %r14d          # imm = 0xFFFF
movq %rcx, 0x10(%rsp)
andq %r14, %r15
movq %r8, 0x20(%rsp)
andq %r8, %r14
cmpq %r15, %r14
movq %r15, %r12
cmovbq %r14, %r12
movq 0x28(%rsi), %rbp
leaq 0x10(%rbp), %r13
shll $0x6, %r12d
movq 0x10(%rbp), %rdi
addq %r12, %rdi
callq 0x2f4c
addq 0x10(%rbp), %r12
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x2f56
cmpq %r15, %r14
je 0x2f1f
cmovaq %r14, %r15
shll $0x6, %r15d
addq (%r13), %r15
movq %r15, %rdi
callq 0x2f4c
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x2f7e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r13
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
imulq $0x28, %r8, %rsi
addq 0x18(%r12), %rsi
movq %r12, %rdi
movl %ecx, %edx
movq %r15, %rcx
callq 0x4066
cmpl $-0x1, %eax
je 0x35ae
movq %r13, (%rbx)
jmp 0x35ce
imulq $0x28, %r14, %rsi
addq 0x18(%r12), %rsi
movzbl %bpl, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x4066
cmpl $-0x1, %eax
je 0x35eb
movq %r14, (%rbx)
cltq
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movl %eax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
pushq $0x2
popq %rax
jmp 0x35d6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rsi), %rax
movzwl %cx, %r12d
shll $0x6, %r12d
addq 0x10(%rax), %r12
movq %r12, %rdi
callq 0x2f4c
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2f56
movq %r12, (%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e5d
jae 0x3e7c
leaq 0x1(%rcx), %rax
movq %rax, 0x2aa0(%rdi)
shlq $0x4, %rcx
movq (%rdi,%rcx), %rax
movq 0x8(%rdi,%rcx), %rdx
popq %rcx
retq
leaq 0x2163(%rip), %rdi      # 0x5fc7
leaq 0x1423(%rip), %rsi      # 0x528e
leaq 0x215e(%rip), %rcx      # 0x5fd0
movl $0x5c1, %edx            # imm = 0x5C1
callq 0x20f0
leaq 0x2257(%rip), %rdi      # 0x60da
leaq 0x1404(%rip), %rsi      # 0x528e
leaq 0x213f(%rip), %rcx      # 0x5fd0
movl $0x5c2, %edx            # imm = 0x5C2
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x38, %rsp
movq %r8, %r14
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
movl $0xffff, %eax           # imm = 0xFFFF
movq %rcx, 0x20(%rsp)
andq %rax, %rcx
movq %r8, 0x30(%rsp)
andq %rax, %r14
andq %rax, %r9
cmpq %r14, %r9
movq %r14, %rbx
cmovbq %r9, %rbx
movq %r14, %r13
movq %r9, 0x28(%rsp)
cmovaq %r9, %r13
cmpq %rcx, %r13
movq %rcx, %rbp
cmovbq %r13, %rbp
movq %rdi, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmovbeq %rcx, %r13
cmpq %rbp, %rbx
movq %rbp, %r15
cmovbq %rbx, %r15
movq 0x28(%rsi), %r12
shll $0x6, %r15d
movq 0x10(%r12), %rdi
addq %r15, %rdi
callq 0x2f4c
addq 0x10(%r12), %r15
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x2f56
cmpq %rbp, %rbx
cmovaq %rbx, %rbp
je 0x3f49
movl %ebp, %edi
shll $0x6, %edi
addq 0x10(%r12), %rdi
callq 0x2f4c
cmpl %ebp, %r13d
je 0x3f5f
shll $0x6, %r13d
addq 0x10(%r12), %r13
movq %r13, %rdi
callq 0x2f4c
movq 0x10(%r12), %rax
movq 0x10(%rsp), %r9
movl %r9d, %ecx
shll $0x6, %ecx
addq %rax, %rcx
movl %r14d, %edx
shll $0x6, %edx
addq %rax, %rdx
movq 0x28(%rsp), %rdi
movl %edi, %esi
shll $0x6, %esi
addq %rax, %rsi
xorl %r8d, %r8d
cmpq %r14, %r9
cmoveq %r8, %rdx
cmpq %r14, %rdi
cmoveq %r8, %rsi
cmpq %r9, %rdi
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rdi, (%rax)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rdx, 0x18(%rax)
cmoveq %r8, %rsi
movq %rsi, 0x20(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/libcuckoo/./libcuckoo_bucket_container.hh
// Function: void libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::setKV<unsigned int, unsigned int>(unsigned long, unsigned long, unsigned char, unsigned int&&, 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:
imulq $0x28, %rsi, %rax
addq 0x10(%rdi), %rax
cmpb $0x1, 0x24(%rdx,%rax)
je 0x4046
movb %cl, 0x20(%rax,%rdx)
movl (%r8), %ecx
movl %ecx, (%rax,%rdx,8)
movl (%r9), %ecx
movl %ecx, 0x4(%rax,%rdx,8)
movb $0x1, 0x24(%rax,%rdx)
retq
pushq %rax
leaq 0x222e(%rip), %rdi      # 0x627c
leaq 0x1092(%rip), %rsi      # 0x50e7
leaq 0x2232(%rip), %rcx      # 0x628e
movl $0xc9, %edx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: int cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::try_read_from_bucket<unsigned int>(libcuckoo_bucket_container<unsigned int, unsigned int, std::allocator<std::pair<unsigned int const, unsigned int>>, unsigned char, 4ul>::bucket const&, unsigned char, unsigned int const&) const
int try_read_from_bucket(const bucket &b, const partial_t partial,
                           const K &key) const {
    // Silence a warning from MSVC about partial being unused if is_simple.
    (void)partial;
    for (int i = 0; i < static_cast<int>(slot_per_bucket()); ++i) {
      if (!b.occupied(i) || (!is_simple && partial != b.partial(i))) {
        continue;
      } else if (key_eq()(b.key(i), key)) {
        return i;
      }
    }
    return -1;
  }

// Assembly:
movl (%rcx), %edx
xorl %ecx, %ecx
pushq $-0x1
popq %rax
cmpq $0x4, %rcx
je 0x4086
cmpb $0x1, 0x24(%rsi,%rcx)
jne 0x407f
cmpl %edx, (%rsi,%rcx,8)
je 0x4084
incq %rcx
jmp 0x406d
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x20(%rsi), %r12
cmpq %r12, 0x20(%rsi)
je 0x40ee
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rbp
movq %rbp, (%rsp)
cmpq %r12, %rbp
je 0x40d1
movq 0x10(%rbp), %r15
movq 0x18(%rbp), %r13
cmpq %r13, %r15
je 0x40cb
movq %r15, %rdi
callq 0x2f4c
addq $0x40, %r15
jmp 0x40b8
movq (%rbp), %rbp
jmp 0x40ab
movq (%rsp), %rax
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2325(%rip), %rdi      # 0x641a
leaq 0x1192(%rip), %rsi      # 0x528e
leaq 0x232b(%rip), %rcx      # 0x642e
movl $0x3d2, %edx            # imm = 0x3D2
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
andq $-0x40, %rsp
subq $0xc0, %rsp
movq 0x28(%rdi), %r12
movq 0x18(%r12), %rax
subq 0x10(%r12), %rax
sarq $0x6, %rax
cmpq $0x10000, %rax          # imm = 0x10000
setae %cl
cmpq %rsi, %rax
setae %al
orb %cl, %al
jne 0x445d
movq %rdi, %rbx
movl $0x10000, %eax          # imm = 0x10000
cmpq %rax, %rsi
cmovbq %rsi, %rax
leaq 0x40(%rsp), %rdx
andq $0x0, 0x8(%rdx)
xorl %ecx, %ecx
xchgb %cl, (%rdx)
leaq 0x28(%rsp), %r15
leaq 0x27(%rsp), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq 0x2bec
movq (%r15), %r14
movq 0x8(%r15), %r15
cmpq %r15, %r14
je 0x441b
movq %r14, %rdi
callq 0x2f4c
addq $0x40, %r14
jmp 0x4408
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rax
subq %rdx, %rax
movq 0x10(%r12), %rdi
movq 0x18(%r12), %rsi
movq %rsi, %rcx
subq %rdi, %rcx
cmpq %rcx, %rax
jbe 0x446a
callq 0x4ed9
addq $0x20, %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ece
leaq 0x28(%rsp), %rdi
callq 0x290e
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2326(%rip), %rdi      # 0x6797
leaq 0xe16(%rip), %rsi       # 0x528e
leaq 0x2340(%rip), %rcx      # 0x67bf
movl $0x6a3, %edx            # imm = 0x6A3
callq 0x20f0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x290e
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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>::AllUnlocker::operator()(cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>*) const
void operator()(cuckoohash_map *map) const {
      for (auto it = first_locked; it != map->all_locks_.end(); ++it) {
        locks_t &locks = *it;
        for (spinlock &lock : locks) {
          lock.unlock();
        }
      }
    }

// Assembly:
movq (%rdi), %rax
addq $0x20, %rsi
cmpq %rsi, %rax
je 0x4fa9
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
cmpq %rdx, %rcx
je 0x4fa4
movb $0x0, (%rcx)
addq $0x40, %rcx
jmp 0x4f96
movq (%rax), %rax
jmp 0x4f89
retq
// File: /workspace/github_cpp_makefile_star2_O2/zengfenfei[P]codility/src/TapeEquilibrium.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	int n = A.size();
	vector<int> leftSums(n), rightSums(n);
	leftSums[0] = A[0];
	for (int i = 1; i < n; i++) {
		leftSums[i] = leftSums[i - 1] + A[i];
	}

	rightSums[n - 1] = A[n - 1];
	int minDiff = abs(leftSums[n - 2] - rightSums[n - 1]);
	for (int i = n - 2; i > 0; i--) {
		rightSums[i] = rightSums[i + 1] + A[i];
		int diff = abs(leftSums[i - 1] - rightSums[i]);
		if (diff < minDiff) {
			minDiff = diff;
		}
	}
	return minDiff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %r15
subq (%rdi), %r15
movq %r15, %r12
shrq $0x2, %r12
movslq %r12d, %rbx
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %rbx, %rsi
callq 0x1310
leaq -0x40(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %rbx, %rsi
callq 0x1310
shlq $0x1e, %r15
movq (%r14), %rax
movl (%rax), %edx
movq -0x58(%rbp), %rcx
movl %edx, (%rcx)
movslq %r12d, %rdx
pushq $0x1
popq %rsi
cmpq %rdx, %rsi
jge 0x1278
movl (%rax,%rsi,4), %edi
addl -0x4(%rcx,%rsi,4), %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
jmp 0x1264
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
addq %rdx, %r15
sarq $0x1e, %r15
movl (%rax,%r15), %edi
movq -0x40(%rbp), %rdx
movl %edi, (%rdx,%r15)
leal -0x2(%rbx), %esi
movl -0x8(%rcx,%rbx,4), %r8d
subl %edi, %r8d
movl %r8d, %ebx
negl %ebx
cmovsl %r8d, %ebx
testl %esi, %esi
jle 0x12d2
movl (%rax,%rsi,4), %edi
addl 0x4(%rdx,%rsi,4), %edi
movl %edi, (%rdx,%rsi,4)
movl -0x4(%rcx,%rsi,4), %r8d
decq %rsi
subl %edi, %r8d
movl %r8d, %edi
negl %edi
cmovsl %r8d, %edi
cmpl %ebx, %edi
cmovll %edi, %ebx
jmp 0x12a9
leaq -0x40(%rbp), %rdi
callq 0x139c
leaq -0x58(%rbp), %rdi
callq 0x139c
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x139c
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/map/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;
	std::map<uint32_t, uint32_t> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		z += ++h[get_key(n, x)];
	}
	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 $0x38, %rsp
movl %esi, %r14d
movl %edi, %ebp
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movl %edi, %r13d
subl $0x1, %r13d
jb 0x156d
movl %r14d, %edi
callq 0x128c
movl %eax, %r14d
movl %ebp, %edi
movl %eax, %esi
callq 0x12b7
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x15c2
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
addl %ecx, %ebx
incl %ebx
jmp 0x1537
movq 0x2a6c(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0x8(%rsp), %r14
movq 0x28(%r14), %rdx
leaq 0xaee(%rip), %rsi       # 0x2075
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1100
movl 0x28(%r14), %ebx
movq %r14, %rdi
callq 0x161c
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x161c
movq %rbx, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rdi, %r14
movl %esi, -0x2c(%rbp)
movb 0x4d9d(%rip), %al       # 0x7188
testb %al, %al
je 0x2495
leaq 0x4d76(%rip), %r12      # 0x7170
movq 0x4d6f(%rip), %rax      # 0x7170
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movl %r15d, 0x4(%rax)
movl %ebx, 0x8(%rax)
addq $0x8, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x3514
movl -0x2c(%rbp), %eax
xorl $0x1, %eax
movq 0x4d47(%rip), %rcx      # 0x7170
movl %eax, (%rcx)
movl %r15d, %r13d
xorl $0x1, %r13d
movl %r13d, 0x4(%rcx)
movl %ebx, 0x8(%rcx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3514
movq 0x4d25(%rip), %rax      # 0x7170
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movl %r13d, 0x4(%rax)
xorl $0x1, %ebx
movl %ebx, 0x8(%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3514
movl -0x2c(%rbp), %eax
xorl $0x1, %eax
movq 0x4cfe(%rip), %rcx      # 0x7170
movl %eax, (%rcx)
movl %r15d, 0x4(%rcx)
movl %ebx, 0x8(%rcx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3514
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4cec(%rip), %rdi      # 0x7188
callq 0x2260
testl %eax, %eax
je 0x23f3
leaq 0x4cc0(%rip), %rdi      # 0x7170
pushq $0x3
popq %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x2d(%rbp), %rcx
callq 0x33bc
leaq 0xf55(%rip), %rdi       # 0x341c
leaq 0x4ca2(%rip), %rsi      # 0x7170
leaq 0x4c7b(%rip), %rdx      # 0x7150
callq 0x2130
leaq 0x4ca7(%rip), %rdi      # 0x7188
callq 0x20d0
jmp 0x23f3
movq %rax, %rbx
leaq 0x4c93(%rip), %rdi      # 0x7188
callq 0x20c0
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/conp-solutions[P]cnfmiter/AtLeastTwoSolutions.cc
// Function: print_formula(CNFMITER::Formula&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print_formula(Formula &f, std::string s)
{
    std::cout << "c AtLeastTwoSolutions, Norbert Manthey, 2021" << std::endl;
    if (!s.empty()) std::cout << "c " << s << std::endl;
    std::cout << "c " << std::endl;
    std::cout << "p cnf " << f.nVars() << " " << f.clauses.size() << std::endl;
    for (const auto &c : f.clauses) {
        std::stringstream s;
        s << c;
        printf("%s 0\n", s.str().c_str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4a9d(%rip), %rdi      # 0x6fc0
leaq 0x1af6(%rip), %rsi      # 0x4020
callq 0x2160
movq %rax, %rdi
callq 0x20a0
cmpq $0x0, 0x8(%r14)
je 0x2564
movq 0x4a7b(%rip), %rdi      # 0x6fc0
leaq 0x1b01(%rip), %rsi      # 0x404d
callq 0x2160
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20a0
movq 0x4a55(%rip), %r14      # 0x6fc0
leaq 0x1adb(%rip), %rsi      # 0x404d
movq %r14, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
leaq 0x1ac7(%rip), %rsi      # 0x4050
movq %r14, %rdi
callq 0x2160
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2240
leaq 0x1adc(%rip), %rsi      # 0x407e
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x20e0
movq %rax, %rdi
callq 0x20a0
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
leaq -0x1d0(%rbp), %r12
leaq -0x48(%rbp), %r13
leaq 0x1a70(%rip), %rbx      # 0x4057
cmpq %r15, %r14
je 0x2636
movq %r12, %rdi
callq 0x2100
leaq -0x1c0(%rbp), %rdi
movq %r14, %rsi
callq 0x3426
movq %r13, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x21f0
movq -0x48(%rbp), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
movq %r13, %rdi
callq 0x2090
movq %r12, %rdi
callq 0x2110
addq $0x18, %r14
jmp 0x25e7
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x264a
movq %rax, %rbx
leaq -0x1d0(%rbp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 0x32a4
movslq 0x100008(%rbx), %rax
cmpl 0x10000c(%rbx), %eax
jge 0x3318
movzbl 0x8(%rbx,%rax), %eax
cmpl $0x2d, %eax
je 0x331d
cmpl $0x2b, %eax
jne 0x3318
xorl %r14d, %r14d
jmp 0x3320
xorl %r14d, %r14d
jmp 0x3328
movb $0x1, %r14b
movq %rbx, %rdi
callq 0x3910
movl 0x100008(%rbx), %eax
movl 0x10000c(%rbx), %ecx
cmpl %ecx, %eax
jge 0x3398
movslq %eax, %rdx
movzbl 0x8(%rbx,%rdx), %edx
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jb 0x339b
xorl %r15d, %r15d
cmpl %ecx, %eax
jge 0x3381
cltq
movzbl 0x8(%rbx,%rax), %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x3381
imull $0xa, %r15d, %ecx
leal (%rcx,%rax), %r15d
addl $-0x30, %r15d
movq %rbx, %rdi
callq 0x3910
movl 0x100008(%rbx), %eax
movl 0x10000c(%rbx), %ecx
jmp 0x334c
movl %r15d, %eax
negl %eax
testb %r14b, %r14b
cmovel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rdx
movq 0x3c26(%rip), %rax      # 0x6fc8
movq (%rax), %rdi
leaq 0x1085(%rip), %rsi      # 0x4431
xorl %eax, %eax
callq 0x21a0
pushq $0x3
popq %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x4844(%rip), %rsi      # 0x9004
movq %r14, %rdi
xorl %edx, %edx
callq 0x45c0
movq %rax, %r15
incq %rax
movl $0x190, %ebp            # imm = 0x190
cmpq $0x2, %rax
jb 0x48a6
movq 0x8(%r14), %rax
decq %rax
cmpq %rax, %r15
je 0x48a6
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x43a0
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %r12
movq %r12, %rsi
callq 0x4410
movq %r12, %rdi
callq 0x4170
movq (%r14), %rax
cmpb $0x20, 0x1(%rax,%r15)
leaq 0x1(%r15), %r15
je 0x4824
movq 0x8(%r14), %rcx
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x43a0
movq %rsp, %rdi
leaq 0x80(%rsp), %r14
movq %r14, %rsi
callq 0x4410
movq %r14, %rdi
callq 0x4170
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4480
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x4480
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x4748
leaq 0x40(%rsp), %rdi
callq 0x4170
leaq 0x60(%rsp), %rdi
callq 0x4170
xorl %ebp, %ebp
movq %rsp, %rdi
callq 0x4170
leaq 0x20(%rsp), %rdi
callq 0x4170
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4170
jmp 0x48dc
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x4170
jmp 0x48ef
jmp 0x48ec
jmp 0x48ec
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4170
leaq 0x20(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/m1c0l[P]http-client-server/HttpMessage.cpp
// Function: HttpMessage::decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int HttpMessage::decode(string encoded) {
	stringstream ss;
	ss << encoded;
	string line;

	size_t start = 0, end = 0;
	bool firstLine = true;

	// header
	while ((end = encoded.find(CRLF, start)) != string::npos) {
		line = encoded.substr(start, end - start);
		start = end + sizeof(CRLF) - 1;

		if (line.size() == 0 && !firstLine) // end of header
			break;

		if (firstLine) {
			int decodeStatus = decodeFirstLine(line);
			if (decodeStatus) {
				return decodeStatus;
			}
		}
		else {
			int decodeStatus = decodeHeaderLine(line);
			if (decodeStatus) {
				return decodeStatus;
			}
		}

		firstLine = false;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x4250
leaq 0xa0(%rsp), %rdi
movq %rbx, %rsi
callq 0x42f0
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movb $0x1, %r15b
leaq 0x70(%rsp), %r13
xorl %r14d, %r14d
movq %rbx, %rdi
leaq 0x4796(%rip), %rsi      # 0x90fc
movq %r14, %rdx
callq 0x45c0
cmpq $-0x1, %rax
je 0x4a19
movq %rax, %r12
movq %rax, %rcx
subq %r14, %rcx
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x43a0
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x4410
movq %r13, %rdi
callq 0x4170
cmpq $0x0, 0x18(%rsp)
setne %al
orb %r15b, %al
testb $0x1, %al
je 0x4a19
addq $0x2, %r12
testb $0x1, %r15b
je 0x49e0
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4480
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *(%rax)
jmp 0x49fd
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4480
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x4782
movl %eax, %ebp
movq %r15, %rdi
callq 0x4170
xorl %r15d, %r15d
movq %r12, %r14
testl %ebp, %ebp
je 0x495c
movl %ebp, %ebx
jmp 0x4a1b
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x4170
leaq 0x90(%rsp), %rdi
callq 0x4280
movl %ebx, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4a75
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x4a5f
jmp 0x4a68
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4170
jmp 0x4a6b
jmp 0x4a68
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
leaq 0x90(%rsp), %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/m1c0l[P]http-client-server/HttpMessage.cpp
// Function: HttpMessage::encode[abi:cxx11]()
string HttpMessage::encode() {
	string msg = "";
	msg += encodeFirstLine();
	for (auto header : m_headers) {
		msg += header.first + ": " + header.second + CRLF;
	}
	msg += CRLF;
	return msg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4656(%rip), %rsi      # 0x90fe
leaq 0x8(%rsp), %rdx
callq 0x4bfa
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r15, %r12
movq %r15, %rdi
callq 0x45a0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4170
addq $0x38, %r14
leaq 0x48(%rsp), %rbp
leaq 0x68(%rsp), %rbx
leaq 0x88(%rsp), %r13
movq (%r14), %r14
testq %r14, %r14
je 0x4b68
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x4c36
movq %rbp, %rdi
movq %r15, %rsi
leaq 0x4621(%rip), %rdx      # 0x9135
callq 0x4cae
movq %rbx, %rdi
movq %rbp, %rsi
leaq 0x28(%rsp), %rdx
callq 0x4c8f
movq %r13, %rdi
movq %rbx, %rsi
leaq 0x45c6(%rip), %rdx      # 0x90fc
callq 0x4c70
movq %r12, %rdi
movq %r13, %rsi
callq 0x45a0
movq %r13, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4170
movq %rbp, %rdi
callq 0x4170
movq %r15, %rdi
callq 0x4ce6
jmp 0x4af3
leaq 0x458d(%rip), %rsi      # 0x90fc
movq %r12, %r15
movq %r12, %rdi
callq 0x4570
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ba0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4170
jmp 0x4be7
movq %rax, %rbx
jmp 0x4bea
movq %rax, %rbx
jmp 0x4bd8
movq %rax, %rbx
jmp 0x4bce
movq %rax, %rbx
jmp 0x4bc4
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4170
leaq 0x68(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
leaq 0x8(%rsp), %rdi
callq 0x4ce6
jmp 0x4be7
movq %rax, %rbx
movq %r12, %r15
movq %r15, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/m1c0l[P]http-client-server/HttpResponse.cpp
// Function: HttpResponse::decodeFirstLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int HttpResponse::decodeFirstLine(string line) {
	stringstream ss;
	ss << line;

	string version, status, description;
	ss >> version >> status;
	ss.ignore(1000, ' ');
	getline(ss, description);

	setVersion(version);
	setStatus(status);
	setDescription(description);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x4250
leaq 0xd0(%rsp), %rdi
movq %r14, %rsi
callq 0x42f0
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq 0x30(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0xc0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4430
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4430
leaq 0xc0(%rsp), %rdi
pushq $0x20
popq %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x4230
leaq 0xc0(%rsp), %rdi
movq %rsp, %rsi
callq 0x4070
leaq 0xa0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4480
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdi
callq 0x472c
leaq 0xa0(%rsp), %rdi
callq 0x4170
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4480
leaq 0x60(%rbx), %rdi
leaq 0x80(%rsp), %rsi
callq 0x41e0
leaq 0x80(%rsp), %rdi
callq 0x4170
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x4480
subq $-0x80, %rbx
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x41e0
leaq 0x60(%rsp), %rdi
callq 0x4170
movq %rsp, %rdi
callq 0x4170
leaq 0x20(%rsp), %rdi
callq 0x4170
leaq 0x40(%rsp), %rdi
callq 0x4170
leaq 0xc0(%rsp), %rdi
callq 0x4280
xorl %eax, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x58ba
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
jmp 0x58ba
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x4170
jmp 0x58c9
movq %rax, %rbx
jmp 0x58e5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4170
leaq 0x20(%rsp), %rdi
callq 0x4170
leaq 0x40(%rsp), %rdi
callq 0x4170
leaq 0xc0(%rsp), %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1f9, %esi            # imm = 0x1F9
je 0x5aca
cmpl $0x190, %esi            # imm = 0x190
je 0x5a92
cmpl $0x194, %esi            # imm = 0x194
je 0x5aae
cmpl $0x198, %esi            # imm = 0x198
je 0x5abc
cmpl $0x1f5, %esi            # imm = 0x1F5
je 0x5aa0
cmpl $0xc8, %esi
jne 0x5ae7
leaq 0x35ef(%rip), %rsi      # 0x907a
leaq 0xf(%rsp), %rdx
jmp 0x5ad6
leaq 0x35e4(%rip), %rsi      # 0x907d
leaq 0xe(%rsp), %rdx
jmp 0x5ad6
leaq 0x35fc(%rip), %rsi      # 0x90a3
leaq 0xb(%rsp), %rdx
jmp 0x5ad6
leaq 0x35d4(%rip), %rsi      # 0x9089
leaq 0xd(%rsp), %rdx
jmp 0x5ad6
leaq 0x35d0(%rip), %rsi      # 0x9093
leaq 0xc(%rsp), %rdx
jmp 0x5ad6
leaq 0x35e2(%rip), %rsi      # 0x90b3
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x4bfa
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x35e0(%rip), %rdi      # 0x90ce
callq 0x42b0
leaq 0x3604(%rip), %rsi      # 0x90fe
leaq 0x9(%rsp), %rdx
jmp 0x5ad6
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7c3c
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x6620
movq 0x79df(%rip), %rdi      # 0xdff0
leaq 0x2ba0(%rip), %rsi      # 0x91b8
callq 0x4350
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x88, %rsp
cmpl $0x4, %edi
jg 0x3178
movq 0x5e7c(%rip), %rdi      # 0x8fd8
leaq 0x2fc8(%rip), %rsi      # 0x612b
callq 0x2250
movq %rax, %rdi
callq 0x2130
pushq $0x1
popq %rax
jmp 0x321a
xorl %edi, %edi
movq %rsi, %r14
callq 0x2220
movl %eax, %edi
callq 0x2240
movq 0x20(%r14), %rdi
callq 0x2380
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 0x18(%r14), %r14
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2340
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2340
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x2eb1
leaq 0x28(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
callq 0x2110
leaq 0x8(%rsp), %rdi
callq 0x2110
leaq 0x68(%rsp), %rdi
callq 0x2110
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
leaq 0x28(%rsp), %rdi
movq %rax, %rbx
callq 0x2110
jmp 0x3237
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2110
jmp 0x3246
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
jmp 0x3255
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3339
pushq $0x1
popq %rsi
callq 0x2330
movl (%rbx), %edi
callq 0x2430
orl $-0x1, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jBlinden[P]private-codis/protocol.cpp
// Function: Listen(CSocket*, int)
bool Listen(CSocket *socket, int port)
{
  if (!socket->Socket())
  {
    return false;
  }

  if (!socket->Bind((uint16_t)port))
  {
    return false;
  }

  if (!socket->Listen())
  {
    return false;
  }

  CSocket sock;
  if (!socket->Accept(sock))
  {
    return false;
  }

  socket->AttachFrom(sock);
  sock.Detach();

  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4a4c
testb %al, %al
je 0x3459
leaq 0x20(%rsp), %r14
leaq 0x2d34(%rip), %rsi      # 0x612a
movq %rsp, %rdx
movq %r14, %rdi
callq 0x2100
movzwl %bp, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4a6e
leaq 0x20(%rsp), %rdi
movl %eax, %ebp
callq 0x2110
testb %bpl, %bpl
je 0x3459
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x4b18
testb %al, %al
je 0x3459
movq %rsp, %rsi
orl $-0x1, (%rsi)
andq $0x0, 0x18(%rsi)
vxorps %xmm0, %xmm0, %xmm0
movq %rbx, %rdi
vmovups %xmm0, 0x8(%rsi)
callq 0x4b28
testb %al, %al
setne %al
je 0x345b
movl (%rsp), %ecx
movl %ecx, (%rbx)
jmp 0x345b
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x20(%rsp), %rdi
movq %rax, %rbx
callq 0x2110
movq %rbx, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O2/jBlinden[P]private-codis/protocol.cpp
// Function: Connect(CSocket*, char const*, int)
bool Connect(CSocket *socket, const char *address, int port)
{
  for (auto i = 0; i < 1000; i++)
  {
    if (!socket->Socket())
    {
      return false;
    }
    if (socket->Connect(address, (uint16_t)port, TIMEOUT_MS))
    {
      return true;
    }
    usleep(20);
  }

  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %r15
movzwl %dx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $0x3e8, %r13d           # imm = 0x3E8
je 0x34f2
movq %r14, %rdi
callq 0x4a4c
testb %al, %al
je 0x34ec
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2100
movl $0x2710, %ecx           # imm = 0x2710
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4b42
movq %r15, %rdi
movl %eax, %r12d
callq 0x2110
testb %r12b, %r12b
jne 0x34f0
pushq $0x14
popq %rdi
callq 0x2350
incl %r13d
jmp 0x3498
xorl %ecx, %ecx
jmp 0x34f2
movb $0x1, %cl
cmpl $0x3e8, %r13d           # imm = 0x3E8
setb %al
andb %cl, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x2110
movq %rbx, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O2/jBlinden[P]private-codis/protocol.cpp
// Function: SenderOTCorrelation::ReadFromFile(std::basic_ifstream<char, std::char_traits<char>>&, unsigned char)
void SenderOTCorrelation::ReadFromFile(ifstream &fin, uint8_t bitsPerFSM)
{
  fin.read((char *)&N, sizeof(N));
  fin.read((char *)&K, sizeof(K));

  blindingFactors = new uint8_t[K * N];

  if (store_sOT_as_key == 1){

    uint8_t keyBuf[AESContext::AES_KEY_LEN];
    fin.read((char *)keyBuf, AESContext::AES_KEY_LEN);

    msgKey.Init(keyBuf);

    msgKey.FillBuffer((uint8_t *)blindingFactors, N * K * sizeof(uint8_t), 0);
  }
  else{
    uint64_t packedLength = packLength(N * K, bitsPerFSM);

    uint8_t *packedBlindingFactors = new uint8_t[packedLength];

    fin.read((char *)packedBlindingFactors, sizeof(uint8_t) * packedLength);

    Unpack(bitsPerFSM, N * K, packedBlindingFactors, blindingFactors);
    delete[] packedBlindingFactors;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movl %edx, %ebx
movq %rdi, %r14
leaq 0x4(%rdi), %rsi
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0x22f0
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x22f0
movzbl (%r14), %r12d
imull 0x4(%r14), %r12d
movq %r12, %rdi
callq 0x2030
movl %ebx, %r13d
imulq %r12, %r13
movq %rax, 0x120(%r14)
addq $0x7, %r13
shrq $0x3, %r13
movq %r13, %rdi
callq 0x2030
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x22f0
movzbl (%r14), %esi
movq 0x120(%r14), %rcx
movl %ebx, %edi
movq %r12, %rdx
imull 0x4(%r14), %esi
callq 0x4105
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2300
nop