LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_not_()
auto test_not_() -> void {
  using Prelude::not_;
  auto even = [](int x) { return x % 2 == 0; };
  auto odd = not_<int>(even);
  assert(odd(3) == true);
  assert(odd(2) == false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x1(%rbp), %rsi
callq 0x2530
movq -0x60(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xa7a0
jmp 0x2458
leaq -0x48(%rbp), %rdi
callq 0xa7e0
leaq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0xa800
movb %al, -0x61(%rbp)
jmp 0x2474
movb -0x61(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2483
jmp 0x24d0
leaq 0x1bde2(%rip), %rdi     # 0x1e26c
leaq 0x1bdea(%rip), %rsi     # 0x1e27b
movl $0xe, %edx
leaq 0x1bdee(%rip), %rcx     # 0x1e28b
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa7e0
jmp 0x2520
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa7e0
jmp 0x2520
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0xa800
movb %al, -0x62(%rbp)
jmp 0x24e3
movb -0x62(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x24f2
jmp 0x2511
leaq 0x1bda3(%rip), %rdi     # 0x1e29c
leaq 0x1bd7b(%rip), %rsi     # 0x1e27b
movl $0xf, %edx
leaq 0x1bd7f(%rip), %rcx     # 0x1e28b
callq 0x2110
leaq -0x28(%rbp), %rdi
callq 0xa7e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_map()
auto test_map() -> void {
  using Prelude::map;
  auto expect = std::vector<bool>{false, true, false, true, false};
  auto even = [](int x) { return x % 2 == 0; };
  auto result = map(even, std::vector<int>{1, 2, 3, 4, 5});
  assert(result == expect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb $0x0, -0x3d(%rbp)
movb $0x1, -0x3c(%rbp)
movb $0x0, -0x3b(%rbp)
movb $0x1, -0x3a(%rbp)
movb $0x0, -0x39(%rbp)
leaq -0x3d(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x5, -0x30(%rbp)
leaq -0x3e(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa840
movq -0xd0(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xa860
jmp 0x2619
leaq -0x3e(%rbp), %rdi
callq 0xa8e0
movups 0x1ba4b(%rip), %xmm0    # 0x1e074
movaps %xmm0, -0xc0(%rbp)
movl $0x5, -0xb0(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x5, -0x98(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xa900
movq -0xd8(%rbp), %rcx
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0xa920
jmp 0x2689
leaq -0x78(%rbp), %rdi
leaq -0x4d(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x2790
jmp 0x269f
leaq -0x90(%rbp), %rdi
callq 0xa9a0
leaq -0xc1(%rbp), %rdi
callq 0xaa00
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaa20
movb %al, -0xd9(%rbp)
jmp 0x26cc
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x26d8
jmp 0x26dd
jmp 0x275e
leaq 0x1bbc8(%rip), %rdi     # 0x1e2ac
leaq 0x1bb90(%rip), %rsi     # 0x1e27b
movl $0x17, %edx
leaq 0x1bbc6(%rip), %rcx     # 0x1e2bd
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x3e(%rbp), %rdi
callq 0xa8e0
jmp 0x2782
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xa9a0
leaq -0xc1(%rbp), %rdi
callq 0xaa00
jmp 0x2779
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xaae0
jmp 0x2779
leaq -0x78(%rbp), %rdi
callq 0xaae0
leaq -0x28(%rbp), %rdi
callq 0xaae0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0xaae0
movq -0x48(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_join()
auto test_join() -> void {
  using Prelude::join;
  auto expect = std::vector<int>{1, 2, 3, 4};
  auto result = join(std::vector<int>{1, 2}, std::vector<int>{3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x1, -0x38(%rbp)
movl $0x2, -0x34(%rbp)
movl $0x3, -0x30(%rbp)
movl $0x4, -0x2c(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x4, -0x20(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xa900
movq -0xe0(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x28e1
leaq -0x39(%rbp), %rdi
callq 0xaa00
movl $0x1, -0x98(%rbp)
movl $0x2, -0x94(%rbp)
leaq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x2, -0x88(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xa900
movq -0xe8(%rbp), %rcx
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0xa920
jmp 0x294a
movl $0x3, -0xd0(%rbp)
movl $0x4, -0xcc(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq $0x2, -0xc0(%rbp)
leaq -0xd1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xa900
movq -0xf0(%rbp), %rcx
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0xa920
jmp 0x29ad
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0xab00
jmp 0x29c3
leaq -0xb8(%rbp), %rdi
callq 0xa9a0
leaq -0xd1(%rbp), %rdi
callq 0xaa00
leaq -0x80(%rbp), %rdi
callq 0xa9a0
leaq -0x99(%rbp), %rdi
callq 0xaa00
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xf1(%rbp)
jmp 0x2a05
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x2a11
jmp 0x2a16
jmp 0x2abd
leaq 0x1b88f(%rip), %rdi     # 0x1e2ac
leaq 0x1b857(%rip), %rsi     # 0x1e27b
movl $0x1e, %edx
leaq 0x1b89d(%rip), %rcx     # 0x1e2cd
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xaa00
jmp 0x2ae1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2a98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2a83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xa9a0
leaq -0xd1(%rbp), %rdi
callq 0xaa00
leaq -0x80(%rbp), %rdi
callq 0xa9a0
leaq -0x99(%rbp), %rdi
callq 0xaa00
jmp 0x2ad8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa9a0
jmp 0x2ad8
leaq -0x68(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x48(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_filter()
auto test_filter() -> void {
  using Prelude::filter;
  auto expect = std::vector<int>{2, 4};
  auto even = [](int x) { return x % 2 == 0; };
  auto result = filter(even, std::vector<int>{1, 2, 3, 4, 5});
  assert(result == expect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x2, -0x30(%rbp)
movl $0x4, -0x2c(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x2, -0x20(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa900
movq -0xb0(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x2b43
leaq -0x31(%rbp), %rdi
callq 0xaa00
movups 0x1b535(%rip), %xmm0    # 0x1e088
movaps %xmm0, -0xa0(%rbp)
movl $0x5, -0x90(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x5, -0x80(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xa900
movq -0xb8(%rbp), %rcx
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0xa920
jmp 0x2baa
leaq -0x60(%rbp), %rdi
leaq -0x45(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x2ca0
jmp 0x2bbd
leaq -0x78(%rbp), %rdi
callq 0xa9a0
leaq -0xa1(%rbp), %rdi
callq 0xaa00
leaq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xb9(%rbp)
jmp 0x2be7
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x2bf3
jmp 0x2bf5
jmp 0x2c73
leaq 0x1b6b0(%rip), %rdi     # 0x1e2ac
leaq 0x1b678(%rip), %rsi     # 0x1e27b
movl $0x26, %edx
leaq 0x1b6cf(%rip), %rcx     # 0x1e2de
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0xaa00
jmp 0x2c97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2c4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xa9a0
leaq -0xa1(%rbp), %rdi
callq 0xaa00
jmp 0x2c8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa9a0
jmp 0x2c8e
leaq -0x60(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x40(%rbp), %rdi
callq 0x22b0
// File: kdungs[P]cpp-prelude/./prelude.h
// Function: std::vector<int, std::allocator<int>> Prelude::filter<test_filter()::$_0, std::vector, int, std::allocator<int>>(test_filter()::$_0 const&, std::vector<int, std::allocator<int>> const&)
auto filter(const PR& p, const CN<A, AllocA>& c) -> CN<A, AllocA> {
  auto res = CN<A, AllocA>{};
  res.reserve(c.size());
  std::copy_if(std::begin(c), std::end(c), std::back_inserter(res), p);
  res.shrink_to_fit();
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0xaf60
movq -0x18(%rbp), %rdi
callq 0x11230
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x12720
jmp 0x2cf0
movq -0x18(%rbp), %rdi
callq 0xf330
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf360
movq -0x60(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x12820
movq %rax, -0x70(%rbp)
jmp 0x2d19
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x8e00
movq %rax, -0x78(%rbp)
jmp 0x2d38
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x12850
jmp 0x2d4b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2d77
jmp 0x2d6e
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xa9a0
jmp 0x2d84
movq -0x60(%rbp), %rdi
callq 0xa9a0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x1, -0x4(%rbp)
movl $0x1, -0x40(%rbp)
movl $0x2, -0x3c(%rbp)
movl $0x3, -0x38(%rbp)
movl $0x4, -0x34(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x4, -0x28(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa900
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa920
jmp 0x2def
leaq -0x20(%rbp), %rdi
callq 0xac60
movl %eax, -0x64(%rbp)
jmp 0x2dfd
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
movl -0x64(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x2e1f
jmp 0x2e6c
leaq 0x1b486(%rip), %rdi     # 0x1e2ac
leaq 0x1b44e(%rip), %rsi     # 0x1e27b
movl $0x2d, %edx
leaq 0x1b4b8(%rip), %rcx     # 0x1e2f1
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2e61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
jmp 0x2e72
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x4, -0x4(%rbp)
movl $0x1, -0x40(%rbp)
movl $0x2, -0x3c(%rbp)
movl $0x3, -0x38(%rbp)
movl $0x4, -0x34(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x4, -0x28(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa900
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa920
jmp 0x2edf
leaq -0x20(%rbp), %rdi
callq 0xacd0
movl %eax, -0x64(%rbp)
jmp 0x2eed
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
movl -0x64(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x2f0f
jmp 0x2f5c
leaq 0x1b396(%rip), %rdi     # 0x1e2ac
leaq 0x1b35e(%rip), %rsi     # 0x1e27b
movl $0x34, %edx
leaq 0x1b3d9(%rip), %rcx     # 0x1e302
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2f51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
jmp 0x2f62
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x2, -0x34(%rbp)
movl $0x3, -0x30(%rbp)
movl $0x4, -0x2c(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x3, -0x20(%rbp)
leaq -0x35(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa900
movq -0xa8(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x2fca
leaq -0x35(%rbp), %rdi
callq 0xaa00
movl $0x1, -0x98(%rbp)
movl $0x2, -0x94(%rbp)
movl $0x3, -0x90(%rbp)
movl $0x4, -0x8c(%rbp)
leaq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x4, -0x80(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa900
movq -0xb0(%rbp), %rcx
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0xa920
jmp 0x3041
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xad40
jmp 0x3050
leaq -0x78(%rbp), %rdi
callq 0xa9a0
leaq -0x99(%rbp), %rdi
callq 0xaa00
leaq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xb1(%rbp)
jmp 0x307a
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x3086
jmp 0x3088
jmp 0x3106
leaq 0x1b21d(%rip), %rdi     # 0x1e2ac
leaq 0x1b1e5(%rip), %rsi     # 0x1e27b
movl $0x3b, %edx
leaq 0x1b271(%rip), %rcx     # 0x1e313
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x35(%rbp), %rdi
callq 0xaa00
jmp 0x312a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x30e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xa9a0
leaq -0x99(%rbp), %rdi
callq 0xaa00
jmp 0x3121
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa9a0
jmp 0x3121
leaq -0x60(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x40(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x1, -0x34(%rbp)
movl $0x2, -0x30(%rbp)
movl $0x3, -0x2c(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x3, -0x20(%rbp)
leaq -0x35(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa900
movq -0xa8(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x319a
leaq -0x35(%rbp), %rdi
callq 0xaa00
movl $0x1, -0x98(%rbp)
movl $0x2, -0x94(%rbp)
movl $0x3, -0x90(%rbp)
movl $0x4, -0x8c(%rbp)
leaq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x4, -0x80(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa900
movq -0xb0(%rbp), %rcx
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0xa920
jmp 0x3211
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xae40
jmp 0x3220
leaq -0x78(%rbp), %rdi
callq 0xa9a0
leaq -0x99(%rbp), %rdi
callq 0xaa00
leaq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xb1(%rbp)
jmp 0x324a
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x3256
jmp 0x3258
jmp 0x32d6
leaq 0x1b04d(%rip), %rdi     # 0x1e2ac
leaq 0x1b015(%rip), %rsi     # 0x1e27b
movl $0x42, %edx
leaq 0x1b0b2(%rip), %rcx     # 0x1e324
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x35(%rbp), %rdi
callq 0xaa00
jmp 0x32fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x32b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xa9a0
leaq -0x99(%rbp), %rdi
callq 0xaa00
jmp 0x32f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa9a0
jmp 0x32f1
leaq -0x60(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x40(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x4, -0x38(%rbp)
movl $0x3, -0x34(%rbp)
movl $0x2, -0x30(%rbp)
movl $0x1, -0x2c(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x4, -0x20(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa900
movq -0xb0(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x3721
leaq -0x39(%rbp), %rdi
callq 0xaa00
movl $0x1, -0xa0(%rbp)
movl $0x2, -0x9c(%rbp)
movl $0x3, -0x98(%rbp)
movl $0x4, -0x94(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x4, -0x88(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xa900
movq -0xb8(%rbp), %rcx
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0xa920
jmp 0x379e
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xb020
jmp 0x37ad
leaq -0x80(%rbp), %rdi
callq 0xa9a0
leaq -0xa1(%rbp), %rdi
callq 0xaa00
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xb9(%rbp)
jmp 0x37d7
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x37e3
jmp 0x37e5
jmp 0x3863
leaq 0x1aac0(%rip), %rdi     # 0x1e2ac
leaq 0x1aa88(%rip), %rsi     # 0x1e27b
movl $0x5a, %edx
leaq 0x1ac10(%rip), %rcx     # 0x1e40f
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xaa00
jmp 0x3887
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x383e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa9a0
leaq -0xa1(%rbp), %rdi
callq 0xaa00
jmp 0x387e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa9a0
jmp 0x387e
leaq -0x68(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x48(%rbp), %rdi
callq 0x22b0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0xa, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x1, -0x48(%rbp)
movl $0x2, -0x44(%rbp)
movl $0x3, -0x40(%rbp)
movl $0x4, -0x3c(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x4, -0x30(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa900
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xa920
jmp 0x38f6
leaq -0x9(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x3990
movl %eax, -0x6c(%rbp)
jmp 0x390c
leaq -0x28(%rbp), %rdi
callq 0xa9a0
leaq -0x49(%rbp), %rdi
callq 0xaa00
movl -0x6c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x392e
jmp 0x397b
leaq 0x1a977(%rip), %rdi     # 0x1e2ac
leaq 0x1a93f(%rip), %rsi     # 0x1e27b
movl $0x62, %edx
leaq 0x1aadb(%rip), %rcx     # 0x1e423
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3970
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa9a0
leaq -0x49(%rbp), %rdi
callq 0xaa00
jmp 0x3981
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0xa, -0x4(%rbp)
movl $0x1, -0x48(%rbp)
movl $0x2, -0x44(%rbp)
movl $0x3, -0x40(%rbp)
movl $0x4, -0x3c(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x4, -0x30(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa900
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xa920
jmp 0x3a3f
leaq -0x9(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3ad0
movl %eax, -0x6c(%rbp)
jmp 0x3a51
leaq -0x28(%rbp), %rdi
callq 0xa9a0
leaq -0x49(%rbp), %rdi
callq 0xaa00
movl -0x6c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x3a73
jmp 0x3ac0
leaq 0x1a832(%rip), %rdi     # 0x1e2ac
leaq 0x1a7fa(%rip), %rsi     # 0x1e27b
movl $0x6a, %edx
leaq 0x1a9a8(%rip), %rcx     # 0x1e435
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3ab5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa9a0
leaq -0x49(%rbp), %rdi
callq 0xaa00
jmp 0x3ac6
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22b0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0xa, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x1, -0x48(%rbp)
movl $0x2, -0x44(%rbp)
movl $0x3, -0x40(%rbp)
movl $0x4, -0x3c(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x4, -0x30(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa900
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xa920
jmp 0x3be6
leaq -0x9(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x3c80
movl %eax, -0x6c(%rbp)
jmp 0x3bfc
leaq -0x28(%rbp), %rdi
callq 0xa9a0
leaq -0x49(%rbp), %rdi
callq 0xaa00
movl -0x6c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x3c1e
jmp 0x3c6b
leaq 0x1a687(%rip), %rdi     # 0x1e2ac
leaq 0x1a64f(%rip), %rsi     # 0x1e27b
movl $0x72, %edx
leaq 0x1a810(%rip), %rcx     # 0x1e448
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3c60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa9a0
leaq -0x49(%rbp), %rdi
callq 0xaa00
jmp 0x3c71
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaf40
testb $0x1, %al
jne 0x3ca6
jmp 0x3cb4
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3d3b
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
callq 0xac60
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xad40
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x3c80
movl %eax, -0x48(%rbp)
jmp 0x3cff
movl -0x48(%rbp), %edx
movl -0x64(%rbp), %esi
movq -0x70(%rbp), %rdi
callq 0x8fb0
movl %eax, -0x74(%rbp)
jmp 0x3d13
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa9a0
jmp 0x3d3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa9a0
jmp 0x3d47
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22b0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0xa, -0x4(%rbp)
movl $0x1, -0x48(%rbp)
movl $0x2, -0x44(%rbp)
movl $0x3, -0x40(%rbp)
movl $0x4, -0x3c(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x4, -0x30(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa900
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xa920
jmp 0x3daf
leaq -0x9(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3e40
movl %eax, -0x6c(%rbp)
jmp 0x3dc1
leaq -0x28(%rbp), %rdi
callq 0xa9a0
leaq -0x49(%rbp), %rdi
callq 0xaa00
movl -0x6c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x3de3
jmp 0x3e30
leaq 0x1a4c2(%rip), %rdi     # 0x1e2ac
leaq 0x1a48a(%rip), %rsi     # 0x1e27b
movl $0x7a, %edx
leaq 0x1a65d(%rip), %rcx     # 0x1e45a
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3e25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa9a0
leaq -0x49(%rbp), %rdi
callq 0xaa00
jmp 0x3e36
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22b0
nop
// File: kdungs[P]cpp-prelude/./prelude.h
// Function: int Prelude::foldr1<test_foldr1()::$_0, std::vector, int, std::allocator<int>>(test_foldr1()::$_0 const&, std::vector<int, std::allocator<int>> const&)
auto foldr1(const FN& f, const CN<A, AllocA>& c) -> A {
  assert(c.size() && "Container can't be empty.");
  if (null(tail(c))) {
    return head(c);
  }
  return f(head(c), foldr1<FN, CN, A, AllocA>(f, tail(c)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11230
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x55(%rbp)
je 0x3e71
movb $0x1, %al
movb %al, -0x55(%rbp)
jmp 0x3e71
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x3e7a
jmp 0x3e7c
jmp 0x3e9b
leaq 0x1aae9(%rip), %rdi     # 0x1e96c
leaq 0x1ab0a(%rip), %rsi     # 0x1e994
movl $0x9b, %edx
leaq 0x1ae62(%rip), %rcx     # 0x1ecf8
callq 0x2110
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xad40
leaq -0x30(%rbp), %rdi
callq 0xaf40
movb %al, -0x56(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa9a0
movb -0x56(%rbp), %al
testb $0x1, %al
jne 0x3ec6
jmp 0x3ed7
movq -0x18(%rbp), %rdi
callq 0xac60
movl %eax, -0x4(%rbp)
jmp 0x3f58
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0xac60
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xad40
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x3e40
movl %eax, -0x5c(%rbp)
jmp 0x3f16
movl -0x5c(%rbp), %edx
movl -0x74(%rbp), %esi
movq -0x80(%rbp), %rdi
callq 0x8fd0
movl %eax, -0x84(%rbp)
jmp 0x3f2d
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa9a0
jmp 0x3f58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa9a0
jmp 0x3f64
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x1, -0x40(%rbp)
movl $0x2, -0x3c(%rbp)
movl $0x3, -0x38(%rbp)
movl $0x4, -0x34(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x4, -0x28(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa900
movq -0xa0(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa920
jmp 0x4391
leaq -0x1(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4530
movb %al, -0xa1(%rbp)
jmp 0x43a6
movb -0xa1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x43b8
jmp 0x4402
leaq 0x1a1b6(%rip), %rdi     # 0x1e575
leaq 0x19eb5(%rip), %rsi     # 0x1e27b
movl $0x8c, %edx
leaq 0x1a1ea(%rip), %rcx     # 0x1e5bc
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x44c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa9a0
jmp 0x44c2
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
movl $0x1, -0x90(%rbp)
movl $0x2, -0x8c(%rbp)
movl $0x3, -0x88(%rbp)
movl $0x4, -0x84(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq $0x4, -0x78(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa900
movq -0xb0(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0xa920
jmp 0x447c
leaq -0x55(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4570
movb %al, -0xb1(%rbp)
jmp 0x4491
movb -0xb1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x44a3
jmp 0x44f2
leaq 0x1a122(%rip), %rdi     # 0x1e5cc
leaq 0x19dca(%rip), %rsi     # 0x1e27b
movl $0x8e, %edx
leaq 0x1a0ff(%rip), %rcx     # 0x1e5bc
callq 0x2110
leaq -0x41(%rbp), %rdi
callq 0xaa00
jmp 0x451c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4510
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa9a0
jmp 0x4510
leaq -0x70(%rbp), %rdi
callq 0xa9a0
leaq -0x91(%rbp), %rdi
callq 0xaa00
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x91(%rbp), %rdi
callq 0xaa00
movq -0x50(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x1, -0x40(%rbp)
movl $0x2, -0x3c(%rbp)
movl $0x3, -0x38(%rbp)
movl $0x4, -0x34(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x4, -0x28(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa900
movq -0xa0(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa920
jmp 0x4611
leaq -0x1(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x47b0
movb %al, -0xa1(%rbp)
jmp 0x4626
movb -0xa1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4638
jmp 0x4682
leaq 0x19fd5(%rip), %rdi     # 0x1e614
leaq 0x19c35(%rip), %rsi     # 0x1e27b
movl $0x94, %edx
leaq 0x1a00a(%rip), %rcx     # 0x1e65c
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4742
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa9a0
jmp 0x4742
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
movl $0x1, -0x90(%rbp)
movl $0x2, -0x8c(%rbp)
movl $0x3, -0x88(%rbp)
movl $0x4, -0x84(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq $0x4, -0x78(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa900
movq -0xb0(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0xa920
jmp 0x46fc
leaq -0x55(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x47f0
movb %al, -0xb1(%rbp)
jmp 0x4711
movb -0xb1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4723
jmp 0x4772
leaq 0x19f42(%rip), %rdi     # 0x1e66c
leaq 0x19b4a(%rip), %rsi     # 0x1e27b
movl $0x96, %edx
leaq 0x19f1f(%rip), %rcx     # 0x1e65c
callq 0x2110
leaq -0x41(%rbp), %rdi
callq 0xaa00
jmp 0x479c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4790
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa9a0
jmp 0x4790
leaq -0x70(%rbp), %rdi
callq 0xa9a0
leaq -0x91(%rbp), %rdi
callq 0xaa00
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x91(%rbp), %rdi
callq 0xaa00
movq -0x50(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0xa, -0x4(%rbp)
movl $0x1, -0x40(%rbp)
movl $0x2, -0x3c(%rbp)
movl $0x3, -0x38(%rbp)
movl $0x4, -0x34(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x4, -0x28(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa900
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa920
jmp 0x488f
leaq -0x20(%rbp), %rdi
callq 0xb1a0
movl %eax, -0x64(%rbp)
jmp 0x489d
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
movl -0x64(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x48bf
jmp 0x490c
leaq 0x199e6(%rip), %rdi     # 0x1e2ac
leaq 0x199ae(%rip), %rsi     # 0x1e27b
movl $0x9d, %edx
leaq 0x19dda(%rip), %rcx     # 0x1e6b3
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4901
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
jmp 0x4912
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x18, -0x4(%rbp)
movl $0x1, -0x40(%rbp)
movl $0x2, -0x3c(%rbp)
movl $0x3, -0x38(%rbp)
movl $0x4, -0x34(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x4, -0x28(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa900
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa920
jmp 0x497f
leaq -0x20(%rbp), %rdi
callq 0xb1d0
movl %eax, -0x64(%rbp)
jmp 0x498d
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
movl -0x64(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x49af
jmp 0x49fc
leaq 0x198f6(%rip), %rdi     # 0x1e2ac
leaq 0x198be(%rip), %rsi     # 0x1e27b
movl $0xa4, %edx
leaq 0x19cfa(%rip), %rcx     # 0x1e6c3
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x49f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x41(%rbp), %rdi
callq 0xaa00
jmp 0x4a02
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movups 0x192fe(%rip), %xmm0    # 0x1e0d0
movaps %xmm0, -0x40(%rbp)
movups 0x192e3(%rip), %xmm0    # 0x1e0c0
movaps %xmm0, -0x50(%rbp)
movl $0x3, -0x30(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x9, -0x20(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xa900
movq -0xc8(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x4e22
leaq -0x51(%rbp), %rdi
callq 0xaa00
movl $0x1, -0xbc(%rbp)
movl $0x2, -0xb8(%rbp)
movl $0x3, -0xb4(%rbp)
leaq -0xbc(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq $0x3, -0xa8(%rbp)
leaq -0xbd(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa900
movq -0xd0(%rbp), %rcx
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0xb3c0
jmp 0x4e98
leaq -0x80(%rbp), %rdi
leaq -0x81(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x4fa0
jmp 0x4eb1
leaq -0xa0(%rbp), %rdi
callq 0xb470
leaq -0xbd(%rbp), %rdi
callq 0xaa00
leaq -0x80(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xd1(%rbp)
jmp 0x4ede
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x4eea
jmp 0x4eef
jmp 0x4f70
leaq 0x193b6(%rip), %rdi     # 0x1e2ac
leaq 0x1937e(%rip), %rsi     # 0x1e27b
movl $0xb5, %edx
leaq 0x197e1(%rip), %rcx     # 0x1e6ea
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xaa00
jmp 0x4f94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4f4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xb470
leaq -0xbd(%rbp), %rdi
callq 0xaa00
jmp 0x4f8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa9a0
jmp 0x4f8b
leaq -0x80(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x60(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x17, -0x4(%rbp)
movabsq $0x500000004, %rax      # imm = 0x500000004
movq %rax, -0x40(%rbp)
movups 0x1909d(%rip), %xmm0    # 0x1e0e4
movaps %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x6, -0x28(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xa900
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa920
jmp 0x507f
leaq -0x20(%rbp), %rdi
callq 0xb490
movl %eax, -0x74(%rbp)
jmp 0x508d
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x51(%rbp), %rdi
callq 0xaa00
movl -0x74(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x50af
jmp 0x50fc
leaq 0x191f6(%rip), %rdi     # 0x1e2ac
leaq 0x191be(%rip), %rsi     # 0x1e27b
movl $0xbc, %edx
leaq 0x19637(%rip), %rcx     # 0x1e700
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x50f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x51(%rbp), %rdi
callq 0xaa00
jmp 0x5105
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x22b0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0xffffffe9, -0x4(%rbp) # imm = 0xFFFFFFE9
movabsq $0x5ffffffe9, %rax      # imm = 0x5FFFFFFE9
movq %rax, -0x40(%rbp)
movups 0x18fc5(%rip), %xmm0    # 0x1e0fc
movaps %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x6, -0x28(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xa900
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa920
jmp 0x516f
leaq -0x20(%rbp), %rdi
callq 0xb4e0
movl %eax, -0x74(%rbp)
jmp 0x517d
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x51(%rbp), %rdi
callq 0xaa00
movl -0x74(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x519f
jmp 0x51ec
leaq 0x19106(%rip), %rdi     # 0x1e2ac
leaq 0x190ce(%rip), %rsi     # 0x1e27b
movl $0xc3, %edx
leaq 0x1955b(%rip), %rcx     # 0x1e714
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x51e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa9a0
leaq -0x51(%rbp), %rdi
callq 0xaa00
jmp 0x51f5
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x22b0
nop
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_take()
auto test_take() -> void {
  using Prelude::take;
  auto expect = std::vector<int>{1, 2, 3, 4};
  auto result = take(4, std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8});
  assert(result == expect);
  // also check case for n > size
  result = take(100, expect);
  assert(result == expect && "Also has to work for n > size!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x1, -0x38(%rbp)
movl $0x2, -0x34(%rbp)
movl $0x3, -0x30(%rbp)
movl $0x4, -0x2c(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x4, -0x20(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xa900
movq -0xd8(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x5261
leaq -0x39(%rbp), %rdi
callq 0xaa00
movups 0x18eb3(%rip), %xmm0    # 0x1e124
movaps %xmm0, -0xa0(%rbp)
movups 0x18e95(%rip), %xmm0    # 0x1e114
movaps %xmm0, -0xb0(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x8, -0x88(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xa900
movq -0xe0(%rbp), %rcx
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0xa920
jmp 0x52d2
leaq -0x68(%rbp), %rdi
movl $0x4, %esi
leaq -0x80(%rbp), %rdx
callq 0xb530
jmp 0x52e6
leaq -0x80(%rbp), %rdi
callq 0xa9a0
leaq -0xb1(%rbp), %rdi
callq 0xaa00
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xe1(%rbp)
jmp 0x5310
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x531c
jmp 0x5321
jmp 0x53a8
leaq 0x18f84(%rip), %rdi     # 0x1e2ac
leaq 0x18f4c(%rip), %rsi     # 0x1e27b
movl $0xca, %edx
leaq 0x193ed(%rip), %rcx     # 0x1e728
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xaa00
jmp 0x5471
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x537d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa9a0
leaq -0xb1(%rbp), %rdi
callq 0xaa00
jmp 0x5468
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa9a0
jmp 0x5468
leaq -0xd0(%rbp), %rdi
movl $0x64, %esi
leaq -0x18(%rbp), %rdx
callq 0xb530
jmp 0x53bf
leaq -0x68(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq -0xd0(%rbp), %rsi
movq %rsi, -0xf8(%rbp)
callq 0xb600
movq -0xf8(%rbp), %rdi
callq 0xa9a0
movq -0xf0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xe2(%rbp)
jmp 0x5401
movb -0xe2(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xf9(%rbp)
jne 0x5416
jmp 0x5420
movb $0x1, %al
movb %al, -0xf9(%rbp)
jmp 0x5420
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x542c
jmp 0x542e
jmp 0x544d
leaq 0x19323(%rip), %rdi     # 0x1e758
leaq 0x18e3f(%rip), %rsi     # 0x1e27b
movl $0xcd, %edx
leaq 0x192e0(%rip), %rcx     # 0x1e728
callq 0x2110
leaq -0x68(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x48(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_takeWhile()
auto test_takeWhile() -> void {
  using Prelude::takeWhile;
  auto expect = std::vector<int>{1, 2, 3, 4};
  auto result = takeWhile([](int x) { return x < 5; },
                          std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8});
  assert(result == expect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x1, -0x38(%rbp)
movl $0x2, -0x34(%rbp)
movl $0x3, -0x30(%rbp)
movl $0x4, -0x2c(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x4, -0x20(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa900
movq -0xd0(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x6141
leaq -0x39(%rbp), %rdi
callq 0xaa00
movups 0x18033(%rip), %xmm0    # 0x1e184
movaps %xmm0, -0xb0(%rbp)
movups 0x18015(%rip), %xmm0    # 0x1e174
movaps %xmm0, -0xc0(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0x98(%rbp)
movq $0x8, -0x90(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xa900
movq -0xd8(%rbp), %rcx
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0xa920
jmp 0x61b5
leaq -0x68(%rbp), %rdi
leaq -0x69(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x62c0
jmp 0x61cb
leaq -0x88(%rbp), %rdi
callq 0xa9a0
leaq -0xc1(%rbp), %rdi
callq 0xaa00
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xd9(%rbp)
jmp 0x61f8
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x6204
jmp 0x6209
jmp 0x628a
leaq 0x1809c(%rip), %rdi     # 0x1e2ac
leaq 0x18064(%rip), %rsi     # 0x1e27b
movl $0xf7, %edx
leaq 0x185b5(%rip), %rcx     # 0x1e7d8
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xaa00
jmp 0x62ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6265
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xa9a0
leaq -0xc1(%rbp), %rdi
callq 0xaa00
jmp 0x62a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa9a0
jmp 0x62a5
leaq -0x68(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x48(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)