LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/glmath.h
// Function: Mat4Perspective
static inline void Mat4Perspective(float fovy, float aspect, float nearVal,
                                   float farVal, Mat4 out) {
    float f, fn;

    f = 1.0f / tanf(fovy * 0.5f);
    fn = 1.0f / (nearVal - farVal);

    out[0] = f / aspect;
    out[5] = f;
    out[10] = (nearVal + farVal) * fn;
    out[11] = -1.0f;
    out[14] = 2.0f * nearVal * farVal * fn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movss 0x21c4(%rip), %xmm0     # 0x508c
mulss -0x4(%rbp), %xmm0
callq 0x21d0
movaps %xmm0, %xmm1
movss 0x219f(%rip), %xmm0     # 0x507c
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0xc(%rbp), %xmm1
subss -0x10(%rbp), %xmm1
movss 0x2184(%rip), %xmm0     # 0x507c
divss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
divss -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0xc(%rbp), %xmm0
addss -0x10(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
movss 0x2143(%rip), %xmm0     # 0x5088
movss %xmm0, 0x2c(%rax)
movss 0x2132(%rip), %xmm0     # 0x5084
mulss -0xc(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/glmath.h
// Function: Mat4LookAt
static inline void Mat4LookAt(Vec3 eye, Vec3 center, Vec3 up, Mat4 out) {
    Vec3 f, u, s;

    Vec3Sub(center, eye, f);
    Vec3Norm(f);

    Vec3CrossNorm(f, up, s);
    Vec3Cross(s, f, u);

    out[0] = s[0];
    out[1] = u[0];
    out[2] = -f[0];
    out[4] = s[1];
    out[5] = u[1];
    out[6] = -f[1];
    out[8] = s[2];
    out[9] = u[2];
    out[10] = -f[2];
    out[12] = -Vec3Dot(s, eye);
    out[13] = -Vec3Dot(u, eye);
    out[14] = Vec3Dot(f, eye);
    out[3] = out[7] = out[11] = 0.0f;
    out[15] = 1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x3cd0
leaq -0x2c(%rbp), %rdi
callq 0x3d30
leaq -0x2c(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x3de0
leaq -0x44(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x3e20
movss -0x44(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x2c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x40(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x28(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x18(%rax)
movss -0x3c(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x20(%rax)
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x24(%rax)
movss -0x24(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x28(%rax)
leaq -0x44(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3f00
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x30(%rax)
leaq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3f00
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x34(%rax)
leaq -0x2c(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3f00
movq -0x20(%rbp), %rax
movss %xmm0, 0x38(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
movq -0x20(%rbp), %rax
movss 0x1ad8(%rip), %xmm0     # 0x507c
movss %xmm0, 0x3c(%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/glmath.h
// Function: Mat4RotateZ
static inline void Mat4RotateZ(Mat4 in, Mat4 out, float angle) {
    Mat4 transform = MAT4_IDENTITY_INIT;

    float c, s;
    c = cosf(angle);
    s = sinf(angle);

    transform[0] = c;
    transform[1] = s;
    transform[4] = -s;
    transform[5] = c;

    Mat4Mul(in, transform, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x20e0
movss 0x1a9f(%rip), %xmm0     # 0x507c
movss %xmm0, -0x60(%rbp)
movss 0x1a92(%rip), %xmm0     # 0x507c
movss %xmm0, -0x4c(%rbp)
movss 0x1a85(%rip), %xmm0     # 0x507c
movss %xmm0, -0x38(%rbp)
movss 0x1a78(%rip), %xmm0     # 0x507c
movss %xmm0, -0x24(%rbp)
movss -0x14(%rbp), %xmm0
callq 0x21b0
movss %xmm0, -0x64(%rbp)
movss -0x14(%rbp), %xmm0
callq 0x2030
movss %xmm0, -0x68(%rbp)
movss -0x64(%rbp), %xmm0
movss %xmm0, -0x60(%rbp)
movss -0x68(%rbp), %xmm0
movss %xmm0, -0x5c(%rbp)
movss -0x68(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x50(%rbp)
movss -0x64(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3f60
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/glmath.h
// Function: Mat4RotateX
static inline void Mat4RotateX(Mat4 in, Mat4 out, float angle) {
    Mat4 transform = MAT4_IDENTITY_INIT;

    float c, s;
    c = cosf(angle);
    s = sinf(angle);

    transform[5] = c;
    transform[6] = s;
    transform[9] = -s;
    transform[10] = c;

    Mat4Mul(in, transform, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x20e0
movss 0x19cf(%rip), %xmm0     # 0x507c
movss %xmm0, -0x60(%rbp)
movss 0x19c2(%rip), %xmm0     # 0x507c
movss %xmm0, -0x4c(%rbp)
movss 0x19b5(%rip), %xmm0     # 0x507c
movss %xmm0, -0x38(%rbp)
movss 0x19a8(%rip), %xmm0     # 0x507c
movss %xmm0, -0x24(%rbp)
movss -0x14(%rbp), %xmm0
callq 0x21b0
movss %xmm0, -0x64(%rbp)
movss -0x14(%rbp), %xmm0
callq 0x2030
movss %xmm0, -0x68(%rbp)
movss -0x64(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x68(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x68(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x64(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3f60
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/glmath.h
// Function: Mat4RotateY
static inline void Mat4RotateY(Mat4 in, Mat4 out, float angle) {
    Mat4 transform = MAT4_IDENTITY_INIT;

    float c, s;
    c = cosf(angle);
    s = sinf(angle);

    transform[0] = c;
    transform[2] = -s;
    transform[8] = s;
    transform[10] = c;

    Mat4Mul(in, transform, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x20e0
movss 0x18ff(%rip), %xmm0     # 0x507c
movss %xmm0, -0x60(%rbp)
movss 0x18f2(%rip), %xmm0     # 0x507c
movss %xmm0, -0x4c(%rbp)
movss 0x18e5(%rip), %xmm0     # 0x507c
movss %xmm0, -0x38(%rbp)
movss 0x18d8(%rip), %xmm0     # 0x507c
movss %xmm0, -0x24(%rbp)
movss -0x14(%rbp), %xmm0
callq 0x21b0
movss %xmm0, -0x64(%rbp)
movss -0x14(%rbp), %xmm0
callq 0x2030
movss %xmm0, -0x68(%rbp)
movss -0x64(%rbp), %xmm0
movss %xmm0, -0x60(%rbp)
movss -0x68(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x58(%rbp)
movss -0x68(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x64(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3f60
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/glmath.h
// Function: Vec3Norm
static inline void Vec3Norm(Vec3 out) {
    float length = sqrtf(out[0] * out[0] + out[1] * out[1] + out[2] * out[2]);

    out[0] /= length;
    out[1] /= length;
    out[2] /= length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm1
movq -0x8(%rbp), %rax
movss (%rax), %xmm2
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x2230
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movss -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rax)
movss -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/demo/keyboard.c
// Function: print_tb
void print_tb(const char *str, int x, int y, uint16_t fg, uint16_t bg)
{
    while (*str) {
        uint32_t uni;
        str += tb_utf8_char_to_unicode(&uni, str);
        tb_change_cell(x, y, uni, fg, bg);
        x++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x53e9
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x9510
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
movw -0x12(%rbp), %ax
movzwl %ax, %ecx
movzwl -0x14(%rbp), %r8d
callq 0x7880
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x539e
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/demo/keyboard.c
// Function: pretty_print_mouse
void  pretty_print_mouse(struct tb_event *ev) {
    printf_tb(3, 19, TB_WHITE, TB_DEFAULT, "Mouse event: %d x %d", ev->x, ev->y);
    char *btn = "";
    switch (ev->key) {
    case TB_KEY_MOUSE_LEFT:
        btn = "MouseLeft: %d";
        break;
    case TB_KEY_MOUSE_MIDDLE:
        btn = "MouseMiddle: %d";
        break;
    case TB_KEY_MOUSE_RIGHT:
        btn = "MouseRight: %d";
        break;
    case TB_KEY_MOUSE_WHEEL_UP:
        btn = "MouseWheelUp: %d";
        break;
    case TB_KEY_MOUSE_WHEEL_DOWN:
        btn = "MouseWheelDown: %d";
        break;
    case TB_KEY_MOUSE_RELEASE:
        btn = "MouseRelease: %d";
    }
    counter++;
    printf_tb(43, 19, TB_WHITE, TB_DEFAULT, "Key: ");
    printf_tb(48, 19, TB_YELLOW, TB_DEFAULT, btn, counter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %r9d
movl 0x14(%rax), %ecx
movq %rsp, %rax
movl %ecx, (%rax)
leaq 0x3ebe(%rip), %r8       # 0xa2f1
xorl %ecx, %ecx
movb %cl, %al
movl $0x3, %edi
movl $0x13, %esi
movl $0x8, %edx
callq 0x53f0
leaq 0x3f3a(%rip), %rax      # 0xa38c
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
addl $0xffff001c, %eax       # imm = 0xFFFF001C
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x64ce
movq -0x18(%rbp), %rax
leaq 0x3b8b(%rip), %rcx      # 0xa004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3e7d(%rip), %rax      # 0xa306
movq %rax, -0x10(%rbp)
jmp 0x64ce
leaq 0x3e7e(%rip), %rax      # 0xa314
movq %rax, -0x10(%rbp)
jmp 0x64ce
leaq 0x3e81(%rip), %rax      # 0xa324
movq %rax, -0x10(%rbp)
jmp 0x64ce
leaq 0x3e83(%rip), %rax      # 0xa333
movq %rax, -0x10(%rbp)
jmp 0x64ce
leaq 0x3e87(%rip), %rax      # 0xa344
movq %rax, -0x10(%rbp)
jmp 0x64ce
leaq 0x3e8d(%rip), %rax      # 0xa357
movq %rax, -0x10(%rbp)
leaq 0x9fe7(%rip), %rax      # 0x104bc
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9fdb(%rip), %rax      # 0x104bc
movl %ecx, (%rax)
movl $0x2b, %edi
movl $0x13, %esi
movl $0x8, %edx
xorl %ecx, %ecx
leaq 0x3d83(%rip), %r8       # 0xa27e
movb $0x0, %al
callq 0x53f0
movq -0x10(%rbp), %r8
leaq 0x9faf(%rip), %rax      # 0x104bc
movl (%rax), %r9d
movl $0x30, %edi
movl $0x13, %esi
movl $0x4, %edx
xorl %ecx, %ecx
movb $0x0, %al
callq 0x53f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/demo/keyboard.c
// Function: dispatch_press
void dispatch_press(struct tb_event *ev)
{
    if (ev->mod & TB_MOD_ALT) {
        draw_key(K_LALT, TB_WHITE, TB_RED);
        draw_key(K_RALT, TB_WHITE, TB_RED);
    }

    struct combo *k = 0;
    if (ev->key >= TB_KEY_ARROW_RIGHT)
        k = &func_combos[0xFFFF-ev->key];
    else if (ev->ch < 128) {
        if (ev->ch == 0 && ev->key < 128)
            k = &combos[ev->key];
        else
            k = &combos[ev->ch];
    }
    if (!k)
        return;

    struct key **keys = k->keys;
    while (*keys) {
        draw_key(*keys, TB_WHITE, TB_RED);
        keys++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6578
leaq 0x779d(%rip), %rdi      # 0xdcf0
movl $0x8, %esi
movl $0x2, %edx
callq 0x54d0
leaq 0x7827(%rip), %rdi      # 0xdd90
movl $0x8, %esi
movl $0x2, %edx
callq 0x54d0
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
cmpl $0xffea, %eax           # imm = 0xFFEA
jl 0x65b5
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %ecx
movl $0xffff, %eax           # imm = 0xFFFF
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x9128(%rip), %rax      # 0xf6d0
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x6618
movq -0x8(%rbp), %rax
cmpl $0x80, 0x4(%rax)
jae 0x6616
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x65f9
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
cmpl $0x80, %eax
jge 0x65f9
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %ecx
leaq 0x78e4(%rip), %rax      # 0xded0
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x6614
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
leaq 0x78c7(%rip), %rax      # 0xded0
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x6616
jmp 0x6618
cmpq $0x0, -0x10(%rbp)
jne 0x6621
jmp 0x6657
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6657
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x8, %esi
movl $0x2, %edx
callq 0x54d0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x6629
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_06/calloc.c
// Function: main
int main(int argc, char *argv[])
{
  char *test_malloc_str_p;
  if ((test_malloc_str_p = c_malloc(27 * sizeof(char))) == NULL)
  {
    printf("Error: malloc faild to allocate the requrested memory.\n");
    return EXIT_FAILURE;
  }

  strcpy(test_malloc_str_p, "Content from malloc here.");
  printf("%s\n", test_malloc_str_p);
  c_free(test_malloc_str_p);

  char *test_calloc_str_p;
  if ((test_calloc_str_p = c_calloc(27, sizeof(char))) == NULL)
  {
    printf("Error: calloc faild to allocate the requrested memory.\n");
    return EXIT_FAILURE;
  }

  strcpy(test_calloc_str_p, "Content from calloc here.");
  printf("%s\n", test_calloc_str_p);
  c_free(test_calloc_str_p);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1b, %edi
callq 0x1250
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x11b4
leaq 0xe63(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x1241
movq -0x18(%rbp), %rdi
leaq 0xe7d(%rip), %rsi       # 0x203c
callq 0x1030
movq -0x18(%rbp), %rsi
leaq 0xe87(%rip), %rdi       # 0x2056
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1390
movl $0x1b, %edi
movl $0x1, %esi
callq 0x14c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x120f
leaq 0xe5b(%rip), %rdi       # 0x205a
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x1241
movq -0x20(%rbp), %rdi
leaq 0xe78(%rip), %rsi       # 0x2092
callq 0x1030
movq -0x20(%rbp), %rsi
leaq 0xe2c(%rip), %rdi       # 0x2056
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1390
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_06/calloc.c
// Function: c_malloc
void *c_malloc(size_t nr_of_bytes)
{
  Header *p;
  Header *prev_p;
  size_t nr_of_units = (nr_of_bytes + sizeof(Header) - 1) / sizeof(Header);

  if ((prev_p = free_p) == NULL)
  {
    base.s.free_block_p = free_p = prev_p = &base;
    base.s.size = 0;
  }

  for (p = prev_p->s.free_block_p;; prev_p = p, p = p->s.free_block_p)
  {
    if (p->s.size >= nr_of_units)
    {
      if (p->s.size == nr_of_units)
      {
        prev_p->s.free_block_p = p->s.free_block_p;
      }
      else
      {
        p->s.size -= nr_of_units;
        p += p->s.size;
        p->s.size = nr_of_units;
      }

      free_p = prev_p;
      return (void *)(p + 1);
    }

    if (p == free_p)
    {
      if ((p = c_morecore(nr_of_units)) == NULL)
      {
        return NULL;
      }
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
subq $0x1, %rax
shrq $0x4, %rax
movq %rax, -0x28(%rbp)
movq 0x2dd9(%rip), %rax      # 0x4050
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x12b3
leaq 0x2dd0(%rip), %rax      # 0x4058
movq %rax, -0x20(%rbp)
leaq 0x2dc5(%rip), %rax      # 0x4058
movq %rax, 0x2db6(%rip)      # 0x4050
leaq 0x2db7(%rip), %rax      # 0x4058
movq %rax, 0x2db0(%rip)      # 0x4058
movq $0x0, 0x2dad(%rip) # 0x4060
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jb 0x1336
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x12ea
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x131d
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x4, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x2d28(%rip)      # 0x4050
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x137c
movq -0x18(%rbp), %rax
cmpq 0x2d0f(%rip), %rax      # 0x4050
jne 0x1362
movq -0x28(%rbp), %rdi
callq 0x1520
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1360
movq $0x0, -0x8(%rbp)
jmp 0x137c
jmp 0x1362
jmp 0x1364
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12be
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_06/calloc.c
// Function: c_free
void c_free(void *a_p)
{
  Header *p;
  Header *b_p = (Header *)a_p - 1;

  for (p = free_p; !(b_p > p && b_p < p->s.free_block_p); p = p->s.free_block_p)
  {
    if (p >= p->s.free_block_p && (b_p > p || b_p < p->s.free_block_p))
    {
      break;
    }
  }

  if (b_p + b_p->s.size == p->s.free_block_p)
  {
    b_p->s.size += p->s.free_block_p->s.size;
    b_p->s.free_block_p = p->s.free_block_p->s.free_block_p;
  }
  else
  {
    b_p->s.free_block_p = p->s.free_block_p;
  }

  if (p + p->s.size == b_p)
  {
    p->s.size += b_p->s.size;
    p->s.free_block_p = b_p->s.free_block_p;
  }
  else
  {
    p->s.free_block_p = b_p;
  }

  free_p = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x18(%rbp)
movq 0x2ca5(%rip), %rax      # 0x4050
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jbe 0x13cf
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13da
jmp 0x140f
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x1400
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x13fe
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1400
jmp 0x140f
jmp 0x1402
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13af
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1455
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1463
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jne 0x14a0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x14ab
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x2b9a(%rip)      # 0x4050
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_06/calloc.c
// Function: c_calloc
void *c_calloc(size_t nr_of_blocks, size_t block_size)
{
  void *p = NULL;
  if ((p = c_malloc(nr_of_blocks * block_size)) == NULL)
  {
    return NULL;
  }
  memset(p, 0, nr_of_blocks * block_size);

  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
callq 0x1250
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x14fa
movq $0x0, -0x8(%rbp)
jmp 0x1516
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
imulq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x1050
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_06/calloc.c
// Function: c_morecore
Header *c_morecore(size_t nr_of_units)
{
  char *c_p;
  Header *u_p;

  if (nr_of_units < MIN_NR_OF_UNITS)
  {
    nr_of_units = MIN_NR_OF_UNITS;
  }

  c_p = sbrk(nr_of_units * sizeof(Header));
  if (c_p == (char *)-1)
  {
    return NULL;
  }

  u_p = (Header *)c_p;
  u_p->s.size = nr_of_units;
  c_free((void *)(u_p + 1));

  return free_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x400, -0x10(%rbp)     # imm = 0x400
jae 0x153e
movq $0x400, -0x10(%rbp)     # imm = 0x400
movq -0x10(%rbp), %rdi
shlq $0x4, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x18(%rbp)
jne 0x1566
movq $0x0, -0x8(%rbp)
jmp 0x1592
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x1390
movq 0x2ac2(%rip), %rax      # 0x4050
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/cpuid.c
// Function: main
int main(int argc, char **argv)
{
    char test_data[2048 * 1024];

    setup_tsc();
    memset(test_data, 'd', sizeof(test_data));

    benchmark(naiveChecksum, sizeof(test_data), test_data, "Generic");
    benchmark(avxChecksum, sizeof(test_data), test_data, "AVX2");
    benchmark(avxChecksumV2, sizeof(test_data), test_data, "AVX2 (optimized)");

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200010, %rsp         # imm = 0x200010
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1830
leaq -0x200010(%rbp), %rdi
movl $0x64, %esi
movl $0x200000, %edx         # imm = 0x200000
callq 0x1060
leaq -0x200010(%rbp), %rdx
leaq 0x10e(%rip), %rdi       # 0x12d0
movl $0x200000, %esi         # imm = 0x200000
leaq 0xe36(%rip), %rcx       # 0x2004
callq 0x1220
leaq -0x200010(%rbp), %rdx
leaq 0x13f(%rip), %rdi       # 0x1320
movl $0x200000, %esi         # imm = 0x200000
leaq 0xe1f(%rip), %rcx       # 0x200c
callq 0x1220
leaq -0x200010(%rbp), %rdx
leaq 0x170(%rip), %rdi       # 0x1370
movl $0x200000, %esi         # imm = 0x200000
leaq 0xe05(%rip), %rcx       # 0x2011
callq 0x1220
xorl %eax, %eax
addq $0x200010, %rsp         # imm = 0x200010
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/cpuid.c
// Function: benchmark
static void benchmark(int (*func)(const char * const target, size_t targetLength),
                      size_t len, const char *test_data, const char *type)
{
    uint64_t tsc_start;
    uint64_t tsc_end;
    uint64_t loops;
    int csum;

    loops = 0;
    tsc_start = rdtsc();
    tsc_end = tsc_start + tsc_per_sec;
    while (rdtsc() < tsc_end) {
        csum = func(test_data, len);
        asm("" : : "r"(csum));
        loops++;
    }

    printf("%s loops: %ld\n", type, loops);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
callq 0x12b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
leaq 0x2e04(%rip), %rcx      # 0x4058
addq (%rcx), %rax
movq %rax, -0x30(%rbp)
callq 0x12b0
cmpq -0x30(%rbp), %rax
jae 0x1288
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x125b
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0xd8b(%rip), %rdi       # 0x2022
movb $0x0, %al
callq 0x1030
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/cpuid_csum.c
// Function: naiveChecksum
int CSUM(const char * const target, size_t targetLength) {
	unsigned int checksum = 0;
	size_t i;

	for (i = 0; i < targetLength; ++i) {
		checksum += (unsigned int) target[i];
	}
	return checksum % 256;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1315
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12eb
movl -0x14(%rbp), %eax
andl $0xff, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_glob.c
// Function: main
int main(int argc, char **argv){
	if (argc < 2){
		print_usage(argv[0]);
		return 1;
	}

	const char *path = argv[1];

	glob_t globresults;

	const char **files = hm_glob_open(&globresults, path);

	if (files == NULL){
		printf("Error glob() %s\n", path);
		return 1;
	}

	size_t i = 0;
	const char **f = files;
	while(*f)
		printf("%5zu : %s\n", i++, *f++ );

	size_t size = hm_glob_size(files);

	if (i == size)
		printf("Total %zu files...\n", size);
	else
		printf("File count does not match! (%zu != %zu)\n", size, i);

	hm_glob_close(&globresults, files);

	return 0;
}

// Assembly:
subq $0x88, %rsp
movl $0x0, 0x84(%rsp)
movl %edi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
cmpl $0x2, 0x80(%rsp)
jge 0x11d5
movq 0x78(%rsp), %rax
movq (%rax), %rdi
callq 0x12f0
movl $0x1, 0x84(%rsp)
jmp 0x12d7
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1360
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1222
movq 0x70(%rsp), %rsi
leaq 0xdf9(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
movl $0x1, 0x84(%rsp)
jmp 0x12d7
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1275
movq 0x18(%rsp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rdx
leaq 0xda9(%rip), %rdi       # 0x2015
movb $0x0, %al
callq 0x1060
jmp 0x1235
movq 0x20(%rsp), %rdi
callq 0x1510
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x12a5
movq 0x8(%rsp), %rsi
leaq 0xd84(%rip), %rdi       # 0x2020
movb $0x0, %al
callq 0x1060
jmp 0x12bd
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0xd7e(%rip), %rdi       # 0x2034
movb $0x0, %al
callq 0x1060
movq 0x20(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1330
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/parser.tab.c
// Function: yystrlen
static YYPTRDIFF_T
yystrlen (const char *yystr)
{
  YYPTRDIFF_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x99be
jmp 0x99b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x99a0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/pasc600.c
// Function: main
int main(int argc, char* argv[]) {

    if (argc == 2) {
        filename = argv[1];

        if (!(yyin = fopen(filename, "r"))) {
            perror(filename);
            exit(EXIT_FAILURE);
        }

        if (DEBUG) printf("-> Line No. 1 <-");

        yyparse();
        fclose(yyin);

        // sem_analysis(ast);

        yylex_destroy();
        ast_free(ast);

        printf("\n");
        exit(EXIT_SUCCESS);
    }

    printf("\nUsage: %s {filename}\n", argv[0]);
    exit(EXIT_FAILURE);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0xcad4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x1f2f1(%rip)     # 0x2bd40
movq 0x1f2ea(%rip), %rdi     # 0x2bd40
leaq 0x1374c(%rip), %rsi     # 0x201a9
callq 0x7210
leaq 0x1f067(%rip), %rcx     # 0x2bad0
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xca88
movq 0x1f2c7(%rip), %rdi     # 0x2bd40
callq 0x7230
movl $0x1, %edi
callq 0x7250
leaq 0x1552c(%rip), %rdi     # 0x21fbb
movb $0x0, %al
callq 0x70f0
movb $0x0, %al
callq 0x73a0
leaq 0x1f02c(%rip), %rax     # 0x2bad0
movq (%rax), %rdi
callq 0x70c0
movb $0x0, %al
callq 0xc8c0
movq 0x1f28e(%rip), %rdi     # 0x2bd48
callq 0xfbd0
leaq 0x15597(%rip), %rdi     # 0x2205d
movb $0x0, %al
callq 0x70f0
xorl %edi, %edi
callq 0x7250
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x154ea(%rip), %rdi     # 0x21fcc
movb $0x0, %al
callq 0x70f0
movl $0x1, %edi
callq 0x7250
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/error.c
// Function: scanner_error
void scanner_error(int lineno, const char* error, ...) {

    va_list args;
    va_start(args, error);

    printf("\n" ANSI_BWHT "%s:%d: " ANSI_MAG "warning: " ANSI_RESET, filename, lineno);
    vprintf(error, args);
    printf("\n");

    va_end(args);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xcb58
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
leaq 0x1f19d(%rip), %rax     # 0x2bd40
movq (%rax), %rsi
movl -0x4(%rbp), %edx
leaq 0x15433(%rip), %rdi     # 0x21fe3
xorl %eax, %eax
movb %al, -0xe1(%rbp)
callq 0x70f0
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x71f0
movb -0xe1(%rbp), %al
leaq 0x15486(%rip), %rdi     # 0x2205d
callq 0x70f0
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/error.c
// Function: parser_error
void parser_error(int lineno, const char* error) {

    static unsigned parser_error_count = 0; // yyerrs

    printf("\n" ANSI_BWHT "%s:%d: " ANSI_RED "error: " ANSI_RESET "%s", filename, lineno, error);

    if (++parser_error_count == PARSER_MAX_ERRORS) {
        printf("\n\nParsing error limit (%u) is exceeded. Exiting...\n", PARSER_MAX_ERRORS);
        exit(EXIT_FAILURE);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1f13a(%rip), %rax     # 0x2bd40
movq (%rax), %rsi
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x153f0(%rip), %rdi     # 0x22007
movb $0x0, %al
callq 0x70f0
movl 0x1f12c(%rip), %eax     # 0x2bd50
addl $0x1, %eax
movl %eax, 0x1f123(%rip)     # 0x2bd50
cmpl $0x5, %eax
jne 0xcc4f
leaq 0x153f2(%rip), %rdi     # 0x2202b
movl $0x5, %esi
movb $0x0, %al
callq 0x70f0
movl $0x1, %edi
callq 0x7250
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/error.c
// Function: sem_error
void sem_error(int lineno, const char* error, ...) {

    va_list args;
    va_start(args, error);

    if (lineno == NO_LINE) {
        printf("\n" ANSI_BWHT "%s: " ANSI_MAG "error: " ANSI_RESET, filename);
    } else {
        printf("\n" ANSI_BWHT "%s:%d: " ANSI_MAG "error: " ANSI_RESET, filename, lineno);
    }

    vprintf(error, args);
    printf("\n");

    va_end(args);

    exit(EXIT_FAILURE);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xcc98
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpl $-0x1, -0x4(%rbp)
jne 0xccff
leaq 0x1f054(%rip), %rax     # 0x2bd40
movq (%rax), %rsi
leaq 0x15369(%rip), %rdi     # 0x2205f
movb $0x0, %al
callq 0x70f0
jmp 0xcd1a
leaq 0x1f03a(%rip), %rax     # 0x2bd40
movq (%rax), %rsi
movl -0x4(%rbp), %edx
leaq 0x1536b(%rip), %rdi     # 0x2207e
movb $0x0, %al
callq 0x70f0
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x71f0
leaq 0x1532f(%rip), %rdi     # 0x2205d
movb $0x0, %al
callq 0x70f0
leaq -0x30(%rbp), %rax
movl $0x1, %edi
callq 0x7250
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_id
Id* ast_id(const char* identifier) {

    Id* id = MALLOC(id, Id);

    id->identifier = strdup(identifier);
    id->next = NULL;

    return id;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x7298
movq %rax, -0x10(%rbp)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xcd81
leaq 0x15324(%rip), %rdi     # 0x220a0
callq 0xcb00
movq -0x8(%rbp), %rdi
callq 0x7260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_program
AST* ast_program(Definition* header, Declaration* declarations, Definition* subprograms, Statement* comp_statement) {

    AST* ast = MALLOC(ast, AST);

    ast->header = header;
    ast->declarations = declarations;
    ast->subprograms = subprograms;
    ast->comp_statement = comp_statement;

    return ast;

}

// 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)
movl $0x20, %edi
callq 0x7298
movq %rax, -0x28(%rbp)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xcded
leaq 0x152b8(%rip), %rdi     # 0x220a0
callq 0xcb00
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_program_declarations
Declaration* ast_program_declarations(Definition* constdefs, Definition* typedefs, Definition* vardefs) {

    Declaration* declaration = MALLOC(declaration, Declaration);

    declaration->constdefs = constdefs;
    declaration->typedefs = typedefs;
    declaration->vardefs = vardefs;

    return declaration;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xce69
leaq 0x1523c(%rip), %rdi     # 0x220a0
callq 0xcb00
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_program
Definition* ast_definition_program(Line line, Id* id) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_PROGRAM;
    definition->next = NULL;
    definition->program.id = id;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xced4
leaq 0x151d1(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_constant
Definition* ast_definition_constant(Line line, Id* id, Expression* expression) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_CONSTANT;
    definition->next = NULL;
    definition->constant.id = id;
    definition->constant.expression = expression;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcf48
leaq 0x1515d(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_type
Definition* ast_definition_type(Line line, Id* id, Type* type) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_TYPE;
    definition->next = NULL;
    definition->type.id = id;
    definition->type.type = type;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcfc8
leaq 0x150dd(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_field
Definition* ast_definition_field(Line line, Id* identifiers, Type* type) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_FIELD;
    definition->next = NULL;
    definition->field.identifiers = identifiers;
    definition->field.type = type;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd048
leaq 0x1505d(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x3, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_variable
Definition* ast_definition_variable(Line line, Id* identifiers, Type* type) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_VARIABLE;
    definition->next = NULL;
    definition->variable.identifiers = identifiers;
    definition->variable.type = type;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd0c8
leaq 0x14fdd(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x4, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_subprogram_forward
Definition* ast_definition_subprogram_forward(Line line, Definition* sub_header) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_SUBPROGRAM_FORWARD;
    definition->next = NULL;
    definition->subprogram_forward.sub_header = sub_header;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd144
leaq 0x14f61(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x5, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_subprogram
Definition* ast_definition_subprogram(Line line, Definition* sub_header, Declaration* declarations, Definition* subprograms, Statement* comp_statement) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_SUBPROGRAM;
    definition->next = NULL;
    definition->subprogram.sub_header = sub_header;
    definition->subprogram.declarations = declarations;
    definition->subprogram.subprograms = subprograms;
    definition->subprogram.comp_statement = comp_statement;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x30(%rbp)
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd1c0
leaq 0x14ee5(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl $0x6, 0x4(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_function
Definition* ast_definition_function(Line line, Id* id, Definition* formal_parameters, Type* type) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_FUNCTION;
    definition->next = NULL;
    definition->function.id = id;
    definition->function.formal_parameters = formal_parameters;
    definition->function.type = type;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x28(%rbp)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd25c
leaq 0x14e49(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x7, 0x4(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_procedure
Definition* ast_definition_procedure(Line line, Id* id, Definition* formal_parameters) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_PROCEDURE;
    definition->next = NULL;
    definition->procedure.id = id;
    definition->procedure.formal_parameters = formal_parameters;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd2e8
leaq 0x14dbd(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x8, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)