LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_old
data load_data_old(char **paths, int n, int m, char **labels, int k, int w, int h)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;
    d.X = load_image_paths(paths, n, w, h);
    d.y = load_labels_paths(paths, n, labels, k, 0);
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x36de1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x314c0
movq %rax, -0x8(%rbp)
movq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x50(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0x10(%rbp), %edx
movl 0x18(%rbp), %ecx
callq 0x316f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x341d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x36e73
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_regression
data load_data_regression(char **paths, int n, int m, int k, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;
    d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure, 0);
    d.y = load_regression_labels_paths(paths, n, k);
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movss %xmm3, -0x28(%rbp)
movss %xmm4, -0x2c(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x36eda
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x314c0
movq %rax, -0x8(%rbp)
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x60(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
movl 0x10(%rbp), %ecx
movl 0x18(%rbp), %r8d
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
movss -0x2c(%rbp), %xmm4
xorl %r9d, %r9d
callq 0x31790
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x33f30
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x36f83
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_augment
data load_data_augment(char **paths, int n, int m, char **labels, int k, tree *hierarchy, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure, int center)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;
    d.w=size;
    d.h=size;
    d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure, center);
    d.y = load_labels_paths(paths, n, labels, k, hierarchy);
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movss %xmm1, -0x24(%rbp)
movss %xmm2, -0x28(%rbp)
movss %xmm3, -0x2c(%rbp)
movss %xmm4, -0x30(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x36ff4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x314c0
movq %rax, -0x8(%rbp)
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x60(%rbp), %rax
movl $0x0, 0x28(%rax)
movl 0x28(%rbp), %ecx
movl %ecx, (%rax)
movl 0x28(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0x18(%rbp), %edx
movl 0x20(%rbp), %ecx
movl 0x28(%rbp), %r8d
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
movss -0x30(%rbp), %xmm4
movl 0x30(%rbp), %r9d
callq 0x31790
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq 0x10(%rbp), %r8
callq 0x341d0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x370b1
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_writing
data load_data_writing(char **paths, int n, int m, int w, int h, int out_w, int out_h)
{
    if(m) paths = get_random_paths(paths, n, m);
    char **replace_paths = find_replace_paths(paths, n, ".png", "-label.png");
    data d = {0};
    d.shallow = 0;
    d.X = load_image_paths(paths, n, w, h);
    d.y = load_image_paths_gray(replace_paths, n, out_w, out_h);
    if(m) free(paths);
    int i;
    for(i = 0; i < n; ++i) free(replace_paths[i]);
    free(replace_paths);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x372f1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x314c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x3bd8c(%rip), %rdx     # 0x7308b
leaq 0x3d0e3(%rip), %rcx     # 0x743e9
callq 0x31550
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x58(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x316f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0x10(%rbp), %edx
movl 0x18(%rbp), %ecx
callq 0x315e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x3739b
movq -0x8(%rbp), %rdi
callq 0x3030
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x373c6
movq -0x20(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3030
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x373a2
movq -0x20(%rbp), %rdi
callq 0x3030
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_tag
data load_data_tag(char **paths, int n, int m, int k, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.w = size;
    d.h = size;
    d.shallow = 0;
    d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure, 0);
    d.y = load_tags_paths(paths, n, k);
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movss %xmm3, -0x28(%rbp)
movss %xmm4, -0x2c(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x3743a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x314c0
movq %rax, -0x8(%rbp)
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x60(%rbp), %rax
movl 0x18(%rbp), %ecx
movl %ecx, (%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
movl 0x10(%rbp), %ecx
movl 0x18(%rbp), %r8d
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
movss -0x2c(%rbp), %xmm4
xorl %r9d, %r9d
callq 0x31790
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x34290
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x374ee
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_in_thread
pthread_t load_data_in_thread(load_args args)
{
    pthread_t thread;
    struct load_args *ptr = calloc(1, sizeof(struct load_args));
    *ptr = args;
    if(pthread_create(&thread, 0, load_thread, ptr)) error("Thread creation failed");
    return thread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0xa8, %esi
callq 0x3220
movq -0x18(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xa8, %edx
callq 0x3280
movq -0x10(%rbp), %rcx
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x1028(%rip), %rdx     # 0x36520
callq 0x3330
cmpl $0x0, %eax
je 0x3755e
leaq 0x3ce79(%rip), %rdi     # 0x743d2
callq 0x4c50
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: concat_datas
data concat_datas(data *d, int n)
{
    int i;
    data out = {0};
    for(i = 0; i < n; ++i){
        data new = concat_data(d[i], out);
        free_data(out);
        out = new;
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x37896
movq -0x60(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movq %rax, -0x68(%rbp)
movups %xmm3, 0x70(%rax)
movups %xmm2, 0x60(%rax)
movups %xmm1, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x37ef0
movq -0x60(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x34400
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x40, %edx
callq 0x3280
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x377e0
movq -0x58(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data
pthread_t load_data(load_args args)
{
    pthread_t thread;
    struct load_args *ptr = calloc(1, sizeof(struct load_args));
    *ptr = args;
    if(pthread_create(&thread, 0, load_threads, ptr)) error("Thread creation failed");
    return thread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0xa8, %esi
callq 0x3220
movq -0x18(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xa8, %edx
callq 0x3280
movq -0x10(%rbp), %rcx
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x3d8(%rip), %rdx      # 0x37570
callq 0x3330
cmpl $0x0, %eax
je 0x3795e
leaq 0x3ca79(%rip), %rdi     # 0x743d2
callq 0x4c50
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: select_data
data select_data(data *orig, int *inds)
{
    data d = {0};
    d.shallow = 1;
    d.w = orig[0].w;
    d.h = orig[0].h;

    d.X.rows = orig[0].X.rows;
    d.y.rows = orig[0].X.rows;

    d.X.cols = orig[0].X.cols;
    d.y.cols = orig[0].y.cols;

    d.X.vals = calloc(orig[0].X.rows, sizeof(float *));
    d.y.vals = calloc(orig[0].y.rows, sizeof(float *));
    int i;
    for(i = 0; i < d.X.rows; ++i){
        d.X.vals[i] = orig[inds[i]].X.vals[i];
        d.y.vals[i] = orig[inds[i]].y.vals[i];
    }
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x20(%rbp), %rdi
movl $0x1, 0x28(%rdi)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x18(%rdi)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdi)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x1c(%rdi)
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rdi
movl $0x8, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rdi
movl $0x8, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq %rax, 0x20(%rdi)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x37a90
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movq 0x20(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x37a17
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: resize_data
data resize_data(data orig, int w, int h)
{
    data d = {0};
    d.shallow = 0;
    d.w = w;
    d.h = h;
    int i;
    d.X.rows = orig.X.rows;
    d.X.cols = w*h*3;
    d.X.vals = calloc(d.X.rows, sizeof(float*));

    d.y = copy_matrix(orig.y);
#pragma omp parallel for
    for(i = 0; i < orig.X.rows; ++i){
        image im = float_to_image(orig.w, orig.h, 3, orig.X.vals[i]);
        d.X.vals[i] = resize_image(im, w, h).data;
    }
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rdi
movl $0x0, 0x28(%rdi)
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
imull $0x3, %eax, %eax
movl %eax, 0xc(%rdi)
movslq 0x8(%rdi), %rdi
movl $0x8, %esi
callq 0x3220
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x393a0
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rdi)
movl $0x0, -0xc(%rbp)
movq -0x60(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x37e04
movq -0x60(%rbp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %r8
leaq -0x38(%rbp), %rdi
movl $0x3, %ecx
callq 0xfbb0
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xfc00
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rdx
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x37d8a
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: concat_matrix
matrix concat_matrix(matrix m1, matrix m2)
{
    int i, count = 0;
    matrix m;
    m.cols = m1.cols;
    m.rows = m1.rows+m2.rows;
    m.vals = calloc(m1.rows + m2.rows, sizeof(float*));
    for(i = 0; i < m1.rows; ++i){
        m.vals[count++] = m1.vals[i];
    }
    for(i = 0; i < m2.rows; ++i){
        m.vals[count++] = m2.vals[i];
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x20(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x20(%rbp), %eax
addl -0x30(%rbp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x37ea1
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x38(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x37e6c
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x37edd
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x38(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x37ea8
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: concat_data
data concat_data(data d1, data d2)
{
    data d = {0};
    d.shallow = 1;
    d.X = concat_matrix(d1.X, d2.X);
    d.y = concat_matrix(d1.y, d2.y);
    d.w = d1.w;
    d.h = d1.h;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdi
movl $0x1, 0x28(%rdi)
movq 0x8(%rcx), %rdi
movq 0x10(%rcx), %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0x37e20
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x40(%rbp), %rax
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, 0x8(%rdi)
movq -0x8(%rbp), %rdx
movq %rdx, 0x10(%rdi)
movq 0x18(%rcx), %rdi
movq 0x20(%rcx), %rsi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
callq 0x37e20
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rax
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movq %rdx, 0x18(%rdi)
movq -0x18(%rbp), %rdx
movq %rdx, 0x20(%rdi)
movl (%rcx), %edx
movl %edx, (%rdi)
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_categorical_data_csv
data load_categorical_data_csv(char *filename, int target, int k)
{
    data d = {0};
    d.shallow = 0;
    matrix X = csv_to_matrix(filename);
    float *truth_1d = pop_column(&X, target);
    float **truth = one_hot_encode(truth_1d, X.rows, k);
    matrix y;
    y.rows = X.rows;
    y.cols = k;
    y.vals = truth;
    d.X = X;
    d.y = y;
    free(truth_1d);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x50(%rbp), %rdi
movl $0x0, 0x28(%rdi)
movq -0x8(%rbp), %rdi
callq 0x39660
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x39580
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5ff0
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x40(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x38(%rbp), %rax
movq %rax, 0x20(%rdi)
movq -0x28(%rbp), %rdi
callq 0x3030
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_cifar10_data
data load_cifar10_data(char *filename)
{
    data d = {0};
    d.shallow = 0;
    long i,j;
    matrix X = make_matrix(10000, 3072);
    matrix y = make_matrix(10000, 10);
    d.X = X;
    d.y = y;

    FILE *fp = fopen(filename, "rb");
    if(!fp) file_error(filename);
    for(i = 0; i < 10000; ++i){
        unsigned char bytes[3073];
        fread(bytes, 1, 3073, fp);
        int class = bytes[0];
        y.vals[i][class] = 1;
        for(j = 0; j < X.cols; ++j){
            X.vals[i][j] = (double)bytes[j+1];
        }
    }
    scale_data_rows(d, 1./255);
    //normalize_data_rows(d);
    fclose(fp);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xcb0, %rsp            # imm = 0xCB0
movq %rdi, -0xc60(%rbp)
movq %rdi, %rax
movq %rax, -0xc68(%rbp)
movq %rsi, -0x8(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0xc60(%rbp), %rdi
movl $0x0, 0x28(%rdi)
movl $0x2710, %edi           # imm = 0x2710
movl $0xc00, %esi            # imm = 0xC00
callq 0x39450
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x2710, %edi           # imm = 0x2710
movl $0xa, %esi
callq 0x39450
movq -0xc60(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x38(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x30(%rbp), %rax
movq %rax, 0x20(%rdi)
movq -0x8(%rbp), %rdi
leaq 0x38fa2(%rip), %rsi     # 0x710bc
callq 0x3360
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x38133
movq -0x8(%rbp), %rdi
callq 0x4110
movq $0x0, -0x10(%rbp)
cmpq $0x2710, -0x10(%rbp)    # imm = 0x2710
jge 0x381f3
leaq -0xc50(%rbp), %rdi
movq -0x40(%rbp), %rcx
movl $0x1, %esi
movl $0xc01, %edx            # imm = 0xC01
callq 0x30a0
movzbl -0xc50(%rbp), %eax
movl %eax, -0xc54(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc54(%rbp), %rcx
movss 0x38e81(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
jge 0x381e0
movq -0x18(%rbp), %rax
leaq -0xc50(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
cvtsi2sd %eax, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x38198
jmp 0x381e2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3813b
movq -0xc60(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movss 0x3c0fd(%rip), %xmm0    # 0x74320
callq 0x38250
movq -0x40(%rbp), %rdi
callq 0x3100
movq -0xc68(%rbp), %rax
addq $0xcb0, %rsp            # imm = 0xCB0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_random_batch
void get_random_batch(data d, int n, float *X, float *y)
{
    int j;
    for(j = 0; j < n; ++j){
        int index = rand()%d.X.rows;
        memcpy(X+j*d.X.cols, d.X.vals[index], d.X.cols*sizeof(float));
        memcpy(y+j*d.y.cols, d.y.vals[index], d.y.cols*sizeof(float));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x38360
callq 0x34b0
movq -0x28(%rbp), %rcx
cltd
idivl 0x8(%rcx)
movq -0x28(%rbp), %rax
movl %edx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %ecx
imull 0xc(%rax), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movslq 0xc(%rax), %rdx
shlq $0x2, %rdx
callq 0x3280
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %ecx
imull 0x1c(%rax), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x20(%rax), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movslq 0x1c(%rax), %rdx
shlq $0x2, %rdx
callq 0x3280
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x382d2
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_next_batch
void get_next_batch(data d, int n, int offset, float *X, float *y)
{
    int j;
    for(j = 0; j < n; ++j){
        int index = offset + j;
        memcpy(X+j*d.X.cols, d.X.vals[index], d.X.cols*sizeof(float));
        if(y) memcpy(y+j*d.y.cols, d.y.vals[index], d.y.cols*sizeof(float));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x38425
movq -0x28(%rbp), %rax
movl -0x8(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %ecx
imull 0xc(%rax), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movslq 0xc(%rax), %rdx
shlq $0x2, %rdx
callq 0x3280
cmpq $0x0, -0x18(%rbp)
je 0x38415
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %ecx
imull 0x1c(%rax), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x20(%rax), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movslq 0x1c(%rax), %rdx
shlq $0x2, %rdx
callq 0x3280
jmp 0x38417
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x38395
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: smooth_data
void smooth_data(data d)
{
    int i, j;
    float scale = 1. / d.y.cols;
    float eps = .1;
    for(i = 0; i < d.y.rows; ++i){
        for(j = 0; j < d.y.cols; ++j){
            d.y.vals[i][j] = eps * scale + (1-eps) * d.y.vals[i][j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cvtsi2sdl 0x1c(%rax), %xmm1
movsd 0x38c17(%rip), %xmm0    # 0x71060
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss 0x38dd6(%rip), %xmm0    # 0x71234
movss %xmm0, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x384f1
movl $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x384e1
movq -0x18(%rbp), %rax
movss -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm2
movss 0x38b6d(%rip), %xmm1    # 0x7100c
subss -0x10(%rbp), %xmm1
movq 0x20(%rax), %rcx
movslq -0x4(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x8(%rbp), %rdx
mulss (%rcx,%rdx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x20(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3847d
jmp 0x384e3
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3846a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: randomize_data
void randomize_data(data d)
{
    int i;
    for(i = d.X.rows-1; i > 0; --i){
        int index = rand()%i;
        float *swap = d.X.vals[index];
        d.X.vals[index] = d.X.vals[i];
        d.X.vals[i] = swap;

        swap = d.y.vals[index];
        d.y.vals[index] = d.y.vals[i];
        d.y.vals[i] = swap;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x38a81
callq 0x34b0
cltd
idivl -0x4(%rbp)
movq -0x18(%rbp), %rax
movl %edx, -0x8(%rbp)
movq 0x10(%rax), %rcx
movslq -0x8(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rcx
movslq -0x4(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x10(%rax), %rcx
movslq -0x8(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rcx
movslq -0x4(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x20(%rax), %rcx
movslq -0x8(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x10(%rbp)
movq 0x20(%rax), %rcx
movslq -0x4(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x20(%rax), %rcx
movslq -0x8(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x10(%rbp), %rdx
movq 0x20(%rax), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x389e9
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: copy_data
data copy_data(data d)
{
    data c = {0};
    c.w = d.w;
    c.h = d.h;
    c.shallow = 0;
    c.num_boxes = d.num_boxes;
    c.boxes = d.boxes;
    c.X = copy_matrix(d.X);
    c.y = copy_matrix(d.y);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movl (%rax), %ecx
movl %ecx, (%rdi)
movl 0x4(%rax), %ecx
movl %ecx, 0x4(%rdi)
movl $0x0, 0x28(%rdi)
movq 0x30(%rax), %rcx
movq %rcx, 0x30(%rdi)
movq 0x38(%rax), %rcx
movq %rcx, 0x38(%rdi)
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x393a0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x393a0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_data_part
data get_data_part(data d, int part, int total)
{
    data p = {0};
    p.shallow = 1;
    p.X.rows = d.X.rows * (part + 1) / total - d.X.rows * part / total;
    p.y.rows = d.y.rows * (part + 1) / total - d.y.rows * part / total;
    p.X.cols = d.X.cols;
    p.y.cols = d.y.cols;
    p.X.vals = d.X.vals + d.X.rows * part / total;
    p.y.vals = d.y.vals + d.y.rows * part / total;
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x1, 0x28(%rdi)
movl 0x8(%rax), %eax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
cltd
idivl -0x8(%rbp)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
imull -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, %edx
movq -0x18(%rbp), %rax
subl %edx, %ecx
movl %ecx, 0x8(%rdi)
movl 0x18(%rax), %eax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
cltd
idivl -0x8(%rbp)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
imull -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, %edx
movq -0x18(%rbp), %rax
subl %edx, %ecx
movl %ecx, 0x18(%rdi)
movl 0xc(%rax), %ecx
movl %ecx, 0xc(%rdi)
movl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rdi)
movq 0x10(%rax), %rcx
movl 0x8(%rax), %eax
imull -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rdi)
movq 0x20(%rax), %rcx
movl 0x18(%rax), %eax
imull -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_random_data
data get_random_data(data d, int num)
{
    data r = {0};
    r.shallow = 1;

    r.X.rows = num;
    r.y.rows = num;

    r.X.cols = d.X.cols;
    r.y.cols = d.y.cols;

    r.X.vals = calloc(num, sizeof(float *));
    r.y.vals = calloc(num, sizeof(float *));

    int i;
    for(i = 0; i < num; ++i){
        int index = rand()%d.X.rows;
        r.X.vals[i] = d.X.vals[index];
        r.y.vals[i] = d.y.vals[index];
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl %esi, -0x4(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movl $0x1, 0x28(%rdi)
movl -0x4(%rbp), %ecx
movl %ecx, 0x8(%rdi)
movl -0x4(%rbp), %ecx
movl %ecx, 0x18(%rdi)
movl 0xc(%rax), %ecx
movl %ecx, 0xc(%rdi)
movl 0x1c(%rax), %eax
movl %eax, 0x1c(%rdi)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, 0x20(%rdi)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x38dcb
callq 0x34b0
movq -0x20(%rbp), %rcx
cltd
idivl 0x8(%rcx)
movq -0x18(%rbp), %rax
movl %edx, -0xc(%rbp)
movq 0x10(%rcx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdi
movq 0x10(%rax), %rdx
movslq -0x8(%rbp), %rsi
movq %rdi, (%rdx,%rsi,8)
movq 0x20(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x20(%rax), %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x38d74
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: matrix_topk_accuracy
float matrix_topk_accuracy(matrix truth, matrix guess, int k)
{
    int *indexes = calloc(k, sizeof(int));
    int n = truth.cols;
    int i,j;
    int correct = 0;
    for(i = 0; i < truth.rows; ++i){
        top_k(guess.vals[i], n, k, indexes);
        for(j = 0; j < k; ++j){
            int class = indexes[j];
            if(truth.vals[i][class]){
                ++correct;
                break;
            }
        }
    }
    free(indexes);
    return (float)correct/truth.rows;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3914f
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x34(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0x4b70
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x3913f
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x44(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x39127
jp 0x39127
jmp 0x39132
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x3913f
jmp 0x39134
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x390f0
jmp 0x39141
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x390c2
movq -0x30(%rbp), %rdi
callq 0x3030
cvtsi2ssl -0x40(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: scale_matrix
void scale_matrix(matrix m, float scale)
{
    int i,j;
    for(i = 0; i < m.rows; ++i){
        for(j = 0; j < m.cols; ++j){
            m.vals[i][j] *= scale;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x391d6
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x391c9
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39197
jmp 0x391cb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x39188
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: resize_matrix
matrix resize_matrix(matrix m, int size)
{
    int i;
    if (m.rows == size) return m;
    if (m.rows < size) {
        m.vals = realloc(m.vals, size*sizeof(float*));
        for (i = m.rows; i < size; ++i) {
            m.vals[i] = calloc(m.cols, sizeof(float));
        }
    } else if (m.rows > size) {
        for (i = size; i < m.rows; ++i) {
            free(m.vals[i]);
        }
        m.vals = realloc(m.vals, size*sizeof(float*));
    }
    m.rows = size;
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x39210
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x392c4
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x39265
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3310
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x39263
movslq -0x1c(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x39233
jmp 0x392ae
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x392ac
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x39297
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3030
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x39273
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3310
movq %rax, -0x18(%rbp)
jmp 0x392ae
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: matrix_add_matrix
void matrix_add_matrix(matrix from, matrix to)
{
    assert(from.rows == to.rows && from.cols == to.cols);
    int i,j;
    for(i = 0; i < from.rows; ++i){
        for(j = 0; j < from.cols; ++j){
            to.vals[i][j] += from.vals[i][j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x3930a
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x3930a
jmp 0x39329
leaq 0x3b115(%rip), %rdi     # 0x74426
leaq 0x3b13b(%rip), %rsi     # 0x74453
movl $0x44, %edx
leaq 0x3b138(%rip), %rcx     # 0x7445c
callq 0x3180
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3938e
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x39381
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3933f
jmp 0x39383
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x39330
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: copy_matrix
matrix copy_matrix(matrix m)
{
    matrix c = {0};
    c.rows = m.rows;
    c.cols = m.cols;
    c.vals = calloc(c.rows, sizeof(float *));
    int i;
    for(i = 0; i < c.rows; ++i){
        c.vals[i] = calloc(c.cols, sizeof(float));
        copy_cpu(c.cols, m.vals[i], 1, c.vals[i], 1);
    }
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3190
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3943e
movslq -0xc(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f960
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x393e5
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: make_matrix
matrix make_matrix(int rows, int cols)
{
    int i;
    matrix m;
    m.rows = rows;
    m.cols = cols;
    m.vals = calloc(m.rows, sizeof(float *));
    for(i = 0; i < m.rows; ++i){
        m.vals[i] = calloc(m.cols, sizeof(float));
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x394b3
movslq -0xc(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39483
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: hold_out_matrix
matrix hold_out_matrix(matrix *m, int n)
{
    int i;
    matrix h;
    h.rows = n;
    h.cols = m->cols;
    h.vals = calloc(h.rows, sizeof(float *));
    for(i = 0; i < n; ++i){
        int index = rand()%m->rows;
        h.vals[i] = m->vals[index];
        m->vals[index] = m->vals[--(m->rows)];
    }
    return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x39570
callq 0x34b0
movq -0x18(%rbp), %rcx
cltd
idivl (%rcx)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x39508
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: pop_column
float *pop_column(matrix *m, int c)
{
    float *col = calloc(m->rows, sizeof(float));
    int i, j;
    for(i = 0; i < m->rows; ++i){
        col[i] = m->vals[i][c];
        for(j = c; j < m->cols-1; ++j){
            m->vals[i][j] = m->vals[i][j+1];
        }
    }
    --m->cols;
    return col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x39649
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x39639
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x395e6
jmp 0x3963b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x395ab
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq