LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_head()
auto test_head() -> void {
  using Prelude::head;
  auto expect = 1;
  auto result = head(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x749e(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0x2bb4
movl (%rdi), %ebx
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0x1, %ebx
jne 0x2bd3
addq $0x30, %rsp
popq %rbx
retq
leaq 0x7b33(%rip), %rdi      # 0xa6ee
leaq 0x7b54(%rip), %rsi      # 0xa716
leaq 0x7b59(%rip), %rcx      # 0xa722
movl $0x40, %edx
callq 0x2090
leaq 0x74c6(%rip), %rdi      # 0xa0a0
leaq 0x748e(%rip), %rsi      # 0xa06f
leaq 0x74fd(%rip), %rcx      # 0xa0e5
movl $0x2d, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_last()
auto test_last() -> void {
  using Prelude::last;
  auto expect = 4;
  auto result = last(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x7412(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rdi, %rax
je 0x2c49
movl -0x4(%rax), %ebx
testq %rdi, %rdi
je 0x2c3e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0x4, %ebx
jne 0x2c68
addq $0x30, %rsp
popq %rbx
retq
leaq 0x7a9e(%rip), %rdi      # 0xa6ee
leaq 0x7abf(%rip), %rsi      # 0xa716
leaq 0x7b25(%rip), %rcx      # 0xa783
movl $0x47, %edx
callq 0x2090
leaq 0x7431(%rip), %rdi      # 0xa0a0
leaq 0x73f9(%rip), %rsi      # 0xa06f
leaq 0x7479(%rip), %rcx      # 0xa0f6
movl $0x34, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_tail()
auto test_tail() -> void {
  using Prelude::tail;
  auto expect = std::vector<int>{2, 3, 4};
  auto result = tail(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movabsq $0x300000002, %rax      # imm = 0x300000002
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movl $0x4, 0x8(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x3, %edx
callq 0x7016
movaps 0x7350(%rip), %xmm0     # 0xa010
leaq 0x50(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
callq 0x7016
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x70a7
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d02
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x2d67
cmpq %rbx, %rax
je 0x2d35
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x2d67
testq %rbx, %rbx
je 0x2d4a
movq 0x48(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2d61
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x60, %rsp
popq %rbx
retq
leaq 0x7332(%rip), %rdi      # 0xa0a0
leaq 0x72fa(%rip), %rsi      # 0xa06f
leaq 0x738b(%rip), %rcx      # 0xa107
movl $0x3b, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2da5
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x2da5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2dbc
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_init()
auto test_init() -> void {
  using Prelude::init;
  auto expect = std::vector<int>{1, 2, 3};
  auto result = init(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x3, %edx
callq 0x7016
movaps 0x7213(%rip), %xmm0     # 0xa010
leaq 0x50(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
callq 0x7016
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x70f4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2e3f
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x2ea4
cmpq %rbx, %rax
je 0x2e72
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x2ea4
testq %rbx, %rbx
je 0x2e87
movq 0x48(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2e9e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x60, %rsp
popq %rbx
retq
leaq 0x71f5(%rip), %rdi      # 0xa0a0
leaq 0x71bd(%rip), %rsi      # 0xa06f
leaq 0x725f(%rip), %rcx      # 0xa118
movl $0x42, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2ee2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x2ee2
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2ef9
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_reverse()
auto test_reverse() -> void {
  using Prelude::reverse;
  auto expect = std::vector<int>{4, 3, 2, 1};
  auto result = reverse(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movaps 0x6fa3(%rip), %xmm0     # 0xa020
leaq 0x38(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x4, %edx
callq 0x7016
movaps 0x6f70(%rip), %xmm0     # 0xa010
leaq 0x50(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
callq 0x7016
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7141
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x30e2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x3147
cmpq %rbx, %rax
je 0x3115
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x3147
testq %rbx, %rbx
je 0x312a
movq 0x48(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3141
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x60, %rsp
popq %rbx
retq
leaq 0x6f52(%rip), %rdi      # 0xa0a0
leaq 0x6f1a(%rip), %rsi      # 0xa06f
leaq 0x706e(%rip), %rcx      # 0xa1ca
movl $0x5a, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3185
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x3185
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x319c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_foldl()
auto test_foldl() -> void {
  using Prelude::foldl;
  auto expect = 10;
  auto result = foldl([](int acc, int x) { return acc + x; }, 0,
                      std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x6e60(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
xorl %ebx, %ebx
cmpq %rax, %rdi
je 0x31f1
movq %rdi, %rcx
addl (%rcx), %ebx
addq $0x4, %rcx
cmpq %rax, %rcx
jne 0x31e0
cmpl $0xa, %ebx
sete %bl
testq %rdi, %rdi
je 0x3203
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
testb %bl, %bl
je 0x320d
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6e8c(%rip), %rdi      # 0xa0a0
leaq 0x6e54(%rip), %rsi      # 0xa06f
leaq 0x6fbc(%rip), %rcx      # 0xa1de
movl $0x62, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_foldl1()
auto test_foldl1() -> void {
  using Prelude::foldl1;
  auto expect = 10;
  auto result = foldl1([](int acc, int x) { return acc + x; },
                       std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x6dd8(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rdi, %rax
je 0x328e
leaq 0x4(%rdi), %rcx
movl (%rdi), %ebx
cmpq %rax, %rcx
je 0x3276
addl (%rcx), %ebx
addq $0x4, %rcx
jmp 0x3269
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0xa, %ebx
jne 0x32ad
addq $0x30, %rsp
popq %rbx
retq
leaq 0x7459(%rip), %rdi      # 0xa6ee
leaq 0x747a(%rip), %rsi      # 0xa716
leaq 0x76c8(%rip), %rcx      # 0xa96b
movl $0x85, %edx
callq 0x2090
leaq 0x6dec(%rip), %rdi      # 0xa0a0
leaq 0x6db4(%rip), %rsi      # 0xa06f
leaq 0x6f2e(%rip), %rcx      # 0xa1f0
movl $0x6a, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_foldr()
auto test_foldr() -> void {
  using Prelude::foldr;
  auto expect = 10;
  auto result = foldr([](int x, int acc) { return x + acc; }, 0,
                      std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
movaps 0x6d2b(%rip), %xmm0     # 0xa010
leaq 0x28(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x10(%rsp), %r14
leaq 0xb(%rsp), %rcx
movl $0x4, %edx
movq %r14, %rdi
callq 0x7016
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3376
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3328
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0xa, %ebx
jne 0x3335
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x6d64(%rip), %rdi      # 0xa0a0
leaq 0x6d2c(%rip), %rsi      # 0xa06f
leaq 0x6eb9(%rip), %rcx      # 0xa203
movl $0x72, %edx
callq 0x2090
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x336e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/./prelude.h
// Function: int Prelude::foldr<test_foldr()::$_0, int, std::vector, int, std::allocator<int>>(test_foldr()::$_0 const&, int&&, std::vector<int, std::allocator<int>> const&)
auto foldr(const FN& f, B&& acc, const CN<A, AllocA>& c) -> B {
  // One way to do this is assuming a BidirIt and iterating the Container back
  // to front. The following is a more general approach that probably entails a
  // lot of copies. To be benchmarked!
  if (null(c)) {
    return std::forward<B>(acc);
  }
  return f(head(c),
           foldr<FN, B, CN, A, AllocA>(f, std::forward<B>(acc), tail(c)));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x33c1
movl (%rax), %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x70a7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3376
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x33bd
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addl %ebp, %ebx
jmp 0x33c3
movl (%rbx), %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x33e8
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_foldr1()
auto test_foldr1() -> void {
  using Prelude::foldr1;
  auto expect = 10;
  auto result = foldr1([](int x, int acc) { return x + acc; },
                       std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x6c14(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq %rbx, %rdi
callq 0x3488
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x343c
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0xa, %ebx
jne 0x3447
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6c52(%rip), %rdi      # 0xa0a0
leaq 0x6c1a(%rip), %rsi      # 0xa06f
leaq 0x6db9(%rip), %rcx      # 0xa215
movl $0x7a, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3480
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_any()
auto test_any() -> void {
  using Prelude::any;
  assert(any([](int x) { return x > 3; }, std::vector<int>{1, 2, 3, 4}) ==
         true);
  assert(any([](int x) { return x > 5; }, std::vector<int>{1, 2, 3, 4}) ==
         false);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x673d(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
movq %rdi, %rcx
testq %rsi, %rsi
jle 0x3943
andq $-0x10, %rdx
movq %rdx, %rcx
addq %rdi, %rcx
incq %rsi
leaq 0x8(%rdi), %rdx
cmpl $0x3, -0x8(%rdx)
jg 0x3980
cmpl $0x3, -0x4(%rdx)
jg 0x3986
cmpl $0x3, (%rdx)
jg 0x3990
cmpl $0x3, 0x4(%rdx)
jg 0x398c
decq %rsi
addq $0x10, %rdx
cmpq $0x1, %rsi
jg 0x391f
movq %rax, %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
cmpq $0x1, %rsi
je 0x3974
cmpq $0x2, %rsi
je 0x396b
movq %rax, %rdx
cmpq $0x3, %rsi
jne 0x3990
cmpl $0x3, (%rcx)
jg 0x397b
addq $0x4, %rcx
cmpl $0x3, (%rcx)
jg 0x397b
addq $0x4, %rcx
cmpl $0x4, (%rcx)
cmovlq %rax, %rcx
movq %rcx, %rdx
jmp 0x3990
addq $-0x8, %rdx
jmp 0x3990
addq $-0x4, %rdx
jmp 0x3990
addq $0x4, %rdx
cmpq %rax, %rdx
je 0x3a8c
testq %rdi, %rdi
je 0x39ab
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
leaq 0x20(%rsp), %rsi
movaps 0x6659(%rip), %xmm0     # 0xa010
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
movq %rdi, %rcx
testq %rsi, %rsi
jle 0x3a22
andq $-0x10, %rdx
movq %rdx, %rcx
addq %rdi, %rcx
incq %rsi
leaq 0x8(%rdi), %rdx
cmpl $0x5, -0x8(%rdx)
jg 0x3a5f
cmpl $0x5, -0x4(%rdx)
jg 0x3a65
cmpl $0x5, (%rdx)
jg 0x3a6f
cmpl $0x5, 0x4(%rdx)
jg 0x3a6b
decq %rsi
addq $0x10, %rdx
cmpq $0x1, %rsi
jg 0x39fe
movq %rax, %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
cmpq $0x1, %rsi
je 0x3a53
cmpq $0x2, %rsi
je 0x3a4a
movq %rax, %rdx
cmpq $0x3, %rsi
jne 0x3a6f
cmpl $0x5, (%rcx)
jg 0x3a5a
addq $0x4, %rcx
cmpl $0x5, (%rcx)
jg 0x3a5a
addq $0x4, %rcx
cmpl $0x6, (%rcx)
cmovlq %rax, %rcx
movq %rcx, %rdx
jmp 0x3a6f
addq $-0x8, %rdx
jmp 0x3a6f
addq $-0x4, %rdx
jmp 0x3a6f
addq $0x4, %rdx
cmpq %rax, %rdx
jne 0x3aab
testq %rdi, %rdi
je 0x3a86
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x30, %rsp
popq %rbx
retq
leaq 0x689d(%rip), %rdi      # 0xa330
leaq 0x65d5(%rip), %rsi      # 0xa06f
leaq 0x68d6(%rip), %rcx      # 0xa377
movl $0x8c, %edx
callq 0x2090
leaq 0x68d5(%rip), %rdi      # 0xa387
leaq 0x65b6(%rip), %rsi      # 0xa06f
leaq 0x68b7(%rip), %rcx      # 0xa377
movl $0x8e, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_all()
auto test_all() -> void {
  using Prelude::all;
  assert(all([](int x) { return x > 3; }, std::vector<int>{1, 2, 3, 4}) ==
         false);
  assert(all([](int x) { return x < 5; }, std::vector<int>{1, 2, 3, 4}) ==
         true);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x653a(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
movq %rdi, %rcx
testq %rsi, %rsi
jle 0x3b46
andq $-0x10, %rdx
movq %rdx, %rcx
addq %rdi, %rcx
incq %rsi
leaq 0x8(%rdi), %rdx
cmpl $0x4, -0x8(%rdx)
jl 0x3b83
cmpl $0x4, -0x4(%rdx)
jl 0x3b89
cmpl $0x4, (%rdx)
jl 0x3b93
cmpl $0x4, 0x4(%rdx)
jl 0x3b8f
decq %rsi
addq $0x10, %rdx
cmpq $0x1, %rsi
jg 0x3b22
movq %rax, %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
cmpq $0x1, %rsi
je 0x3b77
cmpq $0x2, %rsi
je 0x3b6e
movq %rax, %rdx
cmpq $0x3, %rsi
jne 0x3b93
cmpl $0x4, (%rcx)
jl 0x3b7e
addq $0x4, %rcx
cmpl $0x4, (%rcx)
jl 0x3b7e
addq $0x4, %rcx
cmpl $0x4, (%rcx)
cmovgeq %rax, %rcx
movq %rcx, %rdx
jmp 0x3b93
addq $-0x8, %rdx
jmp 0x3b93
addq $-0x4, %rdx
jmp 0x3b93
addq $0x4, %rdx
cmpq %rax, %rdx
je 0x3c8f
testq %rdi, %rdi
je 0x3bae
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
leaq 0x20(%rsp), %rsi
movaps 0x6456(%rip), %xmm0     # 0xa010
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
movq %rdi, %rcx
testq %rsi, %rsi
jle 0x3c25
andq $-0x10, %rdx
movq %rdx, %rcx
addq %rdi, %rcx
incq %rsi
leaq 0x8(%rdi), %rdx
cmpl $0x4, -0x8(%rdx)
jg 0x3c62
cmpl $0x4, -0x4(%rdx)
jg 0x3c68
cmpl $0x4, (%rdx)
jg 0x3c72
cmpl $0x4, 0x4(%rdx)
jg 0x3c6e
decq %rsi
addq $0x10, %rdx
cmpq $0x1, %rsi
jg 0x3c01
movq %rax, %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
cmpq $0x1, %rsi
je 0x3c56
cmpq $0x2, %rsi
je 0x3c4d
movq %rax, %rdx
cmpq $0x3, %rsi
jne 0x3c72
cmpl $0x4, (%rcx)
jg 0x3c5d
addq $0x4, %rcx
cmpl $0x4, (%rcx)
jg 0x3c5d
addq $0x4, %rcx
cmpl $0x5, (%rcx)
cmovlq %rax, %rcx
movq %rcx, %rdx
jmp 0x3c72
addq $-0x8, %rdx
jmp 0x3c72
addq $-0x4, %rdx
jmp 0x3c72
addq $0x4, %rdx
cmpq %rax, %rdx
jne 0x3cae
testq %rdi, %rdi
je 0x3c89
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6739(%rip), %rdi      # 0xa3cf
leaq 0x63d2(%rip), %rsi      # 0xa06f
leaq 0x6773(%rip), %rcx      # 0xa417
movl $0x94, %edx
callq 0x2090
leaq 0x6772(%rip), %rdi      # 0xa427
leaq 0x63b3(%rip), %rsi      # 0xa06f
leaq 0x6754(%rip), %rcx      # 0xa417
movl $0x96, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_sum()
auto test_sum() -> void {
  using Prelude::sum;
  auto expect = 10;
  auto result = sum(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x6337(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
xorl %ebx, %ebx
cmpq %rax, %rdi
je 0x3d1a
movq %rdi, %rcx
addl (%rcx), %ebx
addq $0x4, %rcx
cmpq %rax, %rcx
jne 0x3d09
cmpl $0xa, %ebx
sete %bl
testq %rdi, %rdi
je 0x3d2c
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
testb %bl, %bl
je 0x3d36
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6363(%rip), %rdi      # 0xa0a0
leaq 0x632b(%rip), %rsi      # 0xa06f
leaq 0x6723(%rip), %rcx      # 0xa46e
movl $0x9d, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_product()
auto test_product() -> void {
  using Prelude::product;
  auto expect = 24;
  auto result = product(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x62af(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, %rdi
je 0x3da8
movl $0x1, %ecx
movq %rdi, %rdx
imull (%rdx), %ecx
addq $0x4, %rdx
cmpq %rax, %rdx
jne 0x3d94
cmpl $0x18, %ecx
sete %bl
jmp 0x3daa
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3dbc
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
testb %bl, %bl
je 0x3dc6
addq $0x30, %rsp
popq %rbx
retq
leaq 0x62d3(%rip), %rdi      # 0xa0a0
leaq 0x629b(%rip), %rsi      # 0xa06f
leaq 0x66a3(%rip), %rcx      # 0xa47e
movl $0xa4, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_concat()
auto test_concat() -> void {
  using Prelude::concat;
  auto expect = std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9};
  auto result = concat(
      std::array<std::vector<int>, 3>{{{1, 2, 3}, {4, 5}, {6, 7, 8, 9}}});
  assert(result == expect);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movups 0x6cf4(%rip), %xmm0     # 0xaaec
leaq 0x40(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0x6cd4(%rip), %xmm0     # 0xaadc
movaps %xmm0, (%rsi)
movl $0x9, 0x20(%rsi)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rcx
movl $0x9, %edx
callq 0x7016
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x94(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
leaq 0x40(%rsp), %r14
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x7016
leaq 0x58(%rsp), %rbx
movabsq $0x500000004, %rax      # imm = 0x500000004
leaq 0x8c(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xe(%rsp), %rcx
movl $0x2, %edx
movq %rbx, %rdi
callq 0x7016
leaq 0x70(%rsp), %rbx
movaps 0x619f(%rip), %xmm0     # 0xa030
leaq 0xa0(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0xd(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x7016
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x718e
movl $0x48, %ebx
movq 0x28(%rsp,%rbx), %rdi
testq %rdi, %rdi
je 0x3ed9
movq 0x38(%rsp,%rbx), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $-0x18, %rbx
jne 0x3ec2
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x3f4b
cmpq %rbx, %rax
je 0x3f12
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x3f4b
testq %rbx, %rbx
je 0x3f27
movq 0x38(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3f3e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x614e(%rip), %rdi      # 0xa0a0
leaq 0x6116(%rip), %rsi      # 0xa06f
leaq 0x6532(%rip), %rcx      # 0xa492
movl $0xac, %edx
callq 0x2090
movq %rax, %r15
leaq 0x88(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x22f5
movb $0x1, %al
jmp 0x3f94
jmp 0x3f85
movq %rax, %r15
xorl %eax, %eax
jmp 0x3f94
movq %rax, %r15
xorl %eax, %eax
movq %r14, %rbx
cmpq %rbx, %r14
sete %cl
orb %al, %cl
jne 0x3fc1
leaq 0x40(%rsp), %r14
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3fb8
movq -0x8(%rbx), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $-0x18, %rbx
cmpq %r14, %rbx
jne 0x3fa3
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3fd8
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %r15, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_concatMap()
auto test_concatMap() -> void {
  using Prelude::concatMap;
  auto expect = std::vector<int>{1, 1, 1, 2, 2, 2, 3, 3, 3};
  auto result = concatMap([](int x) {
    return std::vector<int>{x, x, x};
  }, std::list<int>{1, 2, 3});
  assert(result == expect);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movups 0x6b18(%rip), %xmm0     # 0xab10
leaq 0x40(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0x6af8(%rip), %xmm0     # 0xab00
movaps %xmm0, (%rsi)
movl $0x3, %ebx
movl %ebx, 0x20(%rsi)
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %r14
movl $0x9, %edx
movq %r14, %rcx
callq 0x7016
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0xbc(%rsp), %rsi
movq %rax, (%rsi)
movl %ebx, 0x8(%rsi)
leaq 0x88(%rsp), %rbx
leaq 0xe(%rsp), %rcx
movl $0x3, %edx
movq %rbx, %rdi
callq 0x723e
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %r14, 0x18(%rsp)
movq %r14, 0x10(%rsp)
movq 0x88(%rsp), %rbp
cmpq %rbx, %rbp
je 0x4128
leaq 0x40(%rsp), %r14
leaq 0x34(%rsp), %r15
leaq 0xf(%rsp), %r12
leaq 0x10(%rsp), %r13
movl 0x10(%rbp), %eax
movl %eax, 0x34(%rsp)
movl %eax, 0x38(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x7016
movl $0x28, %edi
callq 0x20e0
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x20(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq %rax, %rdi
movq %r13, %rsi
callq 0x2030
incq 0x20(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x411b
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq (%rbp), %rbp
cmpq %rbx, %rbp
jne 0x409c
leaq 0xa0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x89c5
leaq 0x10(%rsp), %rdi
callq 0x8a7a
movq 0x88(%rsp), %rdi
cmpq %rbx, %rdi
je 0x4166
movq (%rdi), %r14
movl $0x18, %esi
callq 0x20f0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x4151
movq 0xa0(%rsp), %rbx
movq 0xa8(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x41e3
cmpq %rbx, %rax
je 0x419f
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x41e3
testq %rbx, %rbx
je 0x41b7
movq 0xb0(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x41d1
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5eb6(%rip), %rdi      # 0xa0a0
leaq 0x5e7e(%rip), %rsi      # 0xa06f
leaq 0x62ad(%rip), %rcx      # 0xa4a5
movl $0xb5, %edx
callq 0x2090
jmp 0x4209
movq %rax, %r14
jmp 0x4254
movq %rax, %r14
jmp 0x4228
movq %rax, %r14
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4228
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
leaq 0x10(%rsp), %rdi
callq 0x8a7a
movq 0x88(%rsp), %rdi
cmpq %rbx, %rdi
je 0x4254
movq (%rdi), %r15
movl $0x18, %esi
callq 0x20f0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x423f
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x426e
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_maximum()
auto test_maximum() -> void {
  using Prelude::maximum;
  auto expect = 23;
  auto result = maximum(std::vector<int>{1, 2, 3, 23, 4, 5});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movups 0x68a2(%rip), %xmm0     # 0xab24
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $0x500000004, %rax      # imm = 0x500000004
movq %rax, 0x10(%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x6, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, %rdi
sete %dl
leaq 0x4(%rdi), %rcx
cmpq %rax, %rcx
sete %sil
orb %dl, %sil
movq %rdi, %rdx
jne 0x42ec
movq %rdi, %rsi
movl (%rsi), %r8d
movq %rcx, %rdx
cmpl (%rcx), %r8d
jl 0x42e0
movq %rsi, %rdx
addq $0x4, %rcx
movq %rdx, %rsi
cmpq %rax, %rcx
jne 0x42d2
movl (%rdx), %ebx
testq %rdi, %rdi
je 0x4300
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0x17, %ebx
jne 0x430b
addq $0x40, %rsp
popq %rbx
retq
leaq 0x5d8e(%rip), %rdi      # 0xa0a0
leaq 0x5d56(%rip), %rsi      # 0xa06f
leaq 0x619b(%rip), %rcx      # 0xa4bb
movl $0xbc, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_minimum()
auto test_minimum() -> void {
  using Prelude::minimum;
  auto expect = -23;
  auto result = minimum(std::vector<int>{1, 2, 3, 4, -23, 5});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movups 0x6806(%rip), %xmm0     # 0xab3c
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $0x5ffffffe9, %rax      # imm = 0x5FFFFFFE9
movq %rax, 0x10(%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x6, %edx
movq %rbx, %rdi
callq 0x7016
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, %rdi
sete %dl
leaq 0x4(%rdi), %rcx
cmpq %rax, %rcx
sete %sil
orb %dl, %sil
movq %rdi, %rdx
jne 0x43a0
movq %rdi, %rsi
movl (%rcx), %r8d
movq %rcx, %rdx
cmpl (%rsi), %r8d
jl 0x4394
movq %rsi, %rdx
addq $0x4, %rcx
movq %rdx, %rsi
cmpq %rax, %rcx
jne 0x4386
movl (%rdx), %ebx
testq %rdi, %rdi
je 0x43b4
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $-0x17, %ebx
jne 0x43bf
addq $0x40, %rsp
popq %rbx
retq
leaq 0x5cda(%rip), %rdi      # 0xa0a0
leaq 0x5ca2(%rip), %rsi      # 0xa06f
leaq 0x60fb(%rip), %rcx      # 0xa4cf
movl $0xc3, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_dropWhile()
auto test_dropWhile() -> void {
  using Prelude::dropWhile;
  auto expect = std::vector<int>{5, 6, 7, 8};
  auto result = dropWhile([](int x) { return x < 5; },
                          std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movaps 0x4e8b(%rip), %xmm0     # 0xa050
leaq 0x50(%rsp), %rbx
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rsi
callq 0x7016
movups 0x59d1(%rip), %xmm0     # 0xabbc
movaps %xmm0, 0x10(%rbx)
movups 0x59b6(%rip), %xmm0     # 0xabac
movaps %xmm0, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x6(%rsp), %rcx
movl $0x8, %edx
callq 0x7016
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rdx, %rax
subq %rsi, %rax
sarq $0x2, %rax
testq %rax, %rax
jle 0x5256
movq %rax, %rcx
shrq %rcx
movq %rcx, %rdi
notq %rdi
addq %rax, %rdi
leaq (%rsi,%rcx,4), %rax
addq $0x4, %rax
cmpl $0x5, -0x4(%rax)
cmovlq %rax, %rsi
cmovgeq %rcx, %rdi
movq %rdi, %rax
testq %rdi, %rdi
jg 0x522b
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x860a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x527c
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %rax
movq %rax, %rdx
subq %rbx, %rdx
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x52e1
cmpq %rbx, %rax
je 0x52af
movq %rbx, %rdi
callq 0x2100
testl %eax, %eax
jne 0x52e1
testq %rbx, %rbx
je 0x52c4
movq 0x48(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x52db
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x70, %rsp
popq %rbx
retq
leaq 0x4db8(%rip), %rdi      # 0xa0a0
leaq 0x4d80(%rip), %rsi      # 0xa06f
leaq 0x5294(%rip), %rcx      # 0xa58a
movl $0xff, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x531f
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x531f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5336
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_zip()
auto test_zip() -> void {
  using Prelude::zip;
  auto expect = std::vector<std::tuple<int, bool>>{std::make_tuple(1, true),
                                                   std::make_tuple(2, false),
                                                   std::make_tuple(3, true)};
  auto result =
      zip(std::vector<int>{1, 2, 3}, std::list<bool>{true, false, true});
  assert(result == expect);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movb $0x1, %al
leaq 0x40(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, 0x4(%rsi)
movb $0x0, 0x8(%rsi)
movl $0x2, 0xc(%rsi)
movb %al, 0x10(%rsi)
movl $0x3, %ebx
movl %ebx, 0x14(%rsi)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movl $0x3, %edx
callq 0x73a0
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x74(%rsp), %rsi
movq %rax, (%rsi)
movl %ebx, 0x8(%rsi)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rcx
movl $0x3, %edx
callq 0x7016
leaq 0xd(%rsp), %rsi
movw $0x1, (%rsi)
movb $0x1, 0x2(%rsi)
leaq 0x58(%rsp), %rdi
leaq 0xb(%rsp), %rcx
movl $0x3, %edx
callq 0x746e
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %r14
movq %r14, %rdx
callq 0x73e5
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x5baa
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x20f0
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x5b95
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5bc1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rsi
subq %rcx, %rsi
cmpq %rsi, %rdx
jne 0x5c26
cmpq %rax, %rdi
sete %sil
je 0x5c45
movl 0x4(%rdi), %edx
cmpl 0x4(%rcx), %edx
jne 0x5c26
movb (%rcx), %dl
cmpb %dl, (%rdi)
jne 0x5c26
leaq 0x8(%rdi), %rdx
addq $0xc, %rcx
cmpq %rax, %rdx
sete %sil
je 0x5c45
movl 0x4(%rdx), %esi
cmpl (%rcx), %esi
jne 0x5c26
leaq 0x8(%rdx), %rsi
movb -0x4(%rcx), %r8b
addq $0x8, %rcx
cmpb %r8b, (%rdx)
movq %rsi, %rdx
je 0x5c02
leaq 0x4473(%rip), %rdi      # 0xa0a0
leaq 0x443b(%rip), %rsi      # 0xa06f
leaq 0x4989(%rip), %rcx      # 0xa5c4
movl $0x11f, %edx            # imm = 0x11F
callq 0x2090
testb %sil, %sil
je 0x5c26
testq %rdi, %rdi
je 0x5c5c
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5c73
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x5ca7
movq (%rdi), %r15
movl $0x18, %esi
callq 0x20f0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x5c8d
jmp 0x5ca7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5cc3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x5cc3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5cda
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/test_prelude.cc
// Function: main
int main() {
  test_not_();
  // List operations
  test_map();
  test_join();
  test_filter();
  test_head();
  test_last();
  test_tail();
  test_init();
  test_null();
  test_at();
  test_reverse();
  // Reducing lists (folds)
  test_foldl();
  test_foldl1();
  test_foldr();
  test_foldr1();
  // Special folds
  test_and_();
  test_or_();
  test_any();
  test_all();
  test_sum();
  test_product();
  test_concat();
  test_concatMap();
  test_maximum();
  test_minimum();
  // Sublists
  test_take();
  test_drop();
  test_splitAt();
  test_takeWhile();
  test_dropWhile();
  test_span();
  test_break_();
  // Zipping and unzipping lists
  test_zip();
  test_zip3();
  test_zipWith();
  test_zipWith3();
  test_unzip();
  test_unzip3();

  std::cout << "Looking good!\n";
}

// Assembly:
pushq %rax
callq 0x24dc
callq 0x25d7
callq 0x27f4
callq 0x298e
callq 0x2b66
callq 0x2bf2
callq 0x2c87
callq 0x2dc4
callq 0x2f01
callq 0x2fda
callq 0x3071
callq 0x31a4
callq 0x322c
callq 0x32cc
callq 0x33f0
callq 0x3584
callq 0x3727
callq 0x38c7
callq 0x3aca
callq 0x3ccd
callq 0x3d55
callq 0x3de5
callq 0x3fe0
callq 0x4276
callq 0x432a
callq 0x43de
callq 0x4629
callq 0x48f6
callq 0x5031
callq 0x51b9
callq 0x533e
callq 0x573e
callq 0x5ae3
callq 0x5ce2
callq 0x5f4a
callq 0x61ac
callq 0x65c3
callq 0x69a7
movq 0x8076(%rip), %rdi      # 0xefd8
leaq 0x36e7(%rip), %rsi      # 0xa650
movl $0xe, %edx
callq 0x2110
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/./prelude.h
// Function: std::vector<int, std::allocator<int>> Prelude::concat<std::__cxx11::list<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>, std::vector<int, std::allocator<int>>>(std::__cxx11::list<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
auto concat(const _Container& c) -> Inner {
  auto res = Inner{};
  for (const auto _c : c) {
    res.insert(std::end(res), std::begin(_c), std::end(_c));
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq %rsi, %r12
je 0x8a30
movq %rsi, %r14
movq %rsp, %r15
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x809c
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x811c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8a27
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq (%r12), %r12
cmpq %r14, %r12
jne 0x89ef
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x8a5d
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8a5d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8a71
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/./prelude.h
// Function: std::vector<std::tuple<int, bool>, std::allocator<std::tuple<int, bool>>> Prelude::zip<std::vector, int, std::allocator<int>, std::__cxx11::list, bool, std::allocator<bool>, std::vector, std::tuple<int, bool>, std::allocator<std::tuple<int, bool>>>(std::vector<int, std::allocator<int>> const&, std::__cxx11::list<bool, std::allocator<bool>> const&)
auto zip(const CA<A, AllocA>& left, const CB<B, AllocB>& right)
    -> CRES<RES, AllocRES> {
  auto res = CRES<RES, AllocRES>{};
  auto l = std::begin(left);
  auto r = std::begin(right);
  while (l != std::end(left) && r != std::end(right)) {
    res.emplace_back(*l, *r);
    ++l;
    ++r;
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq (%rdx), %r13
cmpq 0x8(%rsi), %r12
setne %al
cmpq %rdx, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7441
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%r13), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8e08
addq $0x4, %r12
cmpq 0x8(%r15), %r12
je 0x7441
movq (%r13), %r13
cmpq %r14, %r13
jne 0x741f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7465
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/./prelude.h
// Function: std::tuple<std::vector<int, std::allocator<int>>, std::vector<bool, std::allocator<bool>>> Prelude::unzip<std::vector, std::tuple<int, bool>, std::allocator<std::tuple<int, bool>>, std::vector, int, std::allocator<int>, std::vector, bool, std::allocator<bool>>(std::vector<std::tuple<int, bool>, std::allocator<std::tuple<int, bool>>> const&)
auto unzip(const CN<TUP, AllocTUP>& c)
    -> std::tuple<CA<A, AllocA>, CB<B, AllocB>> {
  auto ca = CA<A, AllocA>{};
  auto cb = CB<B, AllocB>{};
  for (const auto& t : c) {
    // wanted to use emplace_back but not
    // available for vector<bool>, maybe use back_inserter...
    ca.push_back(std::get<0>(t));
    cb.push_back(std::get<1>(t));
  }
  return std::make_tuple(ca, cb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq (%rsi), %r14
movq 0x8(%rsi), %r13
cmpq %r13, %r14
je 0x7768
addq $0x4, %r14
leaq 0x30(%rsp), %r15
movq %rsp, %r12
movq 0x38(%rsp), %rsi
cmpq 0x40(%rsp), %rsi
je 0x7740
movl (%r14), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rsp)
jmp 0x774b
movq %r15, %rdi
movq %r14, %rdx
callq 0x83ea
movzbl -0x4(%r14), %esi
movq %r12, %rdi
callq 0x7c50
leaq 0x8(%r14), %rax
addq $0x4, %r14
cmpq %r13, %r14
movq %rax, %r14
jne 0x7724
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x9866
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x77a6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
xorl %eax, %eax
movq %rax, (%rsp)
movl %eax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x77bd
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x77d0
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7801
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
xorl %eax, %eax
movq %rax, (%rsp)
movl %eax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x7818
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]cpp-prelude/./prelude.h
// Function: std::tuple<std::vector<int, std::allocator<int>>, std::vector<char, std::allocator<char>>, std::vector<bool, std::allocator<bool>>> Prelude::unzip3<std::vector, std::tuple<int, char, bool>, std::allocator<std::tuple<int, char, bool>>, std::vector, int, std::allocator<int>, std::vector, char, std::allocator<char>, std::vector, bool, std::allocator<bool>>(std::vector<std::tuple<int, char, bool>, std::allocator<std::tuple<int, char, bool>>> const&)
auto unzip3(const CN<TUP, AllocTUP>& c)
    -> std::tuple<CA<A, AllocA>, CB<B, AllocB>, CC<C, AllocC>> {
  auto ca = CA<A, AllocA>{};
  auto cb = CB<B, AllocB>{};
  auto cc = CC<C, AllocC>{};
  for (const auto& t : c) {
    ca.push_back(std::get<0>(t));
    cb.push_back(std::get<1>(t));
    cc.push_back(std::get<2>(t));
  }
  return std::make_tuple(ca, cb, cc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq %rax, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq (%rsi), %r13
movq 0x8(%rsi), %rbp
cmpq %rbp, %r13
je 0x78d1
leaq 0x50(%rsp), %r14
leaq 0x30(%rsp), %r15
movq %rsp, %r12
leaq 0x4(%r13), %rdx
movq 0x58(%rsp), %rsi
cmpq 0x60(%rsp), %rsi
je 0x7890
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x58(%rsp)
jmp 0x7898
movq %r14, %rdi
callq 0x83ea
leaq 0x1(%r13), %rdx
movq 0x38(%rsp), %rsi
cmpq 0x40(%rsp), %rsi
je 0x78b3
movb (%rdx), %al
movb %al, (%rsi)
incq 0x38(%rsp)
jmp 0x78bb
movq %r15, %rdi
callq 0x9a1c
movzbl (%r13), %esi
movq %r12, %rdi
callq 0x7c50
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x7871
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x9b0e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7914
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
xorl %eax, %eax
movq %rax, (%rsp)
movl %eax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x792b
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x7942
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7956
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7987
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
xorl %eax, %eax
movq %rax, (%rsp)
movl %eax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x799e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x79b5
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/dns_db.cc
// Function: to_string[abi:cxx11](unsigned int, int)
std::string to_string(unsigned int n, int n_digits) {
	std::string r;
	while (n_digits-- > 0 || n > 0) {
		r = std::to_string(n%10) + r;
		n /= 10;
	}
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %edx, %edx
setle %al
testl %esi, %esi
sete %cl
testb %cl, %al
jne 0x3ca8
movl %edx, %ebp
movl %esi, %r14d
leaq 0x38(%rsp), %r12
movq %rsp, %r15
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x1, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x32a0
movl %r14d, %r13d
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %rax, %r13
shrq $0x23, %r13
leal (,%r13,2), %eax
leal (%rax,%rax,4), %eax
movl %r14d, %edx
subl %eax, %edx
movq (%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x474d
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x3090
movq %r12, 0x28(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3c3d
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x3c45
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0x32e0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3c79
callq 0x3220
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3c8c
callq 0x3220
cmpl $0x2, %ebp
setge %al
cmpl $0xa, %r14d
setae %cl
orb %al, %cl
decl %ebp
movl %r13d, %r14d
testb %cl, %cl
jne 0x3bc6
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3cd5
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3cd5
callq 0x3220
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x3ce4
callq 0x3220
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/dns_db.cc
// Function: DNS_DB::DomainIterator::~DomainIterator()
DNS_DB::DomainIterator::~DomainIterator() {
	for (unsigned int i = 0; i < db->iterators.size(); i++) {
		if (db->iterators[i] == this) {
			db->iterators.erase(db->iterators.begin()+i);
			break;
		}
	}
}

// Assembly:
pushq %rbx
movq 0x30(%rdi), %rbx
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rdx
movq %rdx, %rcx
subq %rax, %rcx
je 0x465a
sarq $0x3, %rcx
movl $0x1, %esi
xorl %r8d, %r8d
cmpq %rdi, (%rax,%r8,8)
je 0x4639
movl %esi, %r8d
incl %esi
cmpq %r8, %rcx
ja 0x4627
jmp 0x465a
leaq (%rax,%r8,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x4652
leaq (%rax,%r8,8), %rdi
subq %rsi, %rdx
callq 0x33b0
addq $-0x8, 0x90(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::lookupNode(char const*) const
int DNS_DB::DnsIndex::lookupNode(const char * domain) const {
	// Look for node which potentially has this domain
	int first = 0, last = nodes.size()-1;
	while (first <= last) {
		int middle = (first+last)>>1;
		const Node * n = &nodes[middle];
		if ( less_eq(n->min, domain) && less(domain, n->max) )
			return middle;
		else if less_eq(domain, n->min)
			last = middle - 1;
		else
			first = middle + 1;
	}
	assert(0 && "This should never occur\n");
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rax
subq %r15, %rax
shrq %rax
imull $0x914c1bad, %eax, %ebp # imm = 0x914C1BAD
decl %ebp
xorl %r13d, %r13d
cmpl %ebp, %r13d
jg 0x4a7b
leal (%r13,%rbp), %r12d
shrl %r12d
imulq $0x4a, %r12, %r14
addq %r15, %r14
movl $0x23, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
testl %eax, %eax
jg 0x4a40
leaq 0x23(%r14), %rsi
movl $0x23, %edx
movq %rbx, %rdi
callq 0x3110
testl %eax, %eax
jns 0x4a40
xorl %eax, %eax
movl %r12d, 0x4(%rsp)
jmp 0x4a64
movl $0x23, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
jle 0x4a5c
incl %r12d
movl %r12d, %r13d
jmp 0x4a62
decl %r12d
movl %r12d, %ebp
movb $0x1, %al
testb %al, %al
jne 0x49fa
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56a7(%rip), %rdi      # 0xa129
leaq 0x56c1(%rip), %rsi      # 0xa14a
leaq 0x56c7(%rip), %rcx      # 0xa157
movl $0x1c, %edx
callq 0x3180
// File: /workspace/github_cpp_makefile_star2_O1/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::DnsIndex(DNS_DB*)
DNS_DB::DnsIndex::DnsIndex(DNS_DB * db) : database(db) {
	Node n;
	n.dnsblock_id = 0;
	memset(n.min, 0, sizeof(n.min));
	memset(n.max,~0, sizeof(n.min));
	nodes.push_back(n);
	current_id = 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movdqa %xmm0, (%rsp)
movdqa %xmm0, 0x10(%rsp)
movl $0x0, 0x1f(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x42(%rsp)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x23(%rsp)
movdqu %xmm0, 0x33(%rsp)
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x4b06
movq %rsp, %rsi
movl $0x4a, %edx
movq %rax, %rdi
callq 0x3200
addq $0x4a, 0x8(%rbx)
jmp 0x4b14
movq %rsp, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5a3e
movl $0x1, 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4b33
callq 0x3220
movq %r14, %rdi
callq 0x3400
nop