LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/./evec.h
// Function: evpop
void evpop(void *vec)
{
    ifp(!vec,
        //Uh ohhh....
        EV_FAIL("Cannot pop a NULL vector\n");
        return;
    );

    evhd_t* hdr =  EV_HDR(vec);
    ifp(_evhdrcheck(hdr),
        EV_FAIL("Header sanity check failed\n");
        return;
    );

    if(hdr->obj_count)
        hdr->obj_count--;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1fe2
movl $0x2, %edi
movl $0x2d5, %esi            # imm = 0x2D5
leaq 0x20a4(%rip), %rdx      # 0x4068
leaq 0x23d3(%rip), %rcx      # 0x439e
leaq 0x23d2(%rip), %r8       # 0x43a4
leaq 0x218c(%rip), %r9       # 0x4165
movb $0x0, %al
callq 0x13d0
jmp 0x2046
movq -0x8(%rbp), %rax
addq $-0x30, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1510
cmpl $0x0, %eax
je 0x202b
movl $0x2, %edi
movl $0x2db, %esi            # imm = 0x2DB
leaq 0x205b(%rip), %rdx      # 0x4068
leaq 0x238a(%rip), %rcx      # 0x439e
leaq 0x21f0(%rip), %r8       # 0x420b
leaq 0x2143(%rip), %r9       # 0x4165
movb $0x0, %al
callq 0x13d0
jmp 0x2046
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2046
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: main
int main(void)
{

    for(int i = 0; tests[i].name != 0; i++){
        printf("Running test %i: %s ...", i+1, tests[i].name);
        int result = tests[i].run();
        printf("%s\n", result ? "Success" : "Fail");
        if(!result){
            return -1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x39bf(%rip), %rax      # 0x60a0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x277a
movl -0x8(%rbp), %esi
addl $0x1, %esi
movslq -0x8(%rbp), %rcx
leaq 0x399d(%rip), %rax      # 0x60a0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x1e3e(%rip), %rdi      # 0x4552
movb $0x0, %al
callq 0x1060
movslq -0x8(%rbp), %rax
leaq 0x397a(%rip), %rcx      # 0x60a0
shlq $0x4, %rax
addq %rax, %rcx
movb $0x0, %al
callq *0x8(%rcx)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
leaq 0x1e33(%rip), %rsi      # 0x4572
leaq 0x1e24(%rip), %rax      # 0x456a
cmpl $0x0, %ecx
cmovneq %rax, %rsi
leaq 0x1910(%rip), %rdi      # 0x4064
movb $0x0, %al
callq 0x1060
cmpl $0x0, -0xc(%rbp)
jne 0x276a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2781
jmp 0x276c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x26d6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test1
static int test1()
{
    EV_DBG("test 1\n");
    int* a = evinit(int);
    if(evcnt(a) != 0) return 0;
    if(evvsz(a) != EV_INIT_COUNT) return 0;
    evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, %edi
movl $0x8, %esi
callq 0x12e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1aa0
cmpq $0x0, %rax
je 0x27c3
movl $0x0, -0x4(%rbp)
jmp 0x27eb
movq -0x10(%rbp), %rdi
callq 0x2210
cmpq $0x8, %rax
je 0x27db
movl $0x0, -0x4(%rbp)
jmp 0x27eb
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test2
static int test2()
{
    int* a = evinisz(128);
    if(evcnt(a) != 0) return 0;
    if(evvsz(a) != EV_INIT_COUNT) return 0;
    evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x80, %edi
movl $0x8, %esi
callq 0x12e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1aa0
cmpq $0x0, %rax
je 0x2833
movl $0x0, -0x4(%rbp)
jmp 0x285b
movq -0x10(%rbp), %rdi
callq 0x2210
cmpq $0x8, %rax
je 0x284b
movl $0x0, -0x4(%rbp)
jmp 0x285b
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test3
static int test3()
{
    int* a = evini(128,64);
    if(evcnt(a) != 0) return 0;
    if(evvsz(a) != 64) return 0;
    evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x80, %edi
movl $0x40, %esi
callq 0x12e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1aa0
cmpq $0x0, %rax
je 0x28a3
movl $0x0, -0x4(%rbp)
jmp 0x28cb
movq -0x10(%rbp), %rdi
callq 0x2210
cmpq $0x40, %rax
je 0x28bb
movl $0x0, -0x4(%rbp)
jmp 0x28cb
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test4
static int test4()
{
    int* a = evini(128,64);
    for(int i = 0; i < 1000; i++){
        evpsh(a,i);
    }

    for(int i = 0; i < 1000; i++){
        int* ai = evidx(a,i);
        if( *ai != i){ return 0;}
    }

    evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x80, %edi
movl $0x40, %esi
callq 0x12e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x2936
jmp 0x290d
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1940
movq %rax, -0x10(%rbp)
jmp 0x292b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2902
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x2978
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1b30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0x296b
movl $0x0, -0x4(%rbp)
jmp 0x2988
jmp 0x296d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x293d
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test5
static int test5()
{
    char** a = evini(128,64);
    for(int i = 0; i < 1000; i++){
        evpsh(a,"AA");
    }

    for(int i = 0; i < 1000; i++){
        char* ai = evidx(a,i);
        if( strcmp(ai,"AA"))return 0;
    }

    evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x80, %edi
movl $0x40, %esi
callq 0x12e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x2a04
jmp 0x29cd
movw 0x1bd0(%rip), %ax       # 0x45a4
movw %ax, -0x17(%rbp)
movb 0x1bc8(%rip), %al       # 0x45a6
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x17(%rbp), %rsi
movl $0x3, %edx
callq 0x1940
movq %rax, -0x10(%rbp)
jmp 0x29f9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x29c2
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x2a50
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1b30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1b74(%rip), %rsi      # 0x45a4
callq 0x1090
cmpl $0x0, %eax
je 0x2a43
movl $0x0, -0x4(%rbp)
jmp 0x2a60
jmp 0x2a45
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a0b
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test6
static int test6()
{
    char** a = NULL;
    char* str = "AA";
    for(int i = 0; i < 1000; i++){
        evpsh(a,str);
    }

    for(int i = 0; i < 1000; i++){
        char** ai = evidx(a,i);
        if( strcmp(*ai,str))return 0;
    }

    evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq $0x0, -0x10(%rbp)
leaq 0x1b1d(%rip), %rax      # 0x45a4
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x2ac8
jmp 0x2a9d
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x1940
movq %rax, -0x10(%rbp)
jmp 0x2abd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a92
movl $0x0, -0x2c(%rbp)
cmpl $0x3e8, -0x2c(%rbp)     # imm = 0x3E8
jge 0x2b14
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x1b30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1090
cmpl $0x0, %eax
je 0x2b07
movl $0x0, -0x4(%rbp)
jmp 0x2b24
jmp 0x2b09
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2acf
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test7
static int test7()
{
    char** a = NULL;
    char* strs[] = {
            "Test",
            "Best",
            "Rest",
            "Vector",
            "Victor",
            0
    };

    for(int i = 0; strs[i]; i++){
        evpsh(a, strs[i]);
    }

    for(int i = 0; i < evcnt(a); i++){
        if(strcmp(a[i],strs[i])) return 0;
    }

    a = evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq $0x0, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x3275(%rip), %rsi      # 0x5dc0
movl $0x30, %edx
callq 0x10a0
movl $0x0, -0x44(%rbp)
movslq -0x44(%rbp), %rax
cmpq $0x0, -0x40(%rbp,%rax,8)
je 0x2b9a
jmp 0x2b6a
movslq -0x44(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x8, %edx
callq 0x1940
movq %rax, -0x10(%rbp)
jmp 0x2b8f
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2b5c
movl $0x0, -0x54(%rbp)
movslq -0x54(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1aa0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2bf3
movq -0x10(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movslq -0x54(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rsi
callq 0x1090
cmpl $0x0, %eax
je 0x2be6
movl $0x0, -0x4(%rbp)
jmp 0x2c07
jmp 0x2be8
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x2ba1
movq -0x10(%rbp), %rdi
callq 0x1f10
movq %rax, -0x10(%rbp)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test9
static int test9()
{
    int* a = evini(128,64);
    for(int i = 0; i < 1000; i++){
        evpsh(a,i);
    }

    for(int i = 0; i < 999; i++){
        evdel(a,0);
        int* ai = evidx(a,0);
        if(*ai != i +1) return 0;
    }

    evdel(a,0);
    if(evcnt(a) != 0) return 0;

    evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x80, %edi
movl $0x40, %esi
callq 0x12e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x2ea6
jmp 0x2e7d
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1940
movq %rax, -0x10(%rbp)
jmp 0x2e9b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2e72
movl $0x0, -0x1c(%rbp)
cmpl $0x3e7, -0x1c(%rbp)     # imm = 0x3E7
jge 0x2efa
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2050
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x2eed
movl $0x0, -0x4(%rbp)
jmp 0x2f2f
jmp 0x2eef
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ead
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2050
movq -0x10(%rbp), %rdi
callq 0x1aa0
cmpq $0x0, %rax
je 0x2f1f
movl $0x0, -0x4(%rbp)
jmp 0x2f2f
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test10
static int test10()
{
    int* a = evini(sizeof(int), 0);
    for(int i = 0;i < 1000;i++){
        evpsh(a, i);
    }

    for(int i = 0;i < 999;i++){
        evpop(a);
        int* a0 = evidx(a,0);
        int* ac = evidx(a,evcnt(a) - 1);

        if(*a0 != 0) return 0;
        if(*ac != 999 - 1 - i) return 0;
    }

    evpop(a);
    if(evcnt(a) != 0) return 0;

    evfree(a);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x12e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x2f95
jmp 0x2f6c
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1940
movq %rax, -0x10(%rbp)
jmp 0x2f8a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f61
movl $0x0, -0x1c(%rbp)
cmpl $0x3e7, -0x1c(%rbp)     # imm = 0x3E7
jge 0x3021
movq -0x10(%rbp), %rdi
callq 0x1fa0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b30
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1aa0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x1b30
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2ff6
movl $0x0, -0x4(%rbp)
jmp 0x3052
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl $0x3e6, %ecx            # imm = 0x3E6
subl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
je 0x3011
movl $0x0, -0x4(%rbp)
jmp 0x3052
jmp 0x3013
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2f9c
movq -0x10(%rbp), %rdi
callq 0x1fa0
movq -0x10(%rbp), %rdi
callq 0x1aa0
cmpq $0x0, %rax
je 0x3042
movl $0x0, -0x4(%rbp)
jmp 0x3052
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test11
static int test11()
{
    int* a = evinisz(128);
    int* b = NULL;

    for(int i = 0; i < 1000; i++){
        evpsh(a,i);
    }

    b = evcpy(a);

    for(int i = 0; i < 1000; i++){
        int* ai = (int*)evidx(a,i);
        int* bi = (int*)evidx(b,i);

        //Check that these are indeed different peices of memory
        if(ai == bi) return 0;

        //But that they have the same value
        if(*ai != *bi) return 0;
    }

    evfree(a);
    evfree(b);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x80, %edi
movl $0x8, %esi
callq 0x12e0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
jge 0x30be
jmp 0x3095
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x1940
movq %rax, -0x10(%rbp)
jmp 0x30b3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x308a
movq -0x10(%rbp), %rdi
callq 0x2580
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3e8, -0x24(%rbp)     # imm = 0x3E8
jge 0x3134
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x1b30
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x1b30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x3110
movl $0x0, -0x4(%rbp)
jmp 0x314d
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
je 0x3127
movl $0x0, -0x4(%rbp)
jmp 0x314d
jmp 0x3129
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x30d2
movq -0x10(%rbp), %rdi
callq 0x1f10
movq -0x18(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/test.c
// Function: test12
static int test12()
{
    int* a = NULL;
    size_t c = evcnt(a);
    if(c != 0){
        return 0;
    }

    int sum1    = 0;
    int first   = 0;
    int last    = 0;
    int r       = -1;
    for(int i = 0; i < 1000; i++){
        r = rand();
        if(i == 0){
            first = r;
        }

        evpsh(a,r);
        sum1 += r;
    }

    last = r;

    if(first != *(int*)evhead(a)){
        return 0;
    }

    if(last != *(int*)evtail(a)){
        return 0;
    }

    int sum2 = 0;
    eveach(a, ai){
        sum2 += *ai;
    }

    if(sum1 != sum2){
        return 0;
    }

    evfree(a);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1aa0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3190
movl $0x0, -0x4(%rbp)
jmp 0x32a3
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
cmpl $0x3e8, -0x2c(%rbp)     # imm = 0x3E8
jge 0x3202
callq 0x1100
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x31d0
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x31d2
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x4, %edx
callq 0x1940
movq %rax, -0x10(%rbp)
movl -0x28(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x31b3
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d20
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
je 0x322a
movl $0x0, -0x4(%rbp)
jmp 0x32a3
movl -0x24(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ce0
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl (%rcx), %eax
je 0x324c
movl $0x0, -0x4(%rbp)
jmp 0x32a3
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d20
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3282
movq -0x40(%rbp), %rax
movl (%rax), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de0
movq %rax, -0x40(%rbp)
jmp 0x3260
movl -0x1c(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x3293
movl $0x0, -0x4(%rbp)
jmp 0x32a3
movq -0x10(%rbp), %rdi
callq 0x1f10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vidarr[P]ringbuffer/test/cached_ringbuffer_test.c
// Function: test_cached_ringbuffer_create
void test_cached_ringbuffer_create() {

    Ringbuffer* buffer = 0;

    buffer = ringbuffer_create(1, 0, 0);
    assert(buffer);
    assert(capacity_func == buffer->capacity);
    assert(add_func == buffer->add);
    assert(pop_func == buffer->pop);
    assert(free_func == buffer->free);

    buffer = buffer->free(buffer);

    fprintf(stdout, "cached ringbuffer_create OK\n");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1190
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15fe
jmp 0x161d
leaq 0x1a21(%rip), %rdi      # 0x3026
leaq 0x1a21(%rip), %rsi      # 0x302d
movl $0x5a, %edx
leaq 0x1a33(%rip), %rcx      # 0x304b
callq 0x1040
movq -0x8(%rbp), %rcx
leaq -0x308(%rip), %rax      # 0x1320
cmpq (%rcx), %rax
jne 0x162f
jmp 0x164e
leaq 0x1a3a(%rip), %rdi      # 0x3070
leaq 0x19f0(%rip), %rsi      # 0x302d
movl $0x5b, %edx
leaq 0x1a02(%rip), %rcx      # 0x304b
callq 0x1040
movq -0x8(%rbp), %rcx
leaq -0x2f9(%rip), %rax      # 0x1360
cmpq 0x8(%rcx), %rax
jne 0x1661
jmp 0x1680
leaq 0x1a2a(%rip), %rdi      # 0x3092
leaq 0x19be(%rip), %rsi      # 0x302d
movl $0x5c, %edx
leaq 0x19d0(%rip), %rcx      # 0x304b
callq 0x1040
movq -0x8(%rbp), %rcx
leaq -0x25b(%rip), %rax      # 0x1430
cmpq 0x10(%rcx), %rax
jne 0x1693
jmp 0x16b2
leaq 0x1a10(%rip), %rdi      # 0x30aa
leaq 0x198c(%rip), %rsi      # 0x302d
movl $0x5d, %edx
leaq 0x199e(%rip), %rcx      # 0x304b
callq 0x1040
movq -0x8(%rbp), %rcx
leaq -0x20d(%rip), %rax      # 0x14b0
cmpq 0x18(%rcx), %rax
jne 0x16c5
jmp 0x16e4
leaq 0x19f6(%rip), %rdi      # 0x30c2
leaq 0x195a(%rip), %rsi      # 0x302d
movl $0x5e, %edx
leaq 0x196c(%rip), %rcx      # 0x304b
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x8(%rbp)
movq 0x38db(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
leaq 0x19d5(%rip), %rsi      # 0x30dc
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vidarr[P]ringbuffer/test/cached_ringbuffer_test.c
// Function: get_data_buffer
DataBuffer* get_data_buffer(Ringbuffer* cache, size_t min_length_bytes) {

    DataBuffer* db =  0;

    if(0 != cache) {
        db = cache->pop(cache);
    }

    if(0 == db) {
        db = calloc(1, sizeof(DataBuffer));
    }

    if(db->capacity_bytes < min_length_bytes) {
        if(0 != db->data) {
            free(db->data);
            db->data = 0;
        }
    }

    if(0 == db->data) {
        db->data = calloc(1, sizeof(min_length_bytes) * sizeof(uint8_t));
        db->capacity_bytes = min_length_bytes;
    }

    db->bytes_used = 0;

    return db;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x1752
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x176d
movl $0x1, %edi
movl $0x18, %esi
callq 0x1060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x17a1
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x179f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x17a1
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x17d2
movl $0x1, %edi
movl $0x8, %esi
callq 0x1060
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vidarr[P]ringbuffer/test/cached_ringbuffer_test.c
// Function: free_data_buffer
void free_data_buffer(void* data_buffer, void* arg) {

    if(0 != arg) {
        size_t* counter = arg;
        *counter = 1 + *counter;
    }

    if(0 == data_buffer) goto error;
    DataBuffer* db = data_buffer;

    if(0 != db->data) {
        free(db->data);
        db->data = 0;
    }

    free(db);

error:

    return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1822
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x182c
jmp 0x1862
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x1859
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vidarr[P]ringbuffer/test/cached_ringbuffer_test.c
// Function: main
int main(int argc, char** argv) {

    /* The interface tests */
    size_t free_count = 0;
    Ringbuffer* cache = ringbuffer_create(31, count_free, &free_count);
    free_item = cache_free;
    free_item_additional_arg = cache;

    test_ringbuffer_create();
    test_capacity();
    test_add();
    test_pop();
    cache->free(cache);
    cache = 0;

    /* Caching tests */
    test_cached_ringbuffer_create();
    test_cached_free();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1f, %edi
leaq 0x7d(%rip), %rsi        # 0x1ac0
leaq -0x18(%rbp), %rdx
callq 0x1190
movq %rax, -0x20(%rbp)
leaq 0x3611(%rip), %rax      # 0x5068
leaq -0x4fe(%rip), %rcx      # 0x1560
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
leaq 0x3604(%rip), %rax      # 0x5070
movq %rcx, (%rax)
movb $0x0, %al
callq 0x1af0
movb $0x0, %al
callq 0x1bb0
movb $0x0, %al
callq 0x1ca0
movb $0x0, %al
callq 0x1f80
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq $0x0, -0x20(%rbp)
callq 0x15d0
callq 0x1870
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/main.c
// Function: print_hardware
static void
print_hardware(const char * str)
{

	/* Inform the user of the general topic... */
	printf("%s", str);

	/* ... and whether we're using hardware acceleration or not. */
#if defined(CPUSUPPORT_CONFIG_FILE)
#if defined(CPUSUPPORT_X86_SHANI) && defined(CPUSUPPORT_X86_SSSE3)
	if (cpusupport_x86_shani() && cpusupport_x86_ssse3())
		printf(" using hardware SHANI");
	else
#endif
#if defined(CPUSUPPORT_X86_SSE2)
	if (cpusupport_x86_sse2())
		printf(" using hardware SSE2");
	else
#endif
#if defined(CPUSUPPORT_ARM_SHA256)
	if (cpusupport_arm_sha256())
		printf(" using hardware SHA256");
	else
#endif
		printf(" using software SHA");

#if defined(CPUSUPPORT_X86_AESNI)
	if (cpusupport_x86_aesni())
		printf(" and hardware AESNI.\n");
	else
#endif
		printf(" and software AES.\n");
#else
	printf(" with unknown hardware acceleration status.\n");
#endif /* CPUSUPPORT_CONFIG_FILE */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x157c3(%rip), %rdi     # 0x1846a
movb $0x0, %al
callq 0x2060
callq 0x2d30
cmpl $0x0, %eax
je 0x2cd2
callq 0x2da0
cmpl $0x0, %eax
je 0x2cd2
leaq 0x154e6(%rip), %rdi     # 0x181af
movb $0x0, %al
callq 0x2060
jmp 0x2cfc
callq 0x2e10
cmpl $0x0, %eax
je 0x2cec
leaq 0x154e2(%rip), %rdi     # 0x181c5
movb $0x0, %al
callq 0x2060
jmp 0x2cfa
leaq 0x154e7(%rip), %rdi     # 0x181da
movb $0x0, %al
callq 0x2060
jmp 0x2cfc
callq 0x2e80
cmpl $0x0, %eax
je 0x2d16
leaq 0x154e1(%rip), %rdi     # 0x181ee
movb $0x0, %al
callq 0x2060
jmp 0x2d24
leaq 0x154e7(%rip), %rdi     # 0x18204
movb $0x0, %al
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/fd_drain.c
// Function: fd_drain_internal
static int
fd_drain_internal(void * cookie)
{
	int fd = *((int *)cookie);
	uint8_t mybuf[FD_DRAIN_MAX_SIZE];
	ssize_t readlen;

	/* Loop until we hit EOF or an error. */
	do {
		readlen = read(fd, mybuf, FD_DRAIN_MAX_SIZE);
	} while (readlen > 0);

	/* Check for an error. */
	if (readlen == -1) {
		warnp("read");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure!  This value will be the pid's exit code. */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4030, %rsp           # imm = 0x4030
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
leaq -0x4020(%rbp), %rsi
movl $0x4000, %edx           # imm = 0x4000
callq 0x2140
movq %rax, -0x4028(%rbp)
cmpq $0x0, -0x4028(%rbp)
jg 0x2f28
cmpq $-0x1, -0x4028(%rbp)
jne 0x2f90
jmp 0x2f59
callq 0x2340
cmpl $0x0, (%rax)
je 0x2f7e
leaq 0x152ae(%rip), %rdi     # 0x18218
movb $0x0, %al
callq 0x14390
callq 0x2340
movl $0x0, (%rax)
jmp 0x2f8c
leaq 0x15293(%rip), %rdi     # 0x18218
movb $0x0, %al
callq 0x145e0
jmp 0x2f8e
jmp 0x2f99
movl $0x0, -0x4(%rbp)
jmp 0x2fa0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x4030, %rsp           # imm = 0x4030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/fd_drain.c
// Function: fd_drain_fork
pid_t
fd_drain_fork(int fd)
{
	pid_t pid;

	/* Fork a new process to run the function. */
	if ((pid = fork_func(fd_drain_internal, &fd)) == -1)
		goto err0;

	/* Success! */
	return (pid);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xb2(%rip), %rdi       # 0x2f10
leaq -0x8(%rbp), %rsi
callq 0x13760
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
jne 0x2fd5
jmp 0x2fdd
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2fe4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_aesctr.c
// Function: standalone_aesctr
int
standalone_aesctr(const size_t * perfsizes, size_t num_perf,
    size_t nbytes_perftest, size_t nbytes_warmup)
{
	struct crypto_aes_key * k_aes;
	uint8_t kbuf[32];

	/* Report what we're doing. */
	printf("Testing AES-CTR\n");

	/* Initialize. */
	memset(kbuf, 0, 32);
	if ((k_aes = crypto_aes_key_expand(kbuf, 32)) == NULL)
		goto err0;

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 0, aesctr_init, aesctr_func, NULL, k_aes)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Clean up. */
	crypto_aes_key_free(k_aes);

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x1520e(%rip), %rdi     # 0x1821d
movb $0x0, %al
callq 0x2060
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2080
leaq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0xd790
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3040
jmp 0x30b3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
xorl %r8d, %r8d
leaq 0x72(%rip), %r9         # 0x30d0
leaq 0xbb(%rip), %r10        # 0x3120
xorl %r11d, %r11d
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x13d80
cmpl $0x0, %eax
je 0x30a1
jmp 0x3086
leaq 0x151a1(%rip), %rdi     # 0x1822e
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x30b3
movq -0x30(%rbp), %rdi
callq 0xd8a0
movl $0x0, -0x4(%rbp)
jmp 0x30ba
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_aesctr.c
// Function: aesctr_init
static int
aesctr_init(void * cookie, uint8_t * buf, size_t buflen)
{
	size_t i;

	(void)cookie; /* UNUSED */

	/* Set the input. */
	for (i = 0; i < buflen; i++)
		buf[i] = (uint8_t)(i & 0xff);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3117
movq -0x20(%rbp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x30e8
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_aesctr.c
// Function: aesctr_func
static int
aesctr_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct crypto_aes_key * k_aes = cookie;
	size_t i;

	/* Do the hashing. */
	for (i = 0; i < nreps; i++) {
		/*
		 * In proto_crypt_enc(), we would append the length to buf,
		 * then encrypt the buffer + 4 bytes of length.  For
		 * simplicity, this test does not imitate that details.
		 */
		crypto_aesctr_buf(k_aes, i, buf, buf, buflen);
	}

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3179
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0xff10
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3148
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_aesctr_hmac.c
// Function: standalone_aesctr_hmac
int
standalone_aesctr_hmac(const size_t * perfsizes, size_t num_perf,
    size_t nbytes_perftest, size_t nbytes_warmup)
{
	struct aesctr_hmac_cookie aesctr_hmac_cookie;
	struct aesctr_hmac_cookie * ahc = &aesctr_hmac_cookie;
	HMAC_SHA256_CTX ctx;
	uint8_t kbuf[32];

	/* Report what we're doing. */
	printf("Testing HMAC_SHA256 with AES-CTR\n");

	/* Initialize. */
	ahc->ctx = &ctx;
	memset(kbuf, 0, 32);
	if ((ahc->k_aes = crypto_aes_key_expand(kbuf, 32)) == NULL)
		goto err0;

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 0, aesctr_hmac_init, aesctr_hmac_func, NULL, ahc)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Clean up. */
	crypto_aes_key_free(ahc->k_aes);

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x15085(%rip), %rdi     # 0x1823f
movb $0x0, %al
callq 0x2060
movq -0x40(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2080
leaq -0x130(%rbp), %rdi
movl $0x20, %esi
callq 0xd790
movq -0x40(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x3203
jmp 0x327a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
xorl %r8d, %r8d
leaq 0x6f(%rip), %r9         # 0x3290
leaq 0xe8(%rip), %r10        # 0x3310
xorl %r11d, %r11d
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x13d80
cmpl $0x0, %eax
je 0x3264
jmp 0x3249
leaq 0x14fde(%rip), %rdi     # 0x1822e
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x327a
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xd8a0
movl $0x0, -0x4(%rbp)
jmp 0x3281
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_aesctr_hmac.c
// Function: aesctr_hmac_init
static int
aesctr_hmac_init(void * cookie, uint8_t * buf, size_t buflen)
{
	struct aesctr_hmac_cookie * ahc = cookie;
	uint8_t kbuf[32];
	size_t i;

	/* (Re-)Initialize the context. */
	memset(kbuf, 0, 32);
	HMAC_SHA256_Init(ahc->ctx, kbuf, 32);

	/* Set the input. */
	for (i = 0; i < buflen; i++)
		buf[i] = (uint8_t)(i & 0xff);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2080
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
callq 0x5b30
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3308
movq -0x48(%rbp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x32d9
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_aesctr_hmac.c
// Function: aesctr_hmac_func
static int
aesctr_hmac_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct aesctr_hmac_cookie * ahc = cookie;
	uint8_t hbuf[32];
	uint8_t pnum_exp[8];
	size_t i;

	/* Do the hashing. */
	for (i = 0; i < nreps; i++) {
		/*
		 * In proto_crypt_enc(), we would append the length to buf,
		 * then encrypt the buffer + 4 bytes of length.  After that,
		 * we'd hash the resulting (larger) buffer.  For simplicity,
		 * this test does not imitate those details.
		 */
		crypto_aesctr_buf(ahc->k_aes, i, buf, buf, buflen);
		HMAC_SHA256_Update(ahc->ctx, buf, buflen);
		be64enc(pnum_exp, i);
		HMAC_SHA256_Update(ahc->ctx, pnum_exp, 8);
	}
	HMAC_SHA256_Final(hbuf, ahc->ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x33a3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0xff10
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5d10
leaq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x33c0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq -0x58(%rbp), %rsi
movl $0x8, %edx
callq 0x5d10
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x3338
leaq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x5da0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_hmac.c
// Function: standalone_hmac
int
standalone_hmac(const size_t * perfsizes, size_t num_perf,
    size_t nbytes_perftest, size_t nbytes_warmup)
{
	HMAC_SHA256_CTX ctx;

	/* Report what we're doing. */
	printf("Testing HMAC_SHA256 with iteration numbers\n");

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 0, hmac_init, hmac_func, NULL, &ctx)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x14daf(%rip), %rdi     # 0x18261
movb $0x0, %al
callq 0x2060
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %r8d, %r8d
leaq 0x6d(%rip), %r9         # 0x3540
leaq 0xe6(%rip), %r10        # 0x35c0
xorl %eax, %eax
leaq -0xf8(%rbp), %rax
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x13d80
cmpl $0x0, %eax
je 0x351c
jmp 0x3501
leaq 0x14d26(%rip), %rdi     # 0x1822e
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x3525
movl $0x0, -0x4(%rbp)
jmp 0x352c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_hmac.c
// Function: hmac_init
static int
hmac_init(void * cookie, uint8_t * buf, size_t buflen)
{
	HMAC_SHA256_CTX * ctx = cookie;
	uint8_t kbuf[32];
	size_t i;

	/* (Re-)Initialize the context. */
	memset(kbuf, 0, 32);
	HMAC_SHA256_Init(ctx, kbuf, 32);

	/* Set the input. */
	for (i = 0; i < buflen; i++)
		buf[i] = (uint8_t)(i & 0xff);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2080
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
callq 0x5b30
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x35b5
movq -0x48(%rbp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x3586
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_hmac.c
// Function: hmac_func
static int
hmac_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	HMAC_SHA256_CTX * ctx = cookie;
	uint8_t hbuf[32];
	uint8_t pnum_exp[8];
	size_t i;

	/* Do the hashing. */
	for (i = 0; i < nreps; i++) {
		HMAC_SHA256_Update(ctx, buf, buflen);

		/* Hash the iteration number as well. */
		be64enc(pnum_exp, i);
		HMAC_SHA256_Update(ctx, pnum_exp, 8);
	}
	HMAC_SHA256_Final(hbuf, ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3630
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5d10
leaq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x3650
movq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x8, %edx
callq 0x5d10
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x35e8
leaq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5da0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pce.c
// Function: standalone_pce
int
standalone_pce(const size_t * perfsizes, size_t num_perf,
    size_t nbytes_perftest, size_t nbytes_warmup)
{
	struct pce pce_actual;
	struct pce * pce = &pce_actual;

	/* Report what we're doing. */
	printf("Testing proto_crypt_enc()\n");

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 0, pce_init, pce_func, pce_cleanup, pce)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x14b46(%rip), %rdi     # 0x1828d
movb $0x0, %al
callq 0x2060
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
xorl %r8d, %r8d
leaq 0x64(%rip), %r9         # 0x37d0
leaq 0xfd(%rip), %r11        # 0x3870
leaq 0x176(%rip), %r10       # 0x38f0
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x13d80
cmpl $0x0, %eax
je 0x37af
jmp 0x3794
leaq 0x14a93(%rip), %rdi     # 0x1822e
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x37b8
movl $0x0, -0x4(%rbp)
jmp 0x37bf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pce.c
// Function: pce_init
static int
pce_init(void * cookie, uint8_t * buf, size_t buflen)
{
	struct pce * pce = cookie;
	uint8_t kbuf[64];
	size_t i;

	/* Set up encryption key. */
	memset(kbuf, 0, 64);
	if ((pce->k = mkkeypair(kbuf)) == NULL)
		goto err0;

	/* Set the input. */
	for (i = 0; i < buflen; i++)
		buf[i] = (uint8_t)(i & 0xff);

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2080
leaq -0x70(%rbp), %rdi
callq 0x4950
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x3817
jmp 0x3857
movq $0x0, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x384e
movq -0x78(%rbp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x78(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x381f
movl $0x0, -0x4(%rbp)
jmp 0x385e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_pce.c
// Function: pce_func
static int
pce_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct pce * pce = cookie;
	uint8_t encbuf[PCRYPT_ESZ];
	size_t i;

	/* Encrypt a bunch of times. */
	for (i = 0; i < nreps; i++)
		proto_crypt_enc(buf, buflen, encbuf, pce->k);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x458(%rbp)
movq -0x458(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x38da
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x450(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
callq 0x5220
movq -0x458(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x458(%rbp)
jmp 0x389e
xorl %eax, %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/perftests/standalone-enc/standalone_transfer_noencrypt.c
// Function: standalone_transfer_noencrypt
int
standalone_transfer_noencrypt(const size_t * perfsizes, size_t num_perf,
    size_t nbytes_perftest, size_t nbytes_warmup, int method)
{
	struct shared shared_actual;
	const char * method_str;

	/* Report what we're doing. */
	if (method == 0)
		method_str = "two pipes";
	else if (method == 1)
		method_str = "two socketpairs";
	else {
		warn0("method not recognized");
		goto err0;
	}
	printf("Testing sending data over %s, no encryption\n", method_str);

	/* Record the communication method. */
	shared_actual.method = method;

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 0, perftest_init, perftest_func, perftest_cleanup,
	    &shared_actual)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x3952
leaq 0x1495c(%rip), %rax     # 0x182a8
movq %rax, -0x68(%rbp)
jmp 0x3987
cmpl $0x1, -0x2c(%rbp)
jne 0x3965
leaq 0x14953(%rip), %rax     # 0x182b2
movq %rax, -0x68(%rbp)
jmp 0x3985
jmp 0x3967
leaq 0x14954(%rip), %rdi     # 0x182c2
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x3a09
jmp 0x3987
movq -0x68(%rbp), %rsi
leaq 0x14946(%rip), %rdi     # 0x182d8
movb $0x0, %al
callq 0x2060
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %r8d, %r8d
leaq 0x67(%rip), %r9         # 0x3a20
leaq 0x3b0(%rip), %r11       # 0x3d70
leaq 0x4b9(%rip), %r10       # 0x3e80
leaq -0x60(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x13d80
cmpl $0x0, %eax
je 0x3a00
jmp 0x39e5
leaq 0x14842(%rip), %rdi     # 0x1822e
movb $0x0, %al
callq 0x145e0
callq 0x2340
movl $0x0, (%rax)
jmp 0x3a09
movl $0x0, -0x4(%rbp)
jmp 0x3a10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)