LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/crop_layer.c
// Function: get_crop_image
image get_crop_image(crop_layer l)
{
    int h = l.out_h;
    int w = l.out_w;
    int c = l.out_c;
    return float_to_image(w,h,c,l.output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movl 0x78(%rax), %ecx
movl %ecx, -0x4(%rbp)
movl 0x7c(%rax), %ecx
movl %ecx, -0x8(%rbp)
movl 0x80(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
movl -0xc(%rbp), %ecx
movq 0x268(%rax), %r8
callq 0xfbb0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/crop_layer.c
// Function: make_crop_layer
crop_layer make_crop_layer(int batch, int h, int w, int c, int crop_height, int crop_width, int flip, float angle, float saturation, float exposure)
{
    fprintf(stderr, "Crop Layer: %d x %d -> %d x %d x %d image\n", h,w,crop_height,crop_width,c);
    crop_layer l = {0};
    l.type = CROP;
    l.batch = batch;
    l.h = h;
    l.w = w;
    l.c = c;
    l.scale = (float)crop_height / h;
    l.flip = flip;
    l.angle = angle;
    l.saturation = saturation;
    l.exposure = exposure;
    l.out_w = crop_width;
    l.out_h = crop_height;
    l.out_c = c;
    l.inputs = l.w * l.h * l.c;
    l.outputs = l.out_w * l.out_h * l.out_c;
    l.output = calloc(l.outputs*batch, sizeof(float));
    l.forward = forward_crop_layer;
    l.backward = backward_crop_layer;

    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movl %r9d, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movss %xmm1, -0x1c(%rbp)
movss %xmm2, -0x20(%rbp)
movq 0x52ccb(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl 0x10(%rbp), %r9d
movl -0x10(%rbp), %eax
leaq 0x43eac(%rip), %rsi     # 0x741f4
movl %eax, (%rsp)
movb $0x0, %al
callq 0x3240
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x30(%rbp), %rdi
movl $0x7, (%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x6c(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x70(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x74(%rdi)
cvtsi2ssl -0x14(%rbp), %xmm0
cvtsi2ssl -0x8(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x194(%rdi)
movl 0x18(%rbp), %eax
movl %eax, 0xb0(%rdi)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0xd4(%rdi)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0xdc(%rdi)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0xe0(%rdi)
movl 0x10(%rbp), %eax
movl %eax, 0x7c(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x78(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x80(%rdi)
movl 0x70(%rdi), %eax
imull 0x6c(%rdi), %eax
imull 0x74(%rdi), %eax
movl %eax, 0x54(%rdi)
movl 0x7c(%rdi), %eax
imull 0x78(%rdi), %eax
imull 0x80(%rdi), %eax
movl %eax, 0x58(%rdi)
movl 0x58(%rdi), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x268(%rdi)
leaq 0x15(%rip), %rcx        # 0x30440
movq %rcx, 0x10(%rdi)
leaq -0x166(%rip), %rcx      # 0x302d0
movq %rcx, 0x18(%rdi)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/crop_layer.c
// Function: resize_crop_layer
void resize_crop_layer(layer *l, int w, int h)
{
    l->w = w;
    l->h = h;

    l->out_w =  l->scale*w;
    l->out_h =  l->scale*h;

    l->inputs = l->w * l->h * l->c;
    l->outputs = l->out_h * l->out_w * l->out_c;

    l->output = realloc(l->output, l->batch*l->outputs*sizeof(float));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x70(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x8(%rbp), %rax
movss 0x194(%rax), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movq -0x8(%rbp), %rax
movss 0x194(%rax), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
movl 0x70(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x6c(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x74(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movl 0x78(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x7c(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x80(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x58(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x268(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/dropout_layer.c
// Function: make_dropout_layer
dropout_layer make_dropout_layer(int batch, int inputs, float probability)
{
    dropout_layer l = {0};
    l.type = DROPOUT;
    l.probability = probability;
    l.inputs = inputs;
    l.outputs = inputs;
    l.batch = batch;
    l.rand = calloc(inputs*batch, sizeof(float));
    l.scale = 1./(1.-probability);
    l.forward = forward_dropout_layer;
    l.backward = backward_dropout_layer;
    fprintf(stderr, "dropout       p = %.2f               %4d  ->  %4d\n", probability, inputs, inputs);
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x20(%rbp), %rdi
movl $0x6, (%rdi)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x190(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x54(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x58(%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq %rax, 0x1d0(%rdi)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x4087d(%rip), %xmm1    # 0x71060
subsd %xmm0, %xmm1
movsd 0x40871(%rip), %xmm0    # 0x71060
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x194(%rdi)
leaq 0x4a(%rip), %rax        # 0x30850
movq %rax, 0x10(%rdi)
leaq 0x11f(%rip), %rax       # 0x30930
movq %rax, 0x18(%rdi)
movq 0x527dc(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movl -0x8(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0x439ea(%rip), %rsi     # 0x7421f
movb $0x1, %al
callq 0x3240
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/dropout_layer.c
// Function: forward_dropout_layer
void forward_dropout_layer(dropout_layer l, network net)
{
    int i;
    if (!net.train) return;
    for(i = 0; i < l.batch * l.inputs; ++i){
        float r = rand_uniform(0, 1);
        l.rand[i] = r;
        if(r < l.probability) net.input[i] = 0;
        else net.input[i] *= l.scale;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x0, 0xf8(%rax)
jne 0x30879
jmp 0x30924
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rdx
movl -0x4(%rbp), %eax
movl 0x48(%rdx), %ecx
imull 0x54(%rdx), %ecx
cmpl %ecx, %eax
jge 0x30924
xorps %xmm0, %xmm0
movss 0x4076b(%rip), %xmm1    # 0x7100c
callq 0x5b30
movq -0x10(%rbp), %rax
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
movq 0x1d0(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss %xmm0, (%rcx,%rdx,4)
movss -0x8(%rbp), %xmm1
movss 0x190(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x308ef
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rax
movslq -0x4(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x30914
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movss 0x194(%rcx), %xmm0
movq 0xd8(%rax), %rax
movslq -0x4(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x30916
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x30880
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/dropout_layer.c
// Function: backward_dropout_layer
void backward_dropout_layer(dropout_layer l, network net)
{
    int i;
    if(!net.delta) return;
    for(i = 0; i < l.batch * l.inputs; ++i){
        float r = l.rand[i];
        if(r < l.probability) net.delta[i] = 0;
        else net.delta[i] *= l.scale;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0xe8(%rax)
jne 0x30956
jmp 0x309e8
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rdx
movl -0x4(%rbp), %eax
movl 0x48(%rdx), %ecx
imull 0x54(%rdx), %ecx
cmpl %ecx, %eax
jge 0x309e8
movq -0x10(%rbp), %rax
movq 0x1d0(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm1
movss 0x190(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x309b3
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0x4(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x309d8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movss 0x194(%rcx), %xmm0
movq 0xe8(%rax), %rax
movslq -0x4(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x309da
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3095d
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/maxpool_layer.c
// Function: get_maxpool_delta
image get_maxpool_delta(maxpool_layer l)
{
    int h = l.out_h;
    int w = l.out_w;
    int c = l.c;
    return float_to_image(w,h,c,l.delta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movl 0x78(%rax), %ecx
movl %ecx, -0x4(%rbp)
movl 0x7c(%rax), %ecx
movl %ecx, -0x8(%rbp)
movl 0x74(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
movl -0xc(%rbp), %ecx
movq 0x260(%rax), %r8
callq 0xfbb0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/maxpool_layer.c
// Function: backward_maxpool_layer
void backward_maxpool_layer(const maxpool_layer l, network net)
{
    int i;
    int h = l.out_h;
    int w = l.out_w;
    int c = l.c;
    for(i = 0; i < h*w*c*l.batch; ++i){
        int index = l.indexes[i];
        net.delta[index] += l.delta[i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x78(%rax), %ecx
movl %ecx, -0x8(%rbp)
movl 0x7c(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x74(%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x20(%rbp), %rdx
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
imull -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
imull 0x48(%rdx), %ecx
cmpl %ecx, %eax
jge 0x30fd3
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x1a0(%rcx), %rdx
movslq -0x4(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
movl %edx, -0x14(%rbp)
movq 0x260(%rcx), %rcx
movslq -0x4(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movq 0xe8(%rax), %rax
movslq -0x14(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x30f70
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/maxpool_layer.c
// Function: resize_maxpool_layer
void resize_maxpool_layer(maxpool_layer *l, int w, int h)
{
    l->h = h;
    l->w = w;
    l->inputs = h*w*l->c;

    l->out_w = (w + l->pad - l->size)/l->stride + 1;
    l->out_h = (h + l->pad - l->size)/l->stride + 1;
    l->outputs = l->out_w * l->out_h * l->c;
    int output_size = l->outputs * l->batch;

    l->indexes = realloc(l->indexes, output_size * sizeof(int));
    l->output = realloc(l->output, output_size * sizeof(float));
    l->delta = realloc(l->delta, output_size * sizeof(float));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x70(%rax)
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x74(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0xa8(%rcx), %eax
movq -0x8(%rbp), %rcx
subl 0x90(%rcx), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x98(%rcx)
movl %eax, %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0xa8(%rcx), %eax
movq -0x8(%rbp), %rcx
subl 0x90(%rcx), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x98(%rcx)
movl %eax, %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x78(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x74(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1a0(%rax)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x268(%rax)
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
movslq -0x14(%rbp), %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x260(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/softmax_layer.c
// Function: make_softmax_layer
softmax_layer make_softmax_layer(int batch, int inputs, int groups)
{
    assert(inputs%groups == 0);
    fprintf(stderr, "softmax                                        %4d\n",  inputs);
    softmax_layer l = {0};
    l.type = SOFTMAX;
    l.batch = batch;
    l.groups = groups;
    l.inputs = inputs;
    l.outputs = inputs;
    l.loss = calloc(inputs*batch, sizeof(float));
    l.output = calloc(inputs*batch, sizeof(float));
    l.delta = calloc(inputs*batch, sizeof(float));
    l.cost = calloc(1, sizeof(float));

    l.forward = forward_softmax_layer;
    l.backward = backward_softmax_layer;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl -0x8(%rbp), %eax
cltd
idivl -0xc(%rbp)
cmpl $0x0, %edx
jne 0x31147
jmp 0x31166
leaq 0x43142(%rip), %rdi     # 0x74290
leaq 0x4314e(%rip), %rsi     # 0x742a3
movl $0xd, %edx
leaq 0x43152(%rip), %rcx     # 0x742b3
callq 0x3180
movq 0x51e8b(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x43169(%rip), %rsi     # 0x742e3
movb $0x0, %al
callq 0x3240
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
movl -0x4(%rbp), %ecx
movl %ecx, 0x48(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8c(%rax)
movl -0x8(%rbp), %ecx
movl %ecx, 0x54(%rax)
movl -0x8(%rbp), %ecx
movl %ecx, 0x58(%rax)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x270(%rax)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x268(%rax)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x260(%rax)
movl $0x1, %edi
movl $0x4, %esi
callq 0x3220
movq -0x20(%rbp), %rcx
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq %rdx, 0x1d8(%rcx)
leaq 0x1c(%rip), %rdx        # 0x31260
movq %rdx, 0x10(%rcx)
leaq 0x1c1(%rip), %rdx       # 0x31410
movq %rdx, 0x18(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/softmax_layer.c
// Function: forward_softmax_layer
void forward_softmax_layer(const softmax_layer l, network net)
{
    if(l.softmax_tree){
        int i;
        int count = 0;
        for (i = 0; i < l.softmax_tree->groups; ++i) {
            int group_size = l.softmax_tree->group_size[i];
            softmax_cpu(net.input + count, group_size, l.batch, l.inputs, 1, 0, 1, l.temperature, l.output + count);
            count += group_size;
        }
    } else {
        softmax_cpu(net.input, l.inputs/l.groups, l.batch, l.inputs, l.groups, l.inputs/l.groups, 1, l.temperature, l.output);
    }

    if(net.truth && !l.noloss){
        softmax_x_ent_cpu(l.batch*l.inputs, l.output, net.truth, l.delta, l.loss);
        l.cost[0] = sum_array(l.loss, l.batch*l.inputs);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x490(%rax)
je 0x31333
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
movq 0x490(%rcx), %rcx
cmpl 0x30(%rcx), %eax
jge 0x31331
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x490(%rax), %rdx
movq 0x38(%rdx), %rdx
movslq -0x4(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
movl %edx, -0xc(%rbp)
movq 0xd8(%rcx), %rdi
movslq -0x8(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movl -0xc(%rbp), %esi
movl 0x48(%rax), %edx
movl 0x54(%rax), %ecx
movss 0x18c(%rax), %xmm0
movq 0x268(%rax), %rax
movslq -0x8(%rbp), %r8
shlq $0x2, %r8
addq %r8, %rax
movl $0x1, %r8d
xorl %r9d, %r9d
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x30010
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x31297
jmp 0x31398
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rdi
movl 0x54(%r9), %eax
cltd
idivl 0x8c(%r9)
movl %eax, %esi
movl 0x48(%r9), %eax
movl %eax, -0x24(%rbp)
movl 0x54(%r9), %ecx
movl 0x8c(%r9), %r8d
movl 0x54(%r9), %eax
cltd
idivl 0x8c(%r9)
movl -0x24(%rbp), %edx
movl %eax, %r9d
movq -0x18(%rbp), %rax
movss 0x18c(%rax), %xmm0
movq 0x268(%rax), %rax
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x30010
movq -0x20(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x31409
movq -0x18(%rbp), %rax
cmpl $0x0, 0xf4(%rax)
jne 0x31409
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x48(%rax), %edi
imull 0x54(%rax), %edi
movq 0x268(%rax), %rsi
movq 0xe0(%rcx), %rdx
movq 0x260(%rax), %rcx
movq 0x270(%rax), %r8
callq 0x2fbd0
movq -0x18(%rbp), %rax
movq 0x270(%rax), %rdi
movl 0x48(%rax), %esi
imull 0x54(%rax), %esi
callq 0x5480
movq -0x18(%rbp), %rax
movq 0x1d8(%rax), %rax
movss %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_paths
list *get_paths(char *filename)
{
    char *path;
    FILE *file = fopen(filename, "r");
    if(!file) file_error(filename);
    list *lines = make_list();
    while((path=fgetl(file))){
        list_insert(lines, path);
    }
    fclose(file);
    return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x45106(%rip), %rsi     # 0x7656d
callq 0x3360
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x31480
movq -0x8(%rbp), %rdi
callq 0x4110
movb $0x0, %al
callq 0x8df0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4140
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x314ad
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8ed0
jmp 0x3148b
movq -0x18(%rbp), %rdi
callq 0x3100
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_random_paths
char **get_random_paths(char **paths, int n, int m)
{
    char **random_paths = calloc(n, sizeof(char*));
    int i;
    pthread_mutex_lock(&mutex);
    for(i = 0; i < n; ++i){
        int index = rand()%m;
        random_paths[i] = paths[index];
        //if(i == 0) printf("%s\n", paths[index]);
    }
    pthread_mutex_unlock(&mutex);
    return random_paths;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x18(%rbp)
leaq 0x5297d(%rip), %rdi     # 0x83e68
callq 0x3490
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3152e
callq 0x34b0
cltd
idivl -0x10(%rbp)
movl %edx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x314f7
leaq 0x52933(%rip), %rdi     # 0x83e68
callq 0x32c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: find_replace_paths
char **find_replace_paths(char **paths, int n, char *find, char *replace)
{
    char **replace_paths = calloc(n, sizeof(char*));
    int i;
    for(i = 0; i < n; ++i){
        char replaced[4096];
        find_replace(paths[i], find, replace, replaced);
        replace_paths[i] = copy_string(replaced);
    }
    return replace_paths;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x315d1
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x1030(%rbp), %rcx
callq 0x4a50
leaq -0x1030(%rbp), %rdi
callq 0x48d0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x31583
movq -0x28(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_image_paths_gray
matrix load_image_paths_gray(char **paths, int n, int w, int h)
{
    int i;
    matrix X;
    X.rows = n;
    X.vals = calloc(X.rows, sizeof(float*));
    X.cols = 0;

    for(i = 0; i < n; ++i){
        image im = load_image(paths[i], w, h, 3);

        image gray = grayscale_image(im);
        free_image(im);
        im = gray;

        X.vals[i] = im.data;
        X.cols = im.h*im.w*im.c;
    }
    return X;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x316d4
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
leaq -0x40(%rbp), %rdi
movl $0x3, %r8d
callq 0x12a60
leaq -0x58(%rbp), %rdi
leaq -0x40(%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 0x140c0
leaq -0x40(%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 0xedb0
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
imull -0x40(%rbp), %eax
imull -0x38(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3161b
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_image_paths
matrix load_image_paths(char **paths, int n, int w, int h)
{
    int i;
    matrix X;
    X.rows = n;
    X.vals = calloc(X.rows, sizeof(float*));
    X.cols = 0;

    for(i = 0; i < n; ++i){
        image im = load_image_color(paths[i], w, h);
        X.vals[i] = im.data;
        X.cols = im.h*im.w*im.c;
    }
    return X;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x31777
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
leaq -0x40(%rbp), %rdi
callq 0xf510
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
imull -0x40(%rbp), %eax
imull -0x38(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3172b
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
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: randomize_boxes
void randomize_boxes(box_label *b, int n)
{
    int i;
    for(i = 0; i < n; ++i){
        box_label swap = b[i];
        int index = rand()%n;
        b[i] = b[index];
        b[index] = swap;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x31c4a
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
imulq $0x24, %rax, %rax
addq %rax, %rsi
leaq -0x34(%rbp), %rdi
movl $0x24, %edx
callq 0x3280
callq 0x34b0
cltd
idivl -0xc(%rbp)
movl %edx, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
imulq $0x24, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x38(%rbp), %rax
imulq $0x24, %rax, %rax
addq %rax, %rsi
movl $0x24, %edx
callq 0x3280
movq -0x8(%rbp), %rdi
movslq -0x38(%rbp), %rax
imulq $0x24, %rax, %rax
addq %rax, %rdi
leaq -0x34(%rbp), %rsi
movl $0x24, %edx
callq 0x3280
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x31bc6
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_rle
void load_rle(image im, int *rle, int n)
{
    int count = 0;
    int curr = 0;
    int i,j;
    for(i = 0; i < n; ++i){
        for(j = 0; j < rle[i]; ++j){
            im.data[count++] = curr;
        }
        curr = 1 - curr;
    }
    for(; count < im.h*im.w*im.c; ++count){
        im.data[count] = curr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x32978
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x32962
movq -0x28(%rbp), %rax
cvtsi2ssl -0x14(%rbp), %xmm0
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x32927
movl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32918
jmp 0x3297a
movq -0x28(%rbp), %rdx
movl -0x10(%rbp), %eax
movl 0x4(%rdx), %ecx
imull (%rdx), %ecx
imull 0x8(%rdx), %ecx
cmpl %ecx, %eax
jge 0x329b0
movq -0x28(%rbp), %rax
cvtsi2ssl -0x14(%rbp), %xmm0
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3297a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: exclusive_image
void exclusive_image(image src)
{
    int k, j, i;
    int s = src.w*src.h;
    for(k = 0; k < src.c-1; ++k){
        for(i = 0; i < s; ++i){
            if (src.data[k*s + i]){
                for(j = k+1; j < src.c; ++j){
                    src.data[j*s + i] = 0;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl (%rcx), %eax
imull 0x4(%rcx), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x32b02
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x32af2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x4(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32aa6
jp 0x32aa6
jmp 0x32ae5
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x32ae3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x8(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x32aaf
jmp 0x32ae5
jmp 0x32ae7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x32a78
jmp 0x32af4
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x32a5c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: bound_image
box bound_image(image im)
{
    int x,y;
    int minx = im.w;
    int miny = im.h;
    int maxx = 0;
    int maxy = 0;
    for(y = 0; y < im.h; ++y){
        for(x = 0; x < im.w; ++x){
            if(im.data[y*im.w + x]){
                minx = (x < minx) ? x : minx;
                miny = (y < miny) ? y : miny;
                maxx = (x > maxx) ? x : maxx;
                maxy = (y > maxy) ? y : maxy;
            }
        }
    }
    box b = {minx, miny, maxx-minx + 1, maxy-miny + 1};
    //printf("%f %f %f %f\n", b.x, b.y, b.w, b.h);
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %ecx
movl %ecx, -0x1c(%rbp)
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x32c17
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x32c07
movq -0x30(%rbp), %rdx
movq 0x10(%rdx), %rax
movl -0x18(%rbp), %ecx
imull (%rdx), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32b87
jp 0x32b87
jmp 0x32bf7
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x32b97
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x32b9d
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x32bb3
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x32bb9
movl -0x20(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x32bcf
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x32bd5
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x32beb
movl -0x18(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x32bf1
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x32bf9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x32b53
jmp 0x32c09
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32b3c
cvtsi2ssl -0x1c(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
cvtsi2ssl -0x20(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl %ecx, %eax
incl %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x8(%rbp)
movl -0x28(%rbp), %eax
movl -0x20(%rbp), %ecx
subl %ecx, %eax
incl %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: print_letters
void print_letters(float *pred, int n)
{
    int i;
    for(i = 0; i < n; ++i){
        int index = max_index(pred+i*NUMCHARS, NUMCHARS);
        printf("%c", int_to_alphanum(index));
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x339f0
movq -0x8(%rbp), %rdi
imull $0x25, -0x10(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
movl $0x25, %esi
callq 0x5c30
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x4960
movsbl %al, %esi
leaq 0x40994(%rip), %rdi     # 0x74372
movb $0x0, %al
callq 0x3130
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x339a6
leaq 0x423b7(%rip), %rdi     # 0x75dae
movb $0x0, %al
callq 0x3130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: fill_truth_captcha
void fill_truth_captcha(char *path, int n, float *truth)
{
    char *begin = strrchr(path, '/');
    ++begin;
    int i;
    for(i = 0; i < strlen(begin) && i < n && begin[i] != '.'; ++i){
        int index = alphanum_to_int(begin[i]);
        if(index > 35) printf("Bad %c\n", begin[i]);
        truth[i*NUMCHARS+index] = 1;
    }
    for(;i < n; ++i){
        truth[i*NUMCHARS + NUMCHARS-1] = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x3160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3110
movq -0x38(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jae 0x33a8c
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x33a8c
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x33a95
jmp 0x33af2
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x4930
movl %eax, -0x28(%rbp)
cmpl $0x23, -0x28(%rbp)
jle 0x33ac9
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x408b3(%rip), %rdi     # 0x74375
movb $0x0, %al
callq 0x3130
movq -0x18(%rbp), %rax
imull $0x25, -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss 0x3d52d(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33a48
jmp 0x33af4
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x33b25
movq -0x18(%rbp), %rax
imull $0x25, -0x24(%rbp), %ecx
addl $0x25, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movss 0x3d4f7(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33af4
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_captcha
data load_data_captcha(char **paths, int n, int m, 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 = make_matrix(n, k*NUMCHARS);
    int i;
    for(i = 0; i < n; ++i){
        fill_truth_captcha(paths[i], k, d.y.vals[i]);
    }
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
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 0x33b6e
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 -0x18(%rbp), %edx
movl 0x10(%rbp), %ecx
callq 0x316f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %edi
imull $0x25, -0x14(%rbp), %esi
callq 0x39450
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x33c23
movq -0x50(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movl -0x14(%rbp), %esi
movq 0x20(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x33a10
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x33bec
cmpl $0x0, -0x10(%rbp)
je 0x33c32
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_captcha_encode
data load_data_captcha_encode(char **paths, int n, int m, 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.X.cols = 17100;
    d.y = d.X;
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
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 0x33c7b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x314c0
movq %rax, -0x8(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3190
movq -0x38(%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 -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x42cc, 0xc(%rax)      # imm = 0x42CC
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x33ced
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: fill_truth
void fill_truth(char *path, char **labels, int k, float *truth)
{
    int i;
    memset(truth, 0, k*sizeof(float));
    int count = 0;
    for(i = 0; i < k; ++i){
        if(strstr(path, labels[i])){
            truth[i] = 1;
            ++count;
            //printf("%s %s %d\n", path, labels[i], i);
        }
    }
    if(count != 1 && (k != 1 || count != 0)) printf("Too many or too few labels: %d, %s\n", count, path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3190
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x33d86
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3480
cmpq $0x0, %rax
je 0x33d79
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss 0x3d2a1(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x33d7b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33d38
cmpl $0x1, -0x28(%rbp)
je 0x33dad
cmpl $0x1, -0x14(%rbp)
jne 0x33d98
cmpl $0x0, -0x28(%rbp)
je 0x33dad
movl -0x28(%rbp), %esi
movq -0x8(%rbp), %rdx
leaq 0x405d7(%rip), %rdi     # 0x7437d
movb $0x0, %al
callq 0x3130
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: fill_hierarchy
void fill_hierarchy(float *truth, int k, tree *hierarchy)
{
    int j;
    for(j = 0; j < k; ++j){
        if(truth[j]){
            int parent = hierarchy->parent[j];
            while(parent >= 0){
                truth[parent] = 1;
                parent = hierarchy->parent[parent];
            }
        }
    }
    int i;
    int count = 0;
    for(j = 0; j < hierarchy->groups; ++j){
        //printf("%d\n", count);
        int mask = 1;
        for(i = 0; i < hierarchy->group_size[j]; ++i){
            if(truth[count + i]){
                mask = 0;
                break;
            }
        }
        if (mask) {
            for(i = 0; i < hierarchy->group_size[j]; ++i){
                truth[count + i] = SECRET_NUM;
            }
        }
        count += hierarchy->group_size[j];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x33e47
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x33df7
jp 0x33df7
jmp 0x33e3a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x33e38
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss 0x3d1ed(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
jmp 0x33e09
jmp 0x33e3a
jmp 0x33e3c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x33dd6
movl $0x0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x33f26
movl $0x1, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x33ebb
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x33ea5
jp 0x33ea5
jmp 0x33eae
movl $0x0, -0x2c(%rbp)
jmp 0x33ebb
jmp 0x33eb0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33e73
cmpl $0x0, -0x2c(%rbp)
je 0x33f03
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x33f01
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss 0x4042b(%rip), %xmm0    # 0x7431c
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33ec8
jmp 0x33f03
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x33e55
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_labels_paths
matrix load_labels_paths(char **paths, int n, char **labels, int k, tree *hierarchy)
{
    matrix y = make_matrix(n, k);
    int i;
    for(i = 0; i < n && labels; ++i){
        fill_truth(paths[i], labels, k, y.vals[i]);
        if(hierarchy){
            fill_hierarchy(y.vals[i], k, hierarchy);
        }
    }
    return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movl -0x1c(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0x39450
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x3d(%rbp)
jge 0x3421c
cmpq $0x0, -0x28(%rbp)
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x34225
jmp 0x34275
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x33d00
cmpq $0x0, -0x38(%rbp)
je 0x34268
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x33dc0
jmp 0x3426a
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x34204
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
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: load_tags_paths
matrix load_tags_paths(char **paths, int n, int k)
{
    matrix y = make_matrix(n, k);
    int i;
    //int count = 0;
    for(i = 0; i < n; ++i){
        char label[4096];
        find_replace(paths[i], "images", "labels", label);
        find_replace(label, ".jpg", ".txt", label);
        FILE *file = fopen(label, "r");
        if (!file) continue;
        //++count;
        int tag;
        while(fscanf(file, "%d", &tag) == 1){
            if(tag < k){
                y.vals[i][tag] = 1;
            }
        }
        fclose(file);
    }
    //printf("%d/%d\n", count, n);
    return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x39450
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x343a2
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x1030(%rbp), %rcx
leaq 0x4005a(%rip), %rsi     # 0x7433f
leaq 0x4005a(%rip), %rdx     # 0x74346
callq 0x4a50
leaq -0x1030(%rbp), %rdi
leaq -0x1030(%rbp), %rcx
leaq 0x3ee33(%rip), %rsi     # 0x73139
leaq 0x41d59(%rip), %rdx     # 0x76066
callq 0x4a50
leaq -0x1030(%rbp), %rdi
leaq 0x4224d(%rip), %rsi     # 0x7656d
callq 0x3360
movq %rax, -0x1038(%rbp)
cmpq $0x0, -0x1038(%rbp)
jne 0x34338
jmp 0x34394
jmp 0x3433a
movq -0x1038(%rbp), %rdi
leaq 0x42171(%rip), %rsi     # 0x764b9
leaq -0x103c(%rbp), %rdx
movb $0x0, %al
callq 0x3080
cmpl $0x1, %eax
jne 0x34388
movl -0x103c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x34386
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x103c(%rbp), %rcx
movss 0x3cc8b(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
jmp 0x3433a
movq -0x1038(%rbp), %rdi
callq 0x3100
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x342bf
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_labels
char **get_labels(char *filename)
{
    list *plist = get_paths(filename);
    char **labels = (char **)list_to_array(plist);
    free_list(plist);
    return labels;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31450
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8fb0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: free_data
void free_data(data d)
{
    if(!d.shallow){
        free_matrix(d.X);
        free_matrix(d.y);
    }else{
        free(d.X.vals);
        free(d.y.vals);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, 0x28(%rax)
jne 0x3443a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x39030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x39030
jmp 0x34454
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)