LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/examples/../src/cxon/lang/common/bio/io.hxx
// Function: std::enable_if<std::is_integral<unsigned long>::value, bool>::type cxon::bio::get<unsigned long, unsigned char const*>(unsigned long&, unsigned int, unsigned char const*&, unsigned char const*)
inline auto get(T& t, unsigned n, II& i, II e)
            -> enable_if_t<std::is_integral<T>::value, bool>
        {
            switch (n) {
                case 1:     return imp::get_<1>(t, i, e);
                case 2:     return imp::get_<2>(t, i, e);
                case 4:     return imp::get_<4>(t, i, e);
                case 8:     return imp::get_<8>(t, i, e);
                default:    return CXON_ASSERT(0, "unexpected"), false; // LCOV_EXCL_LINE
            }
        }

// Assembly:
decl %esi
cmpl $0x7, %esi
ja 0x30c7
leaq 0xffa(%rip), %rax       # 0x4048
movslq (%rax,%rsi,4), %rsi
addq %rax, %rsi
jmpq *%rsi
movq (%rdx), %rax
cmpq %rcx, %rax
je 0x30c4
movzbl (%rax), %ecx
movq %rcx, (%rdi)
incq %rax
movq %rax, (%rdx)
jmp 0x30c1
movq (%rdx), %rax
subq %rax, %rcx
cmpq $0x4, %rcx
jl 0x30c4
leaq 0x4(%rax), %rcx
movq %rcx, (%rdx)
movl (%rax), %eax
bswapl %eax
jmp 0x30be
movq (%rdx), %rax
subq %rax, %rcx
cmpq $0x8, %rcx
jl 0x30c4
leaq 0x8(%rax), %rcx
movq %rcx, (%rdx)
movq (%rax), %rax
bswapq %rax
jmp 0x30be
movq (%rdx), %rax
subq %rax, %rcx
cmpq $0x2, %rcx
jl 0x30c4
leaq 0x2(%rax), %rcx
movq %rcx, (%rdx)
movzwl (%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movq %rax, (%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x12c0(%rip), %rdi      # 0x438f
leaq 0x12bb(%rip), %rsi      # 0x4391
leaq 0x14a6(%rip), %rcx      # 0x4583
movl $0xec, %edx
callq 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/fnvhash.c
// Function: fnv04
uint32_t
fnv04(char const *buf, int len)
{
    // B=2166136261 M=16777619
    uint32_t	hash = 0x811C9DC5;

    for (; --len >= 0; ++buf)
	hash = (hash ^ *(uint8_t const*)buf) * 0x01000193;

    hash += hash << 13;
    hash ^= hash >> 7;
    hash += hash << 3;
    hash ^= hash >> 17;
    hash += hash << 5;

    return  hash;
}

// Assembly:
testl %esi, %esi
jle 0x3e00
incl %esi
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
movzbl (%rdi), %ecx
xorl %eax, %ecx
imull $0x1000193, %ecx, %eax  # imm = 0x1000193
incq %rdi
decl %esi
cmpl $0x1, %esi
ja 0x3de3
imull $0x1326193, %ecx, %eax  # imm = 0x1326193
jmp 0x3e05
movl $0x14d53dc5, %eax       # imm = 0x14D53DC5
movl %eax, %ecx
shrl $0x7, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x11, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0x5, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/fnvhash.c
// Function: fnv08
uint64_t
fnv08(char const *buf, int len)
{
    uint64_t hash = 0xCBF29CE484222325ULL;

    for (; --len >= 0; ++buf)
	hash = (hash ^ *(uint8_t const*)buf) * 0x00000100000001B3ULL;

    hash ^= hash >> 33;
    hash *= 0xFF51AFD7ED558CCDULL;
    hash ^= hash >> 33;
    hash *= 0xC4CEB9FE1A85EC53ULL;
    hash ^= hash >> 33;

    return hash;
}

// Assembly:
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
testl %esi, %esi
jle 0x3e51
incl %esi
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
movzbl (%rdi), %ecx
xorq %rdx, %rcx
imulq %rax, %rcx
incq %rdi
decl %esi
movq %rcx, %rdx
cmpl $0x1, %esi
ja 0x3e38
jmp 0x3e54
movq %rdx, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movabsq $-0xae502812aa7333, %rcx # imm = 0xFF51AFD7ED558CCD
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
movabsq $-0x3b314601e57a13ad, %rcx # imm = 0xC4CEB9FE1A85EC53
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x21, %rax
xorq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: map_create
MAP
map_create(map_diff *diff, map_hash *hash, void *context)
{
    MAP    mp = calloc(1, sizeof(*mp));

    *mp = (struct map) {
		diff, hash, context, 0, MINMASK, -1,
		calloc(MINMASK + 1, sizeof(KEYVAL))
	    };

    return mp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x3180
movq %rax, %r12
movl $0x8, %edi
movl $0x10, %esi
callq 0x3180
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movq %rbx, 0x10(%r12)
movabsq $-0xfffffff9, %rcx      # imm = 0xFFFFFFFF00000007
movq %rcx, 0x1c(%r12)
movq %rax, 0x28(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: map_del
void *
map_del(MAP mp, MKEY key)
{
    int         pos = _find(mp, key), alpha = pos, hole = pos;
    void        *oldval = mp->vdata[pos].val;

    if (!mp->vdata[pos].key)
        return NULL;

    --mp->count;
    if (mp->last > pos)
	mp->last = pos;    //TODO

    do alpha = (alpha - 1) & mp->mask;
    while (mp->vdata[alpha].key);

    while (mp->vdata[pos = (pos + 1) & mp->mask].key) {
        int     want = FNHASH(mp, mp->vdata[pos].key);
        if ((unsigned)(want - alpha) <= (unsigned)(hole - alpha)) {
            mp->vdata[hole] = mp->vdata[pos];
            hole = pos;
        }
    }
    mp->vdata[hole] = (KEYVAL){NULL, NULL};

    return oldval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x40b9
movl %eax, %ebp
movq 0x28(%r14), %rax
movslq %ebp, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
cmpq $0x0, (%rax,%rdx)
je 0x40a5
movq 0x8(%rax,%rdx), %rbx
decl 0x18(%r14)
cmpl %ebp, 0x20(%r14)
jle 0x4008
movl %ebp, 0x20(%r14)
movl 0x1c(%r14), %r15d
movl %ebp, %r12d
decl %r12d
andl %r15d, %r12d
movslq %r12d, %rdx
shlq $0x4, %rdx
cmpq $0x0, (%rax,%rdx)
jne 0x400f
movl %ebp, %edx
incl %edx
andl %edx, %r15d
movslq %r15d, %r13
movq %r13, %rdx
shlq $0x4, %rdx
movq (%rax,%rdx), %rdi
testq %rdi, %rdi
je 0x4098
movq 0x10(%r14), %rsi
xorl %eax, %eax
callq *0x8(%r14)
movl 0x1c(%r14), %ecx
andl %ecx, %eax
subl %r12d, %eax
movl %ebp, %edx
subl %r12d, %edx
cmpl %edx, %eax
ja 0x4078
movq 0x28(%r14), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
shlq $0x4, %r13
movups (%rax,%r13), %xmm0
movups %xmm0, (%rax,%rcx)
movl 0x1c(%r14), %ecx
movl %r15d, %ebp
movq 0x28(%r14), %rax
incl %r15d
andl %ecx, %r15d
movslq %r15d, %r13
movq %r13, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
testq %rdi, %rdi
jne 0x403d
movslq %ebp, %rcx
shlq $0x4, %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx)
jmp 0x40a7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: find
static int
_find(MAP const mp, MKEY key)
{
    int     pos = FNHASH(mp, key);

    while (mp->vdata[pos].key &&
           mp->fndiff(mp->vdata[pos].key, key, mp->context))
        pos = (pos + 1) & mp->mask;

    return pos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq *0x8(%r14)
movq %rax, %r15
andl 0x1c(%r14), %r15d
movslq %r15d, %rax
movq 0x28(%r14), %rcx
shlq $0x4, %rax
movq (%rcx,%rax), %rdi
testq %rdi, %rdi
je 0x411a
movq 0x10(%r14), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq *(%r14)
testl %eax, %eax
je 0x411a
movslq %r15d, %rax
incq %rax
movslq 0x1c(%r14), %r15
andq %rax, %r15
movq 0x28(%r14), %rax
movq %r15, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdi
jmp 0x40e7
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: map_next
int
map_next(MAP mp, void const**pkey, void **pval)
{
    do if (++mp->last > mp->mask) return 0;
    while (!mp->vdata[mp->last].key);

    *pkey = mp->vdata[mp->last].key;
    *pval = mp->vdata[mp->last].val;
    return 1;
}

// Assembly:
movl 0x1c(%rdi), %r8d
movslq 0x20(%rdi), %rcx
movl %ecx, %eax
cmpl %r8d, %ecx
cmovgl %ecx, %r8d
movslq %r8d, %r8
movq %rcx, %r9
subq %r8, %r9
shlq $0x4, %rcx
xorl %r8d, %r8d
cmpq %r8, %r9
je 0x41c2
movq 0x28(%rdi), %r10
movq 0x10(%r10,%rcx), %r10
decq %r8
addq $0x10, %rcx
testq %r10, %r10
je 0x418d
subl %r8d, %eax
movl %eax, 0x20(%rdi)
movq %r10, (%rsi)
movq 0x28(%rdi), %rax
movq 0x8(%rax,%rcx), %rax
movq %rax, (%rdx)
movl $0x1, %eax
retq
subl %r8d, %eax
incl %eax
movl %eax, 0x20(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: map_resize
void
map_resize(MAP mp, int limit)
{
    int		i, j, dups = 0, oldmask = mp->mask;
    KEYVAL      *vdata;
    const void	*kp;

    if (--limit < MINMASK) limit = MINMASK;
    if (limit < mp->count * 5/4) limit = mp->count * 5/4;
    while (mp->mask > limit) mp->mask >>= 1;
    while (mp->mask < limit) mp->mask = (mp->mask << 1) | 1;
    vdata = calloc(mp->mask + 1, sizeof(KEYVAL));

        // PASS 1: insert where there are no collisions,
    for (i = 0; i <= oldmask; ++i) {

        if ((kp = mp->vdata[i].key)) {
            if (vdata[j = FNHASH(mp, kp)].key) {
                mp->vdata[dups++] = mp->vdata[i];
            } else {
                vdata[j] = mp->vdata[i];
            }
        }
    }

        // PASS 2: insert the rest
    for (i = 0; i < dups; ++i) {
        kp = mp->vdata[i].key;
        j = FNHASH(mp, kp);
        do j = (j + 1) & mp->mask; while (vdata[j].key);
        vdata[j] = mp->vdata[i];
    }

    free(mp->vdata);
    mp->vdata = vdata;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
movl 0x1c(%rdi), %r15d
cmpl $0x9, %esi
movl $0x8, %ecx
cmovgel %esi, %ecx
leal -0x1(%rcx), %edx
leal (%rax,%rax,4), %esi
leal (%rax,%rax,4), %eax
addl $0x3, %eax
testl %esi, %esi
cmovnsl %esi, %eax
sarl $0x2, %eax
cmpl %eax, %ecx
cmovgl %edx, %eax
movl %r15d, %ecx
cmpl %eax, %r15d
jle 0x4218
movl %r15d, %ecx
sarl %ecx
cmpl %eax, %ecx
jg 0x420f
movl %ecx, 0x1c(%rbx)
cmpl %eax, %ecx
jge 0x422a
leal 0x1(,%rcx,2), %ecx
cmpl %eax, %ecx
jl 0x421c
movl %ecx, 0x1c(%rbx)
incl %ecx
movslq %ecx, %rdi
movl $0x10, %esi
callq 0x3180
movq %rax, %r14
testl %r15d, %r15d
js 0x42fd
shlq $0x4, %r15
addq $0x10, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r13), %rdi
testq %rdi, %rdi
je 0x42a1
movq 0x10(%rbx), %rsi
xorl %eax, %eax
callq *0x8(%rbx)
andl 0x1c(%rbx), %eax
cltq
shlq $0x4, %rax
leaq (%r14,%rax), %rcx
movq 0x28(%rbx), %rdx
movslq %r12d, %r12
movq %r12, %rsi
shlq $0x4, %rsi
addq %rdx, %rsi
xorl %edi, %edi
cmpq $0x0, (%r14,%rax)
cmoveq %rcx, %rsi
setne %dil
addl %edi, %r12d
movups (%rdx,%r13), %xmm0
movups %xmm0, (%rsi)
addq $0x10, %r13
cmpq %r13, %r15
jne 0x4253
testl %r12d, %r12d
jle 0x42fd
movl %r12d, %r15d
movq 0x28(%rbx), %rdi
xorl %r12d, %r12d
movq %r12, %r13
shlq $0x4, %r13
movq (%rdi,%r13), %rdi
movq 0x10(%rbx), %rsi
xorl %eax, %eax
callq *0x8(%rbx)
movl 0x1c(%rbx), %ecx
andl %ecx, %eax
incl %eax
andl %ecx, %eax
movslq %eax, %rdx
shlq $0x4, %rdx
cmpq $0x0, (%r14,%rdx)
jne 0x42d2
addq %r14, %rdx
movq 0x28(%rbx), %rdi
movups (%rdi,%r13), %xmm0
movups %xmm0, (%rdx)
incq %r12
cmpq %r15, %r12
jne 0x42b9
jmp 0x4301
movq 0x28(%rbx), %rdi
callq 0x3300
movq %r14, 0x28(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: map_set
void *
map_set(MAP mp, MKEY key, void *val)
{
    int         pos     = _find(mp, key);
    void        *oldval = mp->vdata[pos].val;

    if (!mp->vdata[pos].key) {    // new entry
        if (IS_FULL(mp)) {
            map_resize(mp, (mp->mask + 1) << 1);
            pos = FNHASH(mp, key);
            while (mp->vdata[pos].key)
                pos = (pos + 1) & mp->mask;
        }

        mp->vdata[pos].key = key;
        ++mp->count;
    }

    mp->vdata[pos].val = val;
    return oldval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0x40b9
movq 0x28(%r15), %rcx
movslq %eax, %rdx
movq %rdx, %rax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %r14
cmpq $0x0, (%rcx,%rax)
jne 0x4370
movl 0x18(%r15), %esi
movl 0x1c(%r15), %eax
leal (%rsi,%rsi,4), %edi
leal (%rsi,%rsi,4), %esi
addl $0x3, %esi
testl %edi, %edi
cmovnsl %edi, %esi
sarl $0x2, %esi
cmpl %eax, %esi
jge 0x4388
movq %rdx, %rax
shlq $0x4, %rax
movq %r12, (%rcx,%rax)
incl 0x18(%r15)
shlq $0x4, %rdx
movq %rbx, 0x8(%rcx,%rdx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leal 0x2(,%rax,2), %esi
movq %r15, %rdi
callq 0x41cd
movq 0x10(%r15), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq *0x8(%r15)
movl 0x1c(%r15), %esi
andl %esi, %eax
movq 0x28(%r15), %rcx
movslq %eax, %rdx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpq $0x0, (%rcx,%rdi)
je 0x4361
incl %eax
andl %esi, %eax
jmp 0x43ae
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: kvs_del
void
kvs_del(KVS sh, const char *key)
{
    char    *ownkey = (char*)(intptr_t)map_key(sh, key);
    if (ownkey) {
        free(map_del(/*(MAP)*/sh, ownkey));
        free(ownkey);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
callq 0x40b9
cltq
shlq $0x4, %rax
movq (%r14,%rax), %r14
testq %r14, %r14
je 0x440e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fc7
movq %rax, %rdi
callq 0x3300
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3300
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: kvs_destroy
void
kvs_destroy(KVS sh)
{
    char        *key, *val;

    kvs_start(sh);
    while (kvs_next(sh, &key, &val))
	free(key), free(val);

    map_destroy(sh);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl 0x1c(%rbx), %edx
movslq %eax, %rcx
cmpl %edx, %ecx
cmovgl %eax, %edx
movslq %edx, %rdi
movq %rcx, %rsi
subq %rdi, %rsi
shlq $0x4, %rcx
addq $0x10, %rcx
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x4477
movq 0x28(%rbx), %r9
movq (%r9,%rcx), %rdi
decq %r8
addq $0x10, %rcx
testq %rdi, %rdi
je 0x4441
subl %r8d, %eax
movl %eax, 0x20(%rbx)
movq -0x8(%r9,%rcx), %r14
callq 0x3300
movq %r14, %rdi
callq 0x3300
movl 0x20(%rbx), %eax
jmp 0x4422
incl %edx
movl %edx, 0x20(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4123
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: kvs_load
KVS
kvs_load(char const *file, char sep)
{
    MEMBUF  data = chomp(slurp(file));
    if (nilbuf(data))
        return NULL;

    int     nstrs, i;
    MEMREF  *strv = refsplit(data.ptr, '\n', &nstrs);
    KVS     kvs = kvs_create();
    kvs_resize(kvs, nstrs);

    for (i = 0; i < nstrs; ++i) {
        char *cp = (char*)(intptr_t)strchr(strv[i].ptr, sep);
        if (cp)  {
            *cp++ = 0;
            kvs_set(kvs, strv[i].ptr, cp);
        }
    }

    free(strv);
    buffree(data);
    return  kvs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
callq 0x5439
movq %rax, %rdi
movq %rdx, %rsi
callq 0x4dc4
testq %rax, %rax
je 0x4587
movq %rax, %rbx
leaq 0xc(%rsp), %r12
movq %rax, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq 0x5305
movq %rax, 0x10(%rsp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x3180
movq %rax, %r14
movl $0x8, %edi
movl $0x10, %esi
callq 0x3180
movq 0x5ae7(%rip), %rcx      # 0x9fe0
movq %rcx, (%r14)
leaq 0x156(%rip), %rcx       # 0x4659
movq %rcx, 0x8(%r14)
movabsq $-0xfffffff9, %rcx      # imm = 0xFFFFFFFF00000007
movq %rcx, 0x1c(%r14)
movq %rax, 0x28(%r14)
movl (%r12), %esi
movq %r14, %rdi
callq 0x41cd
movl (%r12), %r15d
testl %r15d, %r15d
jle 0x4573
movsbl %bpl, %ebp
xorl %r12d, %r12d
movq 0x10(%rsp), %r13
movq (%r13), %rdi
movl %ebp, %esi
callq 0x30f0
testq %rax, %rax
je 0x4564
movq %rax, %rdx
incq %rdx
movb $0x0, (%rax)
movq (%r13), %rsi
movq %r14, %rdi
callq 0x459c
movl 0xc(%rsp), %r15d
incq %r12
movslq %r15d, %rax
addq $0x10, %r13
cmpq %rax, %r12
jl 0x453a
movq 0x10(%rsp), %rdi
callq 0x3300
movq %rbx, %rdi
callq 0x3300
jmp 0x458a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/map.c
// Function: kvs_set
void
kvs_set(KVS sh, const char *key, const char *val)
{
    int         pos = _find(sh, key);

    if (sh->vdata[pos].key) {
        free(sh->vdata[pos].val);
        sh->vdata[pos].val = strdup(val);
    } else if (!IS_FULL(sh)) {
        sh->vdata[pos] = (KEYVAL){strdup(key), strdup(val)};
        ++sh->count;
    } else {    // redundantly calls FNHASH:
        map_set(sh, strdup(key), strdup(val));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x40b9
movq 0x28(%rbx), %rcx
movslq %eax, %r13
shlq $0x4, %r13
leaq (%rcx,%r13), %r12
cmpq $0x0, (%rcx,%r13)
je 0x45e8
movq 0x8(%r12), %rdi
callq 0x3300
movq %r14, %rdi
callq 0x3420
movq 0x28(%rbx), %rcx
movq %rax, 0x8(%rcx,%r13)
jmp 0x462e
movl 0x18(%rbx), %r13d
leal (%r13,%r13,4), %eax
leal 0x3(%r13,%r13,4), %ebp
testl %eax, %eax
cmovnsl %eax, %ebp
sarl $0x2, %ebp
movl 0x1c(%rbx), %eax
movl %eax, 0x4(%rsp)
movq %r15, %rdi
callq 0x3420
movq %rax, %r15
movq %r14, %rdi
callq 0x3420
cmpl 0x4(%rsp), %ebp
jge 0x463d
movq %r15, (%r12)
movq %rax, 0x8(%r12)
incl %r13d
movl %r13d, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4314
// File: /workspace/github_cpp_makefile_star2_O3/monikakushwaha28[P]Fiduccia_Matthesys-using-c-/Fiduccia_Mattheyses_v1.0.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
vector<string> split(string str, char delimiter) {
	vector<string> internal;
	stringstream ss(str); // Turn the string into a stream.
	string tok;

	while (getline(ss, tok, delimiter)) {
		internal.push_back(tok);
	}
	return internal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x1d0(%rbp), %rdi
movl $0x18, %edx
callq 0x22c0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %r14b, %r14d
leaq -0x1d0(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x2350
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2922
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5f16
jmp 0x28f9
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2937
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
movq 0x866a(%rip), %rsi      # 0xafa8
leaq -0x1d0(%rbp), %rdi
callq 0x2180
leaq -0x150(%rbp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x29a7
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2988
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
movq 0x8619(%rip), %rsi      # 0xafa8
leaq -0x1d0(%rbp), %rdi
callq 0x2180
leaq -0x150(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x5e6c
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x78, %rsp
movaps 0x5130(%rip), %xmm0     # 0xa010
leaq 0x50(%rsp), %rbx
movaps %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rsi
callq 0x6c08
movups 0x5ca6(%rip), %xmm0     # 0xabac
movaps %xmm0, 0x10(%rbx)
movups 0x5c8b(%rip), %xmm0     # 0xab9c
movaps %xmm0, (%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x6(%rsp), %rcx
movl $0x8, %edx
callq 0x6c08
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
subq %rsi, %rax
sarq $0x2, %rax
movq %rsi, %rdx
testq %rax, %rax
jle 0x4f74
movq %rsi, %rdx
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
testq %rdi, %rdi
jg 0x4f49
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x80e2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4f9a
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x38(%rsp), %r14
movq 0x40(%rsp), %rax
movq %rax, %rdx
subq %r14, %rdx
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %rcx
subq %rbx, %rcx
cmpq %rcx, %rdx
jne 0x5007
cmpq %r14, %rax
je 0x4fd0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
jne 0x5007
testq %r14, %r14
je 0x4fea
movq 0x48(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x20f0
movq 0x20(%rsp), %rbx
testq %rbx, %rbx
je 0x4fff
movq 0x30(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
leaq 0x5092(%rip), %rdi      # 0xa0a0
leaq 0x505a(%rip), %rsi      # 0xa06f
leaq 0x5558(%rip), %rcx      # 0xa574
movl $0xf7, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5045
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x5045
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x505c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 $0xa0, %rsp
leaq 0x10(%rsp), %rsi
movl $0x1000100, (%rsi)      # imm = 0x1000100
movb $0x0, 0x4(%rsi)
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rcx
movl $0x5, %edx
callq 0x6baa
movups 0x857e(%rip), %xmm0     # 0xaac8
leaq 0x80(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x5, %edx
callq 0x6c08
movq 0x40(%rsp), %rbx
movq 0x48(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
cmpq %r15, %rbx
je 0x25b9
leaq 0x10(%rsp), %r14
xorl %esi, %esi
testb $0x1, (%rbx)
sete %sil
movq %r14, %rdi
callq 0x777e
addq $0x4, %rbx
cmpq %r15, %rbx
jne 0x259a
movq 0x40(%rsp), %rbx
testq %rbx, %rbx
je 0x25ce
movq 0x50(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl 0x28(%rsp), %ecx
movq %rdx, %rax
subq %rdi, %rax
leaq (%rcx,%rax,8), %rax
movq 0x58(%rsp), %r8
movq 0x68(%rsp), %rsi
movl 0x70(%rsp), %r9d
subq %r8, %rsi
leaq (%r9,%rsi,8), %rsi
cmpq %rsi, %rax
jne 0x264f
leaq 0x20(%rsp), %r14
xorl %esi, %esi
xorl %r9d, %r9d
callq 0x7b3c
testb %al, %al
je 0x264f
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x262b
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x2642
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7a4a(%rip), %rdi      # 0xa0a0
leaq 0x7a12(%rip), %rsi      # 0xa06f
leaq 0x7a4d(%rip), %rcx      # 0xa0b1
movl $0x17, %edx
callq 0x2090
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x26bd
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x21ce
jmp 0x26bd
movq %rax, %rbx
jmp 0x26bd
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x26a6
leaq 0x10(%rsp), %rdi
callq 0x21a0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x26bd
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x26d4
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x78, %rsp
movaps 0x7926(%rip), %xmm0     # 0xa010
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x4, %edx
callq 0x6c08
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x70(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x2, %edx
callq 0x6c08
movabsq $0x400000003, %rax      # imm = 0x400000003
leaq 0x68(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x38(%rsp), %rdi
leaq 0x6(%rsp), %rcx
movl $0x2, %edx
callq 0x6c08
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x6c4d
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x277d
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2794
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x50(%rsp), %r14
movq 0x58(%rsp), %rax
movq %rax, %rdx
subq %r14, %rdx
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %rcx
subq %rbx, %rcx
cmpq %rcx, %rdx
jne 0x2801
cmpq %r14, %rax
je 0x27ca
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
jne 0x2801
testq %r14, %r14
je 0x27e4
movq 0x60(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x20f0
movq 0x20(%rsp), %rbx
testq %rbx, %rbx
je 0x27f9
movq 0x30(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
leaq 0x7898(%rip), %rdi      # 0xa0a0
leaq 0x7860(%rip), %rsi      # 0xa06f
leaq 0x78ab(%rip), %rcx      # 0xa0c1
movl $0x1e, %edx
callq 0x2090
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x283f
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x283f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x285b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x285b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2872
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x80, %rsp
movabsq $0x400000002, %rax      # imm = 0x400000002
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rcx
movl $0x2, %edx
callq 0x6c08
movups 0x8215(%rip), %xmm0     # 0xaac8
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x5, %edx
callq 0x6c08
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x38(%rsp), %rsi
subq 0x30(%rsp), %rsi
sarq $0x2, %rsi
callq 0x7e32
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r15
cmpq %r15, %rbx
je 0x2943
leaq 0x10(%rsp), %r14
movl (%rbx), %eax
testb $0x1, %al
jne 0x293a
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x292f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x293a
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7ece
addq $0x4, %rbx
cmpq %r15, %rbx
jne 0x2910
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x2959
leaq 0x10(%rsp), %rdi
callq 0x7faa
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2970
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rax
movq %rax, %rdx
subq %r14, %rdx
movq 0x48(%rsp), %rbx
movq 0x50(%rsp), %rcx
subq %rbx, %rcx
cmpq %rcx, %rdx
jne 0x29e2
cmpq %r14, %rax
je 0x29a6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
jne 0x29e2
testq %r14, %r14
je 0x29c0
movq 0x20(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x20f0
movq 0x48(%rsp), %rbx
testq %rbx, %rbx
je 0x29d5
movq 0x58(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x76b7(%rip), %rdi      # 0xa0a0
leaq 0x767f(%rip), %rsi      # 0xa06f
leaq 0x76db(%rip), %rcx      # 0xa0d2
movl $0x26, %edx
callq 0x2090
jmp 0x2a08
movq %rax, %rbx
jmp 0x2a39
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2a22
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a39
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x2a50
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_head()
auto test_head() -> void {
  using Prelude::head;
  auto expect = 1;
  auto result = head(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x75ac(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0x2aa6
movl (%rdi), %ebx
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0x1, %ebx
jne 0x2ac5
addq $0x30, %rsp
popq %rbx
retq
leaq 0x7c41(%rip), %rdi      # 0xa6ee
leaq 0x7c62(%rip), %rsi      # 0xa716
leaq 0x7c67(%rip), %rcx      # 0xa722
movl $0x40, %edx
callq 0x2090
leaq 0x75d4(%rip), %rdi      # 0xa0a0
leaq 0x759c(%rip), %rsi      # 0xa06f
leaq 0x760b(%rip), %rcx      # 0xa0e5
movl $0x2d, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_last()
auto test_last() -> void {
  using Prelude::last;
  auto expect = 4;
  auto result = last(std::vector<int>{1, 2, 3, 4});
  assert(result == expect);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movaps 0x7520(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rdi, %rax
je 0x2b3b
movl -0x4(%rax), %ebx
testq %rdi, %rdi
je 0x2b30
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0x4, %ebx
jne 0x2b5a
addq $0x30, %rsp
popq %rbx
retq
leaq 0x7bac(%rip), %rdi      # 0xa6ee
leaq 0x7bcd(%rip), %rsi      # 0xa716
leaq 0x7c33(%rip), %rcx      # 0xa783
movl $0x47, %edx
callq 0x2090
leaq 0x753f(%rip), %rdi      # 0xa0a0
leaq 0x7507(%rip), %rsi      # 0xa06f
leaq 0x7587(%rip), %rcx      # 0xa0f6
movl $0x34, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movabsq $0x300000002, %rax      # imm = 0x300000002
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movl $0x4, 0x8(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x3, %edx
callq 0x6c08
movaps 0x745c(%rip), %xmm0     # 0xa010
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
callq 0x6c08
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6c99
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2bf6
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x38(%rsp), %r14
movq 0x40(%rsp), %rax
movq %rax, %rdx
subq %r14, %rdx
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %rcx
subq %rbx, %rcx
cmpq %rcx, %rdx
jne 0x2c63
cmpq %r14, %rax
je 0x2c2c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
jne 0x2c63
testq %r14, %r14
je 0x2c46
movq 0x48(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x20f0
movq 0x20(%rsp), %rbx
testq %rbx, %rbx
je 0x2c5b
movq 0x30(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x7436(%rip), %rdi      # 0xa0a0
leaq 0x73fe(%rip), %rsi      # 0xa06f
leaq 0x748f(%rip), %rcx      # 0xa107
movl $0x3b, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2ca1
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x2ca1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2cb8
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x3, %edx
callq 0x6c08
movaps 0x7315(%rip), %xmm0     # 0xa010
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
callq 0x6c08
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6ce6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d3d
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x38(%rsp), %r14
movq 0x40(%rsp), %rax
movq %rax, %rdx
subq %r14, %rdx
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %rcx
subq %rbx, %rcx
cmpq %rcx, %rdx
jne 0x2daa
cmpq %r14, %rax
je 0x2d73
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
jne 0x2daa
testq %r14, %r14
je 0x2d8d
movq 0x48(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x20f0
movq 0x20(%rsp), %rbx
testq %rbx, %rbx
je 0x2da2
movq 0x30(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x72ef(%rip), %rdi      # 0xa0a0
leaq 0x72b7(%rip), %rsi      # 0xa06f
leaq 0x7359(%rip), %rcx      # 0xa118
movl $0x42, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2de8
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x2de8
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2dff
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x78, %rsp
movaps 0x70a0(%rip), %xmm0     # 0xa020
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movl $0x4, %edx
callq 0x6c08
movaps 0x706d(%rip), %xmm0     # 0xa010
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x4, %edx
callq 0x6c08
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6d33
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2fe5
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq 0x40(%rsp), %r14
movq 0x48(%rsp), %rax
movq %rax, %rdx
subq %r14, %rdx
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %rcx
subq %rbx, %rcx
cmpq %rcx, %rdx
jne 0x3052
cmpq %r14, %rax
je 0x301b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
jne 0x3052
testq %r14, %r14
je 0x3035
movq 0x50(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x20f0
movq 0x28(%rsp), %rbx
testq %rbx, %rbx
je 0x304a
movq 0x38(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x20f0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
leaq 0x7047(%rip), %rdi      # 0xa0a0
leaq 0x700f(%rip), %rsi      # 0xa06f
leaq 0x7163(%rip), %rcx      # 0xa1ca
movl $0x5a, %edx
callq 0x2090
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3090
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
jmp 0x3090
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x30a7
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6f55(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
xorl %ebx, %ebx
cmpq %rax, %rdi
je 0x30fc
movq %rdi, %rcx
addl (%rcx), %ebx
addq $0x4, %rcx
cmpq %rax, %rcx
jne 0x30eb
cmpl $0xa, %ebx
sete %bl
testq %rdi, %rdi
je 0x310e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
testb %bl, %bl
je 0x3118
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6f81(%rip), %rdi      # 0xa0a0
leaq 0x6f49(%rip), %rsi      # 0xa06f
leaq 0x70b1(%rip), %rcx      # 0xa1de
movl $0x62, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6ecd(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rdi, %rax
je 0x3199
leaq 0x4(%rdi), %rcx
movl (%rdi), %ebx
cmpq %rax, %rcx
je 0x3181
addl (%rcx), %ebx
addq $0x4, %rcx
jmp 0x3174
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0xa, %ebx
jne 0x31b8
addq $0x30, %rsp
popq %rbx
retq
leaq 0x754e(%rip), %rdi      # 0xa6ee
leaq 0x756f(%rip), %rsi      # 0xa716
leaq 0x77bd(%rip), %rcx      # 0xa96b
movl $0x85, %edx
callq 0x2090
leaq 0x6ee1(%rip), %rdi      # 0xa0a0
leaq 0x6ea9(%rip), %rsi      # 0xa06f
leaq 0x7023(%rip), %rcx      # 0xa1f0
movl $0x6a, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x30, %rsp
movaps 0x6e2d(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
xorl %edi, %edi
movq %rbx, %rsi
callq 0x3271
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3225
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0xa, %ebx
jne 0x3230
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6e69(%rip), %rdi      # 0xa0a0
leaq 0x6e31(%rip), %rsi      # 0xa06f
leaq 0x6fbe(%rip), %rcx      # 0xa203
movl $0x72, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3269
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/kdungs[P]cpp-prelude/./prelude.h
// Function: int Prelude::foldr<test_foldr()::$_0, int, std::vector, int, std::allocator<int>>(test_foldr()::$_0 const&, int&&, std::vector<int, std::allocator<int>> const&)
auto foldr(const FN& f, B&& acc, const CN<A, AllocA>& c) -> B {
  // One way to do this is assuming a BidirIt and iterating the Container back
  // to front. The following is a more general approach that probably entails a
  // lot of copies. To be benchmarked!
  if (null(c)) {
    return std::forward<B>(acc);
  }
  return f(head(c),
           foldr<FN, B, CN, A, AllocA>(f, std::forward<B>(acc), tail(c)));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x32b8
movl (%rax), %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6c99
movl %ebx, %edi
movq %r14, %rsi
callq 0x3271
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x32b6
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addl %ebp, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x32dd
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d1f(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq %rbx, %rdi
callq 0x337d
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3331
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
cmpl $0xa, %ebx
jne 0x333c
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6d5d(%rip), %rdi      # 0xa0a0
leaq 0x6d25(%rip), %rsi      # 0xa06f
leaq 0x6ec4(%rip), %rcx      # 0xa215
movl $0x7a, %edx
callq 0x2090
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3375
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68f4(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
testq %rsi, %rsi
jle 0x3791
andq $-0x10, %rdx
movq %rdx, %rcx
addq %rdi, %rcx
incq %rsi
leaq 0x8(%rdi), %rdx
cmpl $0x3, -0x8(%rdx)
jg 0x37cc
cmpl $0x3, -0x4(%rdx)
jg 0x37d2
cmpl $0x3, (%rdx)
jg 0x37dc
cmpl $0x3, 0x4(%rdx)
jg 0x37d8
decq %rsi
addq $0x10, %rdx
cmpq $0x1, %rsi
jg 0x3765
movq %rax, %rdx
subq %rcx, %rdx
jmp 0x3794
movq %rdi, %rcx
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x37c0
cmpq $0x2, %rdx
je 0x37b7
cmpq $0x3, %rdx
jne 0x38d7
cmpl $0x3, (%rcx)
jg 0x37c7
addq $0x4, %rcx
cmpl $0x3, (%rcx)
jg 0x37c7
addq $0x4, %rcx
cmpl $0x4, (%rcx)
cmovlq %rax, %rcx
movq %rcx, %rdx
jmp 0x37dc
addq $-0x8, %rdx
jmp 0x37dc
addq $-0x4, %rdx
jmp 0x37dc
addq $0x4, %rdx
cmpq %rax, %rdx
je 0x38d7
testq %rdi, %rdi
je 0x37f7
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
leaq 0x20(%rsp), %rsi
movaps 0x680d(%rip), %xmm0     # 0xa010
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
testq %rsi, %rsi
jle 0x3873
andq $-0x10, %rdx
movq %rdx, %rcx
addq %rdi, %rcx
incq %rsi
leaq 0x8(%rdi), %rdx
cmpl $0x5, -0x8(%rdx)
jg 0x38aa
cmpl $0x5, -0x4(%rdx)
jg 0x38b0
cmpl $0x5, (%rdx)
jg 0x38ba
cmpl $0x5, 0x4(%rdx)
jg 0x38b6
decq %rsi
addq $0x10, %rdx
cmpq $0x1, %rsi
jg 0x3847
movq %rax, %rdx
subq %rcx, %rdx
jmp 0x3876
movq %rdi, %rcx
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x389e
cmpq $0x2, %rdx
je 0x3895
cmpq $0x3, %rdx
jne 0x38bf
cmpl $0x5, (%rcx)
jg 0x38a5
addq $0x4, %rcx
cmpl $0x5, (%rcx)
jg 0x38a5
addq $0x4, %rcx
cmpl $0x6, (%rcx)
cmovlq %rax, %rcx
movq %rcx, %rdx
jmp 0x38ba
addq $-0x8, %rdx
jmp 0x38ba
addq $-0x4, %rdx
jmp 0x38ba
addq $0x4, %rdx
cmpq %rax, %rdx
jne 0x38f6
testq %rdi, %rdi
je 0x38d1
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6a52(%rip), %rdi      # 0xa330
leaq 0x678a(%rip), %rsi      # 0xa06f
leaq 0x6a8b(%rip), %rcx      # 0xa377
movl $0x8c, %edx
callq 0x2090
leaq 0x6a8a(%rip), %rdi      # 0xa387
leaq 0x676b(%rip), %rsi      # 0xa06f
leaq 0x6a6c(%rip), %rcx      # 0xa377
movl $0x8e, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66ef(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
testq %rsi, %rsi
jle 0x3996
andq $-0x10, %rdx
movq %rdx, %rcx
addq %rdi, %rcx
incq %rsi
leaq 0x8(%rdi), %rdx
cmpl $0x4, -0x8(%rdx)
jl 0x39d1
cmpl $0x4, -0x4(%rdx)
jl 0x39d7
cmpl $0x4, (%rdx)
jl 0x39e1
cmpl $0x4, 0x4(%rdx)
jl 0x39dd
decq %rsi
addq $0x10, %rdx
cmpq $0x1, %rsi
jg 0x396a
movq %rax, %rdx
subq %rcx, %rdx
jmp 0x3999
movq %rdi, %rcx
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x39c5
cmpq $0x2, %rdx
je 0x39bc
cmpq $0x3, %rdx
jne 0x3adc
cmpl $0x4, (%rcx)
jl 0x39cc
addq $0x4, %rcx
cmpl $0x4, (%rcx)
jl 0x39cc
addq $0x4, %rcx
cmpl $0x4, (%rcx)
cmovgeq %rax, %rcx
movq %rcx, %rdx
jmp 0x39e1
addq $-0x8, %rdx
jmp 0x39e1
addq $-0x4, %rdx
jmp 0x39e1
addq $0x4, %rdx
cmpq %rax, %rdx
je 0x3adc
testq %rdi, %rdi
je 0x39fc
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
leaq 0x20(%rsp), %rsi
movaps 0x6608(%rip), %xmm0     # 0xa010
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
sarq $0x4, %rsi
testq %rsi, %rsi
jle 0x3a78
andq $-0x10, %rdx
movq %rdx, %rcx
addq %rdi, %rcx
incq %rsi
leaq 0x8(%rdi), %rdx
cmpl $0x4, -0x8(%rdx)
jg 0x3aaf
cmpl $0x4, -0x4(%rdx)
jg 0x3ab5
cmpl $0x4, (%rdx)
jg 0x3abf
cmpl $0x4, 0x4(%rdx)
jg 0x3abb
decq %rsi
addq $0x10, %rdx
cmpq $0x1, %rsi
jg 0x3a4c
movq %rax, %rdx
subq %rcx, %rdx
jmp 0x3a7b
movq %rdi, %rcx
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x3aa3
cmpq $0x2, %rdx
je 0x3a9a
cmpq $0x3, %rdx
jne 0x3ac4
cmpl $0x4, (%rcx)
jg 0x3aaa
addq $0x4, %rcx
cmpl $0x4, (%rcx)
jg 0x3aaa
addq $0x4, %rcx
cmpl $0x5, (%rcx)
cmovlq %rax, %rcx
movq %rcx, %rdx
jmp 0x3abf
addq $-0x8, %rdx
jmp 0x3abf
addq $-0x4, %rdx
jmp 0x3abf
addq $0x4, %rdx
cmpq %rax, %rdx
jne 0x3afb
testq %rdi, %rdi
je 0x3ad6
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
addq $0x30, %rsp
popq %rbx
retq
leaq 0x68ec(%rip), %rdi      # 0xa3cf
leaq 0x6585(%rip), %rsi      # 0xa06f
leaq 0x6926(%rip), %rcx      # 0xa417
movl $0x94, %edx
callq 0x2090
leaq 0x6925(%rip), %rdi      # 0xa427
leaq 0x6566(%rip), %rsi      # 0xa06f
leaq 0x6907(%rip), %rcx      # 0xa417
movl $0x96, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x64ea(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
xorl %ebx, %ebx
cmpq %rax, %rdi
je 0x3b67
movq %rdi, %rcx
addl (%rcx), %ebx
addq $0x4, %rcx
cmpq %rax, %rcx
jne 0x3b56
cmpl $0xa, %ebx
sete %bl
testq %rdi, %rdi
je 0x3b79
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
testb %bl, %bl
je 0x3b83
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6516(%rip), %rdi      # 0xa0a0
leaq 0x64de(%rip), %rsi      # 0xa06f
leaq 0x68d6(%rip), %rcx      # 0xa46e
movl $0x9d, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6462(%rip), %xmm0     # 0xa010
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq 0x6c08
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, %rdi
je 0x3bf5
movl $0x1, %ecx
movq %rdi, %rdx
imull (%rdx), %ecx
addq $0x4, %rdx
cmpq %rax, %rdx
jne 0x3be1
cmpl $0x18, %ecx
sete %bl
jmp 0x3bf7
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3c09
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x20f0
testb %bl, %bl
je 0x3c13
addq $0x30, %rsp
popq %rbx
retq
leaq 0x6486(%rip), %rdi      # 0xa0a0
leaq 0x644e(%rip), %rsi      # 0xa06f
leaq 0x6856(%rip), %rcx      # 0xa47e
movl $0xa4, %edx
callq 0x2090