LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x70, %rsp
movaps 0x4eea(%rip), %xmm0     # 0x9010
leaq 0x50(%rsp), %rbx
movaps %xmm0, (%rbx)
leaq 0x38(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rsi
callq 0x55b0
movups 0x5aba(%rip), %xmm0     # 0x9c04
movaps %xmm0, 0x10(%rbx)
movups 0x5a9f(%rip), %xmm0     # 0x9bf4
movaps %xmm0, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x8
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x55b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
subq %rsi, %rax
sarq $0x2, %rax
movq %rsi, %rdx
testq %rax, %rax
jle 0x41b0
movq %rax, %rcx
shrq %rcx
movq %rcx, %rdi
notq %rdi
addq %rax, %rdi
leaq (%rdx,%rcx,4), %rax
addq $0x4, %rax
cmpl $0x5, -0x4(%rax)
cmovlq %rax, %rdx
cmovgeq %rcx, %rdi
movq %rdi, %rax
jmp 0x4183
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x6d6a
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x41f6
leaq 0x20(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rdi
callq 0x62fa
addq $0x70, %rsp
popq %rbx
retq
leaq 0x4ea3(%rip), %rdi      # 0x90a0
leaq 0x4e6b(%rip), %rsi      # 0x906f
leaq 0x5369(%rip), %rcx      # 0x9574
movl $0xf7, %edx
callq 0x20c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x4227
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
jmp 0x4231
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x20(%rsp), %rsi
movl $0x1000100, (%rsi)      # imm = 0x1000100
movb $0x0, 0x4(%rsi)
leaq 0x48(%rsp), %rdi
pushq $0x5
popq %rbx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdx
callq 0x5570
movups 0x76fc(%rip), %xmm0     # 0x9b10
leaq 0x70(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movq %rbx, %rdx
callq 0x55b0
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rbx
andq $0x0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r15
cmpq %r15, %r14
je 0x2470
xorl %esi, %esi
testb $0x1, (%r14)
sete %sil
movq %rbx, %rdi
callq 0x6384
addq $0x4, %r14
jmp 0x2453
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x55e6
testb %al, %al
je 0x24ae
leaq 0x20(%rsp), %rdi
callq 0x5620
leaq 0x48(%rsp), %rdi
callq 0x5620
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6beb(%rip), %rdi      # 0x90a0
leaq 0x6bb3(%rip), %rsi      # 0x906f
leaq 0x6bee(%rip), %rcx      # 0x90b1
pushq $0x17
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5620
jmp 0x24f6
movq %rax, %rbx
jmp 0x24f6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5620
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x48(%rsp), %rdi
callq 0x5620
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x80, %rsp
movaps 0x6af9(%rip), %xmm0     # 0x9010
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x58(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x28(%rsp), %rcx
callq 0x55b0
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x78(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0x55b0
movabsq $0x400000003, %rax      # imm = 0x400000003
leaq 0x70(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x40(%rsp), %rdi
pushq $0x2
popq %rdx
leaq 0xe(%rsp), %rcx
callq 0x55b0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x5630
leaq 0x40(%rsp), %rdi
callq 0x62fa
leaq 0x28(%rsp), %rdi
callq 0x62fa
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x25d1
leaq 0x10(%rsp), %rdi
callq 0x62fa
leaq 0x58(%rsp), %rdi
callq 0x62fa
addq $0x80, %rsp
popq %rbx
retq
leaq 0x6ac8(%rip), %rdi      # 0x90a0
leaq 0x6a90(%rip), %rsi      # 0x906f
leaq 0x6adb(%rip), %rcx      # 0x90c1
pushq $0x1e
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x260f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x62fa
jmp 0x260a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x62fa
jmp 0x2619
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movabsq $0x400000002, %rax      # imm = 0x400000002
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x38(%rsp), %rdi
pushq $0x2
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x55b0
movups 0x74b1(%rip), %xmm0     # 0x9b10
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
pushq $0x5
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x55b0
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
sarq $0x2, %rsi
callq 0x6ad0
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r14
cmpq %r15, %rbx
je 0x26cd
testb $0x1, (%rbx)
jne 0x26c7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6b66
addq $0x4, %rbx
jmp 0x26b2
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x6c46
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x5670
testb %al, %al
je 0x2713
leaq 0x20(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rdi
callq 0x62fa
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6986(%rip), %rdi      # 0x90a0
leaq 0x694e(%rip), %rsi      # 0x906f
leaq 0x69aa(%rip), %rcx      # 0x90d2
pushq $0x26
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x2753
jmp 0x2741
movq %rax, %rbx
jmp 0x2758
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x62fa
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x38, %rsp
movaps 0x6899(%rip), %xmm0     # 0x9010
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x5699
movl %eax, %ebp
movq %rbx, %rdi
callq 0x62fa
cmpl $0x1, %ebp
jne 0x27b2
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x68e7(%rip), %rdi      # 0x90a0
leaq 0x68af(%rip), %rsi      # 0x906f
leaq 0x691e(%rip), %rcx      # 0x90e5
pushq $0x2d
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x38, %rsp
movaps 0x6834(%rip), %xmm0     # 0x9010
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x56c3
movl %eax, %ebp
movq %rbx, %rdi
callq 0x62fa
cmpl $0x4, %ebp
jne 0x2817
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x6882(%rip), %rdi      # 0x90a0
leaq 0x684a(%rip), %rsi      # 0x906f
leaq 0x68ca(%rip), %rcx      # 0x90f6
pushq $0x34
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20(%rsp), %rsi
movq %rax, (%rsi)
movl $0x4, 0x8(%rsi)
leaq 0x38(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x55b0
movaps 0x67a5(%rip), %xmm0     # 0x9010
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x55b0
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x56ee
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x28cb
leaq 0x20(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rdi
callq 0x62fa
addq $0x60, %rsp
popq %rbx
retq
leaq 0x67ce(%rip), %rdi      # 0x90a0
leaq 0x6796(%rip), %rsi      # 0x906f
leaq 0x6827(%rip), %rcx      # 0x9107
pushq $0x3b
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x28fa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
jmp 0x2904
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
leaq 0x38(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x55b0
movaps 0x66c3(%rip), %xmm0     # 0x9010
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x55b0
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5739
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x29ad
leaq 0x20(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rdi
callq 0x62fa
addq $0x60, %rsp
popq %rbx
retq
leaq 0x66ec(%rip), %rdi      # 0x90a0
leaq 0x66b4(%rip), %rsi      # 0x906f
leaq 0x6756(%rip), %rcx      # 0x9118
pushq $0x42
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x29dc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
jmp 0x29e6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x70, %rsp
movaps 0x64b9(%rip), %xmm0     # 0x9020
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x48(%rsp), %rdi
pushq $0x4
popq %rbx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdx
callq 0x55b0
movaps 0x6485(%rip), %xmm0     # 0x9010
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %rbx, %rdx
callq 0x55b0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x57bb
leaq 0x30(%rsp), %rdi
callq 0x62fa
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x2beb
leaq 0x10(%rsp), %rdi
callq 0x62fa
leaq 0x48(%rsp), %rdi
callq 0x62fa
addq $0x70, %rsp
popq %rbx
retq
leaq 0x64ae(%rip), %rdi      # 0x90a0
leaq 0x6476(%rip), %rsi      # 0x906f
leaq 0x65ca(%rip), %rcx      # 0x91ca
pushq $0x5a
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x2c1a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x62fa
jmp 0x2c24
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x63ce(%rip), %xmm0     # 0x9010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorl %ebx, %ebx
cmpq %rcx, %rax
je 0x2c75
addl (%rax), %ebx
addq $0x4, %rax
jmp 0x2c68
leaq 0x8(%rsp), %rdi
callq 0x62fa
cmpl $0xa, %ebx
jne 0x2c8a
addq $0x30, %rsp
popq %rbx
retq
leaq 0x640f(%rip), %rdi      # 0x90a0
leaq 0x63d7(%rip), %rsi      # 0x906f
leaq 0x653f(%rip), %rcx      # 0x91de
pushq $0x62
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x635d(%rip), %xmm0     # 0x9010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x2d00
movl (%rax), %ebx
addq $0x4, %rax
cmpq %rcx, %rax
je 0x2ceb
addl (%rax), %ebx
jmp 0x2cde
leaq 0x8(%rsp), %rdi
callq 0x62fa
cmpl $0xa, %ebx
jne 0x2d1f
addq $0x30, %rsp
popq %rbx
retq
leaq 0x69e7(%rip), %rdi      # 0x96ee
leaq 0x6a08(%rip), %rsi      # 0x9716
leaq 0x6ca0(%rip), %rcx      # 0x99b5
movl $0x85, %edx
callq 0x20c0
leaq 0x637a(%rip), %rdi      # 0x90a0
leaq 0x6342(%rip), %rsi      # 0x906f
leaq 0x64bc(%rip), %rcx      # 0x91f0
pushq $0x6a
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4(%rsp), %rbx
andl $0x0, (%rbx)
movaps 0x62be(%rip), %xmm0     # 0x9010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %r14
pushq $0x4
popq %rdx
leaq 0x3(%rsp), %rcx
movq %r14, %rdi
callq 0x55b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2dc5
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x62fa
cmpl $0xa, %ebx
jne 0x2d93
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x6306(%rip), %rdi      # 0x90a0
leaq 0x62ce(%rip), %rsi      # 0x906f
leaq 0x645b(%rip), %rcx      # 0x9203
pushq $0x72
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x2e0f
movq %rsi, %r14
movq %rsi, %rdi
callq 0x5699
movl %eax, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x56ee
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2dc5
movl %eax, %ebx
addl %ebp, %ebx
movq %rsp, %rdi
callq 0x62fa
jmp 0x2e11
movl (%rbx), %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x61d3(%rip), %xmm0     # 0x9010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x2eab
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x62fa
cmpl $0xa, %ebx
jne 0x2e79
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6220(%rip), %rdi      # 0x90a0
leaq 0x61e8(%rip), %rsi      # 0x906f
leaq 0x6387(%rip), %rcx      # 0x9215
pushq $0x7a
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f19(%rip), %xmm0     # 0x9010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
testq %rsi, %rsi
jle 0x3151
cmpl $0x3, (%rax)
jg 0x3196
cmpl $0x3, 0x4(%rax)
jg 0x3186
cmpl $0x3, 0x8(%rax)
jg 0x318c
cmpl $0x3, 0xc(%rax)
jg 0x3192
addq $0x10, %rax
decq %rsi
addq $-0x10, %rdx
jmp 0x3128
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x317d
cmpq $0x2, %rdx
je 0x3174
cmpq $0x3, %rdx
jne 0x3260
cmpl $0x3, (%rax)
jg 0x3196
addq $0x4, %rax
cmpl $0x3, (%rax)
jg 0x3196
addq $0x4, %rax
cmpl $0x4, (%rax)
cmovlq %rcx, %rax
jmp 0x3196
addq $0x4, %rax
jmp 0x3196
addq $0x8, %rax
jmp 0x3196
addq $0xc, %rax
cmpq %rcx, %rax
je 0x3260
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rsi
movaps 0x5e5b(%rip), %xmm0     # 0x9010
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
testq %rsi, %rsi
jle 0x320a
cmpl $0x5, (%rax)
jg 0x324b
cmpl $0x5, 0x4(%rax)
jg 0x323b
cmpl $0x5, 0x8(%rax)
jg 0x3241
cmpl $0x5, 0xc(%rax)
jg 0x3247
addq $0x10, %rax
decq %rsi
addq $-0x10, %rdx
jmp 0x31e1
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x3232
cmpq $0x2, %rdx
je 0x3229
cmpq $0x3, %rdx
jne 0x3250
cmpl $0x5, (%rax)
jg 0x324b
addq $0x4, %rax
cmpl $0x5, (%rax)
jg 0x324b
addq $0x4, %rax
cmpl $0x6, (%rax)
cmovlq %rcx, %rax
jmp 0x324b
addq $0x4, %rax
jmp 0x324b
addq $0x8, %rax
jmp 0x324b
addq $0xc, %rax
cmpq %rcx, %rax
jne 0x327f
leaq 0x8(%rsp), %rdi
callq 0x62fa
addq $0x30, %rsp
popq %rbx
retq
leaq 0x60c9(%rip), %rdi      # 0x9330
leaq 0x5e01(%rip), %rsi      # 0x906f
leaq 0x6102(%rip), %rcx      # 0x9377
movl $0x8c, %edx
callq 0x20c0
leaq 0x6101(%rip), %rdi      # 0x9387
leaq 0x5de2(%rip), %rsi      # 0x906f
leaq 0x60e3(%rip), %rcx      # 0x9377
movl $0x8e, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d66(%rip), %xmm0     # 0x9010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
testq %rsi, %rsi
jle 0x3304
cmpl $0x4, (%rax)
jl 0x3349
cmpl $0x4, 0x4(%rax)
jl 0x3339
cmpl $0x4, 0x8(%rax)
jl 0x333f
cmpl $0x4, 0xc(%rax)
jl 0x3345
addq $0x10, %rax
decq %rsi
addq $-0x10, %rdx
jmp 0x32db
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x3330
cmpq $0x2, %rdx
je 0x3327
cmpq $0x3, %rdx
jne 0x3413
cmpl $0x4, (%rax)
jl 0x3349
addq $0x4, %rax
cmpl $0x4, (%rax)
jl 0x3349
addq $0x4, %rax
cmpl $0x4, (%rax)
cmovgeq %rcx, %rax
jmp 0x3349
addq $0x4, %rax
jmp 0x3349
addq $0x8, %rax
jmp 0x3349
addq $0xc, %rax
cmpq %rcx, %rax
je 0x3413
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rsi
movaps 0x5ca8(%rip), %xmm0     # 0x9010
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
testq %rsi, %rsi
jle 0x33bd
cmpl $0x4, (%rax)
jg 0x33fe
cmpl $0x4, 0x4(%rax)
jg 0x33ee
cmpl $0x4, 0x8(%rax)
jg 0x33f4
cmpl $0x4, 0xc(%rax)
jg 0x33fa
addq $0x10, %rax
decq %rsi
addq $-0x10, %rdx
jmp 0x3394
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x33e5
cmpq $0x2, %rdx
je 0x33dc
cmpq $0x3, %rdx
jne 0x3403
cmpl $0x4, (%rax)
jg 0x33fe
addq $0x4, %rax
cmpl $0x4, (%rax)
jg 0x33fe
addq $0x4, %rax
cmpl $0x5, (%rax)
cmovlq %rcx, %rax
jmp 0x33fe
addq $0x4, %rax
jmp 0x33fe
addq $0x8, %rax
jmp 0x33fe
addq $0xc, %rax
cmpq %rcx, %rax
jne 0x3432
leaq 0x8(%rsp), %rdi
callq 0x62fa
addq $0x30, %rsp
popq %rbx
retq
leaq 0x5fb5(%rip), %rdi      # 0x93cf
leaq 0x5c4e(%rip), %rsi      # 0x906f
leaq 0x5fef(%rip), %rcx      # 0x9417
movl $0x94, %edx
callq 0x20c0
leaq 0x5fee(%rip), %rdi      # 0x9427
leaq 0x5c2f(%rip), %rsi      # 0x906f
leaq 0x5fd0(%rip), %rcx      # 0x9417
movl $0x96, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5bb3(%rip), %xmm0     # 0x9010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x5819
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x62fa
cmpl $0xa, %ebx
jne 0x3499
addq $0x30, %rsp
popq %rbx
retq
leaq 0x5c00(%rip), %rdi      # 0x90a0
leaq 0x5bc8(%rip), %rsi      # 0x906f
leaq 0x5fc0(%rip), %rcx      # 0x946e
movl $0x9d, %edx
callq 0x20c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5b37(%rip), %xmm0     # 0x9010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x5831
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x62fa
cmpl $0x18, %ebx
jne 0x3515
addq $0x30, %rsp
popq %rbx
retq
leaq 0x5b84(%rip), %rdi      # 0x90a0
leaq 0x5b4c(%rip), %rsi      # 0x906f
leaq 0x5f54(%rip), %rcx      # 0x947e
movl $0xa4, %edx
callq 0x20c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x65d8(%rip), %xmm0     # 0x9b34
leaq 0x40(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0x65b8(%rip), %xmm0     # 0x9b24
movaps %xmm0, (%rsi)
movl $0x9, 0x20(%rsi)
leaq 0x20(%rsp), %rdi
pushq $0x9
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x55b0
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x94(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
leaq 0x40(%rsp), %rbx
pushq $0x3
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
leaq 0x58(%rsp), %r14
movabsq $0x500000004, %rax      # imm = 0x500000004
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
pushq $0x2
popq %rdx
leaq 0x6(%rsp), %rcx
movq %r14, %rdi
callq 0x55b0
leaq 0x70(%rsp), %r14
movaps 0x5a44(%rip), %xmm0     # 0x9030
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
pushq $0x4
popq %rdx
leaq 0x5(%rsp), %rcx
movq %r14, %rdi
callq 0x55b0
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x584c
leaq 0x40(%rsp), %rdi
callq 0x58d2
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x3654
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
callq 0x62fa
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5a45(%rip), %rdi      # 0x90a0
leaq 0x5a0d(%rip), %rsi      # 0x906f
leaq 0x5e29(%rip), %rcx      # 0x9492
movl $0xac, %edx
callq 0x20c0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x62fa
jmp 0x36ac
movq %rax, %r15
leaq 0x40(%rsp), %rdi
callq 0x58d2
jmp 0x36ac
jmp 0x3693
movq %rax, %r15
addq $-0x18, %r14
movq %r14, %rdi
callq 0x62fa
cmpq %rbx, %r14
jne 0x3696
jmp 0x36ac
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x62fa
movq %r15, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xb8, %rsp
movups 0x6482(%rip), %xmm0     # 0x9b58
leaq 0x80(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0x645f(%rip), %xmm0     # 0x9b48
movaps %xmm0, (%rsi)
pushq $0x3
popq %rbx
movl %ebx, 0x20(%rsi)
leaq 0x50(%rsp), %rdi
pushq $0x9
popq %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rcx
callq 0x55b0
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0xac(%rsp), %rsi
movq %rax, (%rsi)
movl %ebx, 0x8(%rsi)
leaq 0x68(%rsp), %rbx
pushq $0x3
popq %rdx
leaq 0xe(%rsp), %rcx
movq %rbx, %rdi
callq 0x58f8
movq %r14, 0x18(%rsp)
movq %r14, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x80(%rsp), %r15
leaq 0x2c(%rsp), %r12
pushq $0x3
popq %r13
leaq 0xf(%rsp), %rbp
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x379d
movl 0x10(%r14), %eax
movl %eax, 0x2c(%rsp)
movl %eax, 0x30(%rsp)
movl %eax, 0x34(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x55b0
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x730c
movq %r15, %rdi
callq 0x62fa
jmp 0x375d
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7285
leaq 0x10(%rsp), %rdi
callq 0x73e6
leaq 0x68(%rsp), %rdi
callq 0x5fd4
leaq 0x38(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x37f9
leaq 0x38(%rsp), %rdi
callq 0x62fa
leaq 0x50(%rsp), %rdi
callq 0x62fa
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58a0(%rip), %rdi      # 0x90a0
leaq 0x5868(%rip), %rsi      # 0x906f
leaq 0x5c97(%rip), %rcx      # 0x94a5
movl $0xb5, %edx
callq 0x20c0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62fa
jmp 0x3857
jmp 0x382e
movq %rax, %rbx
jmp 0x3857
movq %rax, %rbx
jmp 0x3843
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x62fa
leaq 0x10(%rsp), %rdi
callq 0x73e6
leaq 0x68(%rsp), %rdi
callq 0x5fd4
leaq 0x50(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x62f7(%rip), %xmm0     # 0x9b6c
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $0x500000004, %rax      # imm = 0x500000004
movq %rax, 0x10(%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x6
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x592f
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x62fa
cmpl $0x17, %ebx
jne 0x38bf
addq $0x40, %rsp
popq %rbx
retq
leaq 0x57da(%rip), %rdi      # 0x90a0
leaq 0x57a2(%rip), %rsi      # 0x906f
leaq 0x5be7(%rip), %rcx      # 0x94bb
movl $0xbc, %edx
callq 0x20c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6285(%rip), %xmm0     # 0x9b84
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $0x5ffffffe9, %rax      # imm = 0x5FFFFFFE9
movq %rax, 0x10(%rsi)
leaq 0x8(%rsp), %rbx
pushq $0x6
popq %rdx
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x5943
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x62fa
cmpl $-0x17, %ebx
jne 0x3949
addq $0x40, %rsp
popq %rbx
retq
leaq 0x5750(%rip), %rdi      # 0x90a0
leaq 0x5718(%rip), %rsi      # 0x906f
leaq 0x5b71(%rip), %rcx      # 0x94cf
movl $0xc3, %edx
callq 0x20c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x78, %rsp
movaps 0x5685(%rip), %xmm0     # 0x9010
leaq 0x50(%rsp), %rbx
movaps %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rsi
callq 0x55b0
movups 0x6255(%rip), %xmm0     # 0x9c04
movaps %xmm0, 0x10(%rbx)
movups 0x623a(%rip), %xmm0     # 0x9bf4
movaps %xmm0, (%rbx)
leaq 0x38(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x8
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x55b0
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rsi
leaq 0x38(%rsp), %rdx
callq 0x5957
leaq 0x38(%rsp), %rdi
callq 0x62fa
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x3a5f
leaq 0x50(%rsp), %rdi
pushq $0x64
popq %rsi
leaq 0x20(%rsp), %rdx
callq 0x5957
leaq 0x8(%rsp), %rbx
leaq 0x50(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7474
movq %r14, %rdi
callq 0x62fa
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5670
testb %al, %al
je 0x3a7e
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
callq 0x62fa
addq $0x78, %rsp
popq %rbx
popq %r14
retq
leaq 0x563a(%rip), %rdi      # 0x90a0
leaq 0x5602(%rip), %rsi      # 0x906f
leaq 0x5a6f(%rip), %rcx      # 0x94e3
movl $0xca, %edx
callq 0x20c0
leaq 0x5a6f(%rip), %rdi      # 0x94f4
leaq 0x55e3(%rip), %rsi      # 0x906f
leaq 0x5a50(%rip), %rcx      # 0x94e3
movl $0xcd, %edx
callq 0x20c0
jmp 0x3aae
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x3ab6
movq %rax, %rbx
jmp 0x3abb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_drop()
auto test_drop() -> void {
  using Prelude::drop;
  auto expect = std::vector<int>{5, 6, 7, 8};
  auto result = drop(4, std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8});
  assert(result == expect);
  // also check case for n > size
  result = drop(100, std::vector<int>{1, 2, 3, 4});
  expect = std::vector<int>{};
  assert(result == expect && "Also has to work for n > size!");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movaps 0x5560(%rip), %xmm0     # 0x9040
leaq 0x50(%rsp), %rbx
movaps %xmm0, (%rbx)
leaq 0x38(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rsi
callq 0x55b0
movups 0x6100(%rip), %xmm0     # 0x9c04
movaps %xmm0, 0x10(%rbx)
movups 0x60e5(%rip), %xmm0     # 0x9bf4
movaps %xmm0, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x8
popq %rdx
leaq 0x70(%rsp), %rcx
callq 0x55b0
leaq 0x20(%rsp), %rdi
pushq $0x4
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x5991
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x3c0f
movaps 0x54ad(%rip), %xmm0     # 0x9010
leaq 0x70(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x55b0
leaq 0x50(%rsp), %rdi
pushq $0x64
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x5991
leaq 0x20(%rsp), %rbx
leaq 0x50(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7474
movq %r14, %rdi
callq 0x62fa
leaq 0x8(%rsp), %rdi
callq 0x62fa
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x38(%rsp), %r14
leaq 0x50(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7474
movq %r15, %rdi
callq 0x62fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5670
testb %al, %al
je 0x3c2e
leaq 0x20(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rdi
callq 0x62fa
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x548a(%rip), %rdi      # 0x90a0
leaq 0x5452(%rip), %rsi      # 0x906f
leaq 0x5905(%rip), %rcx      # 0x9529
movl $0xd4, %edx
callq 0x20c0
leaq 0x58bf(%rip), %rdi      # 0x94f4
leaq 0x5433(%rip), %rsi      # 0x906f
leaq 0x58e6(%rip), %rcx      # 0x9529
movl $0xd8, %edx
callq 0x20c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
jmp 0x3c70
jmp 0x3c6d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x3c75
movq %rax, %rbx
jmp 0x3c7a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4df1(%rip), %xmm0     # 0x9040
leaq 0x50(%rsp), %rbx
movaps %xmm0, (%rbx)
leaq 0x38(%rsp), %rdi
pushq $0x4
popq %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rsi
callq 0x55b0
movups 0x5991(%rip), %xmm0     # 0x9c04
movaps %xmm0, 0x10(%rbx)
movups 0x5976(%rip), %xmm0     # 0x9bf4
movaps %xmm0, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x8
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x55b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rdx, %rax
subq %rsi, %rax
sarq $0x2, %rax
testq %rax, %rax
jle 0x42d9
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
jmp 0x42ac
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x6d6a
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x431f
leaq 0x20(%rsp), %rdi
callq 0x62fa
leaq 0x38(%rsp), %rdi
callq 0x62fa
addq $0x70, %rsp
popq %rbx
retq
leaq 0x4d7a(%rip), %rdi      # 0x90a0
leaq 0x4d42(%rip), %rsi      # 0x906f
leaq 0x5256(%rip), %rcx      # 0x958a
movl $0xff, %edx
callq 0x20c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x4350
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
jmp 0x435a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_break_()
auto test_break_() -> void {
  using Prelude::break_;
  auto expectL = std::vector<int>{1, 2, 3, 4};
  auto expectR = std::vector<int>{5, 6, 7, 8};
  std::vector<int> resultL, resultR;
  std::tie(resultL, resultR) = break_([](int x) { return x >= 5; },
                                      std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8});
  assert(resultL == expectL);
  assert(resultR == expectR);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movaps 0x4a1f(%rip), %xmm0     # 0x9010
leaq 0xd0(%rsp), %rbx
movaps %xmm0, (%rbx)
leaq 0x98(%rsp), %rdi
pushq $0x4
popq %r14
leaq 0x48(%rsp), %rcx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x55b0
movaps 0x4a21(%rip), %xmm0     # 0x9040
movaps %xmm0, (%rbx)
leaq 0x80(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0x48(%rsp), %rcx
movq %r14, %rdx
callq 0x55b0
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movups 0x55a5(%rip), %xmm0     # 0x9c04
leaq 0x100(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0x5582(%rip), %xmm0     # 0x9bf4
movaps %xmm0, (%rsi)
leaq 0x68(%rsp), %rdi
pushq $0x8
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0x55b0
leaq 0xb0(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0xe7c(%rip), %rcx       # 0x5518
movq %rcx, 0x18(%rax)
leaq 0xe79(%rip), %rcx       # 0x5520
movq %rcx, 0x10(%rax)
leaq 0x48(%rsp), %rsi
andq $0x0, 0x8(%rsi)
movq %rax, (%rsi)
leaq 0x19a9(%rip), %rax      # 0x6068
movq %rax, 0x18(%rsi)
leaq 0x19a4(%rip), %rax      # 0x606e
movq %rax, 0x10(%rsi)
leaq 0xd0(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x751c
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x5538
leaq 0xb0(%rsp), %rdi
callq 0x5538
leaq 0x10(%rsp), %rax
movq %rax, (%rbx)
leaq 0x30(%rsp), %r14
movq %r14, 0x8(%rbx)
leaq 0x48(%rsp), %rdi
leaq 0xd0(%rsp), %rbx
movq %rbx, %rsi
callq 0x5a38
movq %rbx, %rdi
callq 0x5a4e
leaq 0x68(%rsp), %rdi
callq 0x62fa
leaq 0x98(%rsp), %rsi
movq %r14, %rdi
callq 0x5670
testb %al, %al
je 0x4795
leaq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x47b4
leaq 0x10(%rsp), %rdi
callq 0x62fa
leaq 0x30(%rsp), %rdi
callq 0x62fa
leaq 0x80(%rsp), %rdi
callq 0x62fa
leaq 0x98(%rsp), %rdi
callq 0x62fa
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
leaq 0x4d9e(%rip), %rdi      # 0x953a
leaq 0x48cc(%rip), %rsi      # 0x906f
leaq 0x4e07(%rip), %rcx      # 0x95b1
movl $0x114, %edx            # imm = 0x114
callq 0x20c0
leaq 0x4da6(%rip), %rdi      # 0x9561
leaq 0x48ad(%rip), %rsi      # 0x906f
leaq 0x4de8(%rip), %rcx      # 0x95b1
movl $0x115, %edx            # imm = 0x115
callq 0x20c0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5538
leaq 0xb0(%rsp), %rdi
callq 0x5538
leaq 0x68(%rsp), %rdi
callq 0x62fa
jmp 0x4803
jmp 0x4800
movq %rax, %rbx
jmp 0x4824
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x62fa
leaq 0x30(%rsp), %rdi
callq 0x62fa
leaq 0x80(%rsp), %rdi
callq 0x62fa
leaq 0x98(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x78, %rsp
movb $0x1, %al
leaq 0x20(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, 0x4(%rsi)
movb $0x0, 0x8(%rsi)
movl $0x2, 0xc(%rsi)
movb %al, 0x10(%rsi)
pushq $0x3
popq %rbp
movl %ebp, 0x14(%rsi)
leaq 0x50(%rsp), %rdi
pushq $0x3
popq %rbx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdx
callq 0x5a64
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x6c(%rsp), %rsi
movq %rax, (%rsi)
movl %ebp, 0x8(%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rcx
movq %rbx, %rdx
callq 0x55b0
leaq 0x5(%rsp), %rsi
movw $0x1, (%rsi)
movb $0x1, 0x2(%rsi)
leaq 0x38(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x3(%rsp), %rcx
callq 0x5b02
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x5a9a
leaq 0x38(%rsp), %rdi
callq 0x5ffe
leaq 0x8(%rsp), %rdi
callq 0x62fa
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x5b38
testb %al, %al
je 0x4915
leaq 0x20(%rsp), %rdi
callq 0x76e6
leaq 0x50(%rsp), %rdi
callq 0x76e6
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4784(%rip), %rdi      # 0x90a0
leaq 0x474c(%rip), %rsi      # 0x906f
leaq 0x4c9a(%rip), %rcx      # 0x95c4
movl $0x11f, %edx            # imm = 0x11F
callq 0x20c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x76e6
jmp 0x4964
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5ffe
jmp 0x4955
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x62fa
jmp 0x4964
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x76e6
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_zip3()
auto test_zip3() -> void {
  using Prelude::zip3;
  auto expect = std::vector<std::tuple<int, bool, char>>{
      std::make_tuple(1, true, 'a'), std::make_tuple(2, false, 'b'),
      std::make_tuple(3, true, 'm')};
  auto result =
      zip3(std::vector<int>{1, 2, 3}, std::list<bool>{true, false, true},
           std::vector<char>{'a', 'b', 'm'});
  assert(result == expect);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x98, %rsp
leaq 0x28(%rsp), %rsi
movw $0x161, (%rsi)          # imm = 0x161
movl $0x1, 0x4(%rsi)
movw $0x62, 0x8(%rsi)
movl $0x2, 0xc(%rsi)
movw $0x16d, 0x10(%rsi)      # imm = 0x16D
pushq $0x3
popq %rbp
movl %ebp, 0x14(%rsi)
leaq 0x70(%rsp), %rdi
pushq $0x3
popq %rbx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdx
callq 0x5b62
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x8c(%rsp), %rsi
movq %rax, (%rsi)
movl %ebp, 0x8(%rsi)
leaq 0x10(%rsp), %rdi
leaq 0x9(%rsp), %rcx
movq %rbx, %rdx
callq 0x55b0
leaq 0xd(%rsp), %rsi
movw $0x1, (%rsi)
movb $0x1, 0x2(%rsi)
leaq 0x58(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x5b02
leaq 0xa(%rsp), %rsi
movw $0x6261, (%rsi)         # imm = 0x6261
movb $0x6d, 0x2(%rsi)
leaq 0x40(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x5c1c
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdx
leaq 0x40(%rsp), %rcx
callq 0x5b98
leaq 0x40(%rsp), %rdi
callq 0x7b3e
leaq 0x58(%rsp), %rdi
callq 0x5ffe
leaq 0x10(%rsp), %rdi
callq 0x62fa
leaq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x5c51
testb %al, %al
je 0x4a90
leaq 0x28(%rsp), %rdi
callq 0x7a5c
leaq 0x70(%rsp), %rdi
callq 0x7a5c
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4609(%rip), %rdi      # 0x90a0
leaq 0x45d1(%rip), %rsi      # 0x906f
leaq 0x4b2f(%rip), %rcx      # 0x95d4
movl $0x12a, %edx            # imm = 0x12A
callq 0x20c0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7a5c
jmp 0x4aee
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x7b3e
jmp 0x4ad0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5ffe
jmp 0x4adf
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x62fa
jmp 0x4aee
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x7a5c
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_zipWith()
auto test_zipWith() -> void {
  using Prelude::zipWith;
  auto expect = std::vector<int>{1, 0, 3, 0, 5, 0};
  auto result = zipWith([](int x, bool y) { return y ? x : 0; },
                        std::vector<int>{1, 2, 3, 4, 5, 6},
                        std::list<bool>{true, false, true, false, true, false});
  assert(result == expect);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movups 0x5085(%rip), %xmm0     # 0x9b9c
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x5, 0x10(%rsi)
leaq 0x48(%rsp), %rdi
pushq $0x6
popq %rbx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdx
callq 0x55b0
movups 0x5071(%rip), %xmm0     # 0x9bb4
leaq 0x80(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $0x600000005, %rax      # imm = 0x600000005
movq %rax, 0x10(%rsi)
leaq 0x30(%rsp), %rdi
leaq 0xb(%rsp), %rcx
movq %rbx, %rdx
callq 0x55b0
leaq 0x60(%rsp), %rsi
movl $0x10001, (%rsi)        # imm = 0x10001
movw $0x1, 0x4(%rsi)
leaq 0x68(%rsp), %rbx
pushq $0x6
popq %rdx
leaq 0xa(%rsp), %rcx
movq %rbx, %rdi
callq 0x5b02
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
movq 0x30(%rsp), %r12
leaq 0xc(%rsp), %r15
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
setne %al
cmpq 0x38(%rsp), %r12
je 0x4be9
testb %al, %al
je 0x4be9
xorl %eax, %eax
cmpb $0x0, 0x10(%r13)
je 0x4bd4
movl (%r12), %eax
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d98
addq $0x4, %r12
jmp 0x4bb2
leaq 0x68(%rsp), %rdi
callq 0x5ffe
leaq 0x30(%rsp), %rdi
callq 0x62fa
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5670
testb %al, %al
je 0x4c35
leaq 0x10(%rsp), %rdi
callq 0x62fa
leaq 0x48(%rsp), %rdi
callq 0x62fa
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4464(%rip), %rdi      # 0x90a0
leaq 0x442c(%rip), %rsi      # 0x906f
leaq 0x499b(%rip), %rcx      # 0x95e5
movl $0x133, %edx            # imm = 0x133
callq 0x20c0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x4c84
movq %rax, %rbx
jmp 0x4c7f
movq %rax, %rbx
jmp 0x4c89
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x62fa
leaq 0x68(%rsp), %rdi
callq 0x5ffe
leaq 0x30(%rsp), %rdi
callq 0x62fa
leaq 0x48(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_unzip()
auto test_unzip() -> void {
  using Prelude::unzip;
  auto expectL = std::vector<int>{1, 2, 3};
  auto expectR = std::vector<bool>{true, false, true};
  std::vector<int> resultL;
  std::vector<bool> resultR;
  std::tie(resultL, resultR) = unzip(std::vector<std::tuple<int, bool>>{
      std::make_tuple(1, true), std::make_tuple(2, false),
      std::make_tuple(3, true)});
  assert(resultL == expectL);
  assert(resultR == expectR);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0xb0(%rsp), %rbx
movq %rax, (%rbx)
movl $0x3, 0x8(%rbx)
leaq 0x60(%rsp), %rdi
pushq $0x3
popq %r14
leaq 0x78(%rsp), %rcx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x55b0
movw $0x1, (%rbx)
movb $0x1, 0x2(%rbx)
leaq 0x78(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x8(%rsp), %rbx
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5570
andq $0x0, 0x40(%rsp)
andq $0x0, 0x8(%rsp)
andl $0x0, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
xorps %xmm0, %xmm0
andl $0x0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x28(%rsp)
movb $0x1, %al
leaq 0xf0(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, 0x4(%rsi)
movb $0x0, 0x8(%rsi)
movl $0x2, 0xc(%rsi)
movb %al, 0x10(%rsi)
movl $0x3, 0x14(%rsi)
leaq 0x48(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x5a64
leaq 0xb0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5d71
leaq 0xa0(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x30(%rsp), %rbx
movq %rbx, 0x8(%rdi)
leaq 0xb0(%rsp), %r14
movq %r14, %rsi
callq 0x5e24
movq %r14, %rdi
callq 0x5e3a
leaq 0x48(%rsp), %rdi
callq 0x76e6
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x5670
testb %al, %al
je 0x50da
leaq 0x8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x55e6
testb %al, %al
je 0x50f9
leaq 0x8(%rsp), %rdi
callq 0x5620
leaq 0x30(%rsp), %rdi
callq 0x62fa
leaq 0x78(%rsp), %rdi
callq 0x5620
leaq 0x60(%rsp), %rdi
callq 0x62fa
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
leaq 0x4459(%rip), %rdi      # 0x953a
leaq 0x3f87(%rip), %rsi      # 0x906f
leaq 0x4529(%rip), %rcx      # 0x9618
movl $0x149, %edx            # imm = 0x149
callq 0x20c0
leaq 0x4461(%rip), %rdi      # 0x9561
leaq 0x3f68(%rip), %rsi      # 0x906f
leaq 0x450a(%rip), %rcx      # 0x9618
movl $0x14a, %edx            # imm = 0x14A
callq 0x20c0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x76e6
jmp 0x5131
jmp 0x512e
movq %rax, %rbx
jmp 0x514f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5620
leaq 0x30(%rsp), %rdi
callq 0x62fa
leaq 0x78(%rsp), %rdi
callq 0x5620
leaq 0x60(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0