LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/batchnorm_layer.c
// Function: mean_delta_cpu
void mean_delta_cpu(float *delta, float *variance, int batch, int filters, int spatial, float *mean_delta)
{

    int i,j,k;
    for(i = 0; i < filters; ++i){
        mean_delta[i] = 0;
        for (j = 0; j < batch; ++j) {
            for (k = 0; k < spatial; ++k) {
                int index = j*filters*spatial + i*spatial + k;
                mean_delta[i] += delta[index];
            }
        }
        mean_delta[i] *= (-1./sqrt(variance[i] + .00001f));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4b8e6
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4b890
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4b883
movl -0x30(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4b837
jmp 0x4b885
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4b828
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss 0x29c94(%rip), %xmm0    # 0x75534
addss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3430
movsd 0x29c82(%rip), %xmm1    # 0x75538
divsd %xmm0, %xmm1
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4b805
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/batchnorm_layer.c
// Function: variance_delta_cpu
void  variance_delta_cpu(float *x, float *delta, float *mean, float *variance, int batch, int filters, int spatial, float *variance_delta)
{

    int i,j,k;
    for(i = 0; i < filters; ++i){
        variance_delta[i] = 0;
        for(j = 0; j < batch; ++j){
            for(k = 0; k < spatial; ++k){
                int index = j*filters*spatial + i*spatial + k;
                variance_delta[i] += delta[index]*(x[index] - mean[i]);
            }
        }
        variance_delta[i] *= -.5 * pow(variance[i] + .00001f, (float)(-3./2.));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x4ba30
movq 0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4b9d2
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x4b9c2
movl -0x30(%rbp), %eax
imull -0x28(%rbp), %eax
imull 0x10(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull 0x10(%rbp), %ecx
addl %ecx, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
subss (%rax,%rcx,4), %xmm2
movq 0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4b954
jmp 0x4b9c4
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4b941
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss 0x29b52(%rip), %xmm0    # 0x75534
addss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x29b55(%rip), %xmm1    # 0x75548
callq 0x30e0
movsd 0x29b40(%rip), %xmm1    # 0x75540
mulsd %xmm0, %xmm1
movq 0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4b91e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/batchnorm_layer.c
// Function: normalize_delta_cpu
void normalize_delta_cpu(float *x, float *mean, float *variance, float *mean_delta, float *variance_delta, int batch, int filters, int spatial, float *delta)
{
    int f, j, k;
    for(j = 0; j < batch; ++j){
        for(f = 0; f < filters; ++f){
            for(k = 0; k < spatial; ++k){
                int index = j*filters*spatial + f*spatial + k;
                delta[index] = delta[index] * 1./(sqrt(variance[f] + .00001f)) + variance_delta[f] * 2. * (x[index] - mean[f]) / (spatial * batch) + mean_delta[f]/(spatial*batch);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x4bbbe
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x4bbae
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0x4bb9e
movl -0x34(%rbp), %eax
imull 0x10(%rbp), %eax
imull 0x18(%rbp), %eax
movl -0x30(%rbp), %ecx
imull 0x18(%rbp), %ecx
addl %ecx, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq 0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2558a(%rip), %xmm1    # 0x71060
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss 0x29a45(%rip), %xmm0    # 0x75534
addss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3430
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
divsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x25536(%rip), %xmm2    # 0x71058
mulsd %xmm2, %xmm1
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
subss (%rax,%rcx,4), %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm1
movl 0x18(%rbp), %eax
imull -0x2c(%rbp), %eax
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
movl 0x18(%rbp), %eax
imull -0x2c(%rbp), %eax
cvtsi2ss %eax, %xmm2
divss %xmm2, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4ba97
jmp 0x4bba0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4ba84
jmp 0x4bbb0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4ba71
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/region_layer.c
// Function: resize_region_layer
void resize_region_layer(layer *l, int w, int h)
{
    l->w = w;
    l->h = h;

    l->outputs = h*w*l->n*(l->classes + l->coords + 1);
    l->inputs = l->outputs;

    l->output = realloc(l->output, l->batch*l->outputs*sizeof(float));
    l->delta = realloc(l->delta, 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)
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x84(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0xfc(%rax), %eax
movq -0x8(%rbp), %rdx
addl 0x100(%rdx), %eax
addl $0x1, %eax
imull %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%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)
movq -0x8(%rbp), %rax
movq 0x260(%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, 0x260(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/region_layer.c
// Function: get_region_box
box get_region_box(float *x, float *biases, int n, int index, int i, int j, int w, int h, int stride)
{
    box b;
    b.x = (i + x[index + 0*stride]) / w;
    b.y = (j + x[index + 1*stride]) / h;
    b.w = exp(x[index + 2*stride]) * biases[2*n]   / w;
    b.h = exp(x[index + 3*stride]) * biases[2*n+1] / h;
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movl %ecx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
cvtsi2ssl -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
addss %xmm1, %xmm0
cvtsi2ssl 0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
cvtsi2ssl -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl 0x20(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
addss %xmm1, %xmm0
cvtsi2ssl 0x18(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %esi
movl 0x20(%rbp), %ecx
movl %ecx, %edx
movl %esi, %ecx
leal (%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x34a0
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl 0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl 0x20(%rbp), %esi
movl %esi, %edx
leal (%rdx,%rdx,2), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x34a0
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
movss 0x4(%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl 0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/region_layer.c
// Function: zero_objectness
void zero_objectness(layer l)
{
    int i, n;
    for (i = 0; i < l.w*l.h; ++i){
        for(n = 0; n < l.n; ++n){
            int obj_index = entry_index(l, 0, n*l.w*l.h + i, l.coords);
            l.output[obj_index] = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rdx
movl -0x4(%rbp), %eax
movl 0x70(%rdx), %ecx
imull 0x6c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x4e76b
movl $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x4e75b
movq -0x18(%rbp), %rsi
movl -0x8(%rbp), %eax
imull 0x70(%rsi), %eax
imull 0x6c(%rsi), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl 0x100(%rsi), %edx
xorl %eax, %eax
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
movl -0x1c(%rbp), %esi
xorl %edi, %edi
callq 0x4db20
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x268(%rax), %rax
movslq -0xc(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4e6f3
jmp 0x4e75d
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4e6da
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/reorg_layer.c
// Function: forward_reorg_layer
void forward_reorg_layer(const layer l, network net)
{
    int i;
    if(l.flatten){
        memcpy(l.output, net.input, l.outputs*l.batch*sizeof(float));
        if(l.reverse){
            flatten(l.output, l.w*l.h, l.c, l.batch, 0);
        }else{
            flatten(l.output, l.w*l.h, l.c, l.batch, 1);
        }
    } else if (l.extra) {
        for(i = 0; i < l.batch; ++i){
            copy_cpu(l.inputs, net.input + i*l.inputs, 1, l.output + i*l.outputs, 1);
        }
    } else if (l.reverse){
        reorg_cpu(net.input, l.w, l.h, l.c, l.batch, l.stride, 1, l.output);
    } else {
        reorg_cpu(net.input, l.w, l.h, l.c, l.batch, l.stride, 0, l.output);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0xa0(%rax)
je 0x4ea38
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x268(%rcx), %rdi
movq 0xd8(%rax), %rsi
movl 0x58(%rcx), %eax
imull 0x48(%rcx), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x3280
movq -0x10(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x4ea10
movq -0x10(%rbp), %rax
movq 0x268(%rax), %rdi
movl 0x70(%rax), %esi
imull 0x6c(%rax), %esi
movl 0x74(%rax), %edx
movl 0x48(%rax), %ecx
xorl %r8d, %r8d
callq 0x2eb50
jmp 0x4ea33
movq -0x10(%rbp), %rax
movq 0x268(%rax), %rdi
movl 0x70(%rax), %esi
imull 0x6c(%rax), %esi
movl 0x74(%rax), %edx
movl 0x48(%rax), %ecx
movl $0x1, %r8d
callq 0x2eb50
jmp 0x4eb38
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x4eaac
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x4eaa7
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x54(%rdx), %edi
movq 0xd8(%rax), %rsi
movl -0x4(%rbp), %eax
imull 0x54(%rdx), %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
movq 0x268(%rdx), %rcx
movl -0x4(%rbp), %eax
imull 0x58(%rdx), %eax
cltq
shlq $0x2, %rax
addq %rax, %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f960
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4ea49
jmp 0x4eb36
movq -0x10(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x4eaf6
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0xd8(%rcx), %rdi
movl 0x70(%rax), %esi
movl 0x6c(%rax), %edx
movl 0x74(%rax), %ecx
movl 0x48(%rax), %r8d
movl 0x98(%rax), %r9d
movq 0x268(%rax), %rax
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2e9b0
jmp 0x4eb34
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0xd8(%rcx), %rdi
movl 0x70(%rax), %esi
movl 0x6c(%rax), %edx
movl 0x74(%rax), %ecx
movl 0x48(%rax), %r8d
movl 0x98(%rax), %r9d
movq 0x268(%rax), %rax
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2e9b0
jmp 0x4eb36
jmp 0x4eb38
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/reorg_layer.c
// Function: backward_reorg_layer
void backward_reorg_layer(const layer l, network net)
{
    int i;
    if(l.flatten){
        memcpy(net.delta, l.delta, l.outputs*l.batch*sizeof(float));
        if(l.reverse){
            flatten(net.delta, l.w*l.h, l.c, l.batch, 1);
        }else{
            flatten(net.delta, l.w*l.h, l.c, l.batch, 0);
        }
    } else if(l.reverse){
        reorg_cpu(l.delta, l.w, l.h, l.c, l.batch, l.stride, 0, net.delta);
    } else if (l.extra) {
        for(i = 0; i < l.batch; ++i){
            copy_cpu(l.inputs, l.delta + i*l.outputs, 1, net.delta + i*l.inputs, 1);
        }
    }else{
        reorg_cpu(l.delta, l.w, l.h, l.c, l.batch, l.stride, 1, net.delta);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0xa0(%rax)
je 0x4ebf0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rdi
movq 0x260(%rcx), %rsi
movl 0x58(%rcx), %eax
imull 0x48(%rcx), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x3280
movq -0x10(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x4ebc7
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0xe8(%rcx), %rdi
movl 0x70(%rax), %esi
imull 0x6c(%rax), %esi
movl 0x74(%rax), %edx
movl 0x48(%rax), %ecx
movl $0x1, %r8d
callq 0x2eb50
jmp 0x4ebeb
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0xe8(%rcx), %rdi
movl 0x70(%rax), %esi
imull 0x6c(%rax), %esi
movl 0x74(%rax), %edx
movl 0x48(%rax), %ecx
xorl %r8d, %r8d
callq 0x2eb50
jmp 0x4ecf7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x4ec43
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %r9
movq 0x260(%r9), %rdi
movl 0x70(%r9), %esi
movl 0x6c(%r9), %edx
movl 0x74(%r9), %ecx
movl 0x48(%r9), %r8d
movl 0x98(%r9), %r9d
movq 0xe8(%rax), %rax
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2e9b0
jmp 0x4ecf5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x4ecb5
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x4ecb3
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x54(%rdx), %edi
movq 0x260(%rdx), %rsi
movl -0x4(%rbp), %ecx
imull 0x58(%rdx), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rsi
movq 0xe8(%rax), %rcx
movl -0x4(%rbp), %eax
imull 0x54(%rdx), %eax
cltq
shlq $0x2, %rax
addq %rax, %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f960
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4ec54
jmp 0x4ecf3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %r9
movq 0x260(%r9), %rdi
movl 0x70(%r9), %esi
movl 0x6c(%r9), %edx
movl 0x74(%r9), %ecx
movl 0x48(%r9), %r8d
movl 0x98(%r9), %r9d
movq 0xe8(%rax), %rax
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2e9b0
jmp 0x4ecf5
jmp 0x4ecf7
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/reorg_layer.c
// Function: resize_reorg_layer
void resize_reorg_layer(layer *l, int w, int h)
{
    int stride = l->stride;
    int c = l->c;

    l->h = h;
    l->w = w;

    if(l->reverse){
        l->out_w = w*stride;
        l->out_h = h*stride;
        l->out_c = c/(stride*stride);
    }else{
        l->out_w = w/stride;
        l->out_h = h/stride;
        l->out_c = c*(stride*stride);
    }

    l->outputs = l->out_h * l->out_w * l->out_c;
    l->inputs = l->outputs;
    int output_size = l->outputs * l->batch;

    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)
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x18(%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)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x4ed81
movl -0xc(%rbp), %ecx
imull -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl -0x10(%rbp), %ecx
imull -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x14(%rbp), %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x80(%rax)
jmp 0x4edb8
movl -0xc(%rbp), %eax
cltd
idivl -0x14(%rbp)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl -0x10(%rbp), %eax
cltd
idivl -0x14(%rbp)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
imull -0x14(%rbp), %eax
imull %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x80(%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
movl 0x58(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movslq -0x1c(%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 -0x1c(%rbp), %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x260(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/tree.c
// Function: change_leaves
void change_leaves(tree *t, char *leaf_list)
{
    list *llist = get_paths(leaf_list);
    char **leaves = (char **)list_to_array(llist);
    int n = llist->size;
    int i,j;
    int found = 0;
    for(i = 0; i < t->n; ++i){
        t->leaf[i] = 0;
        for(j = 0; j < n; ++j){
            if (0==strcmp(t->name[i], leaves[j])){
                t->leaf[i] = 1;
                ++found;
                break;
            }
        }
    }
    fprintf(stderr, "Found %d leaves.\n", found);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31450
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9020
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4ef25
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4ef15
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3230
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4ef08
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4ef15
jmp 0x4ef0a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4eeba
jmp 0x4ef17
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4ee91
movq 0x340cc(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x30(%rbp), %edx
leaq 0x26720(%rip), %rsi     # 0x75659
movb $0x0, %al
callq 0x3240
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/tree.c
// Function: get_hierarchy_probability
float get_hierarchy_probability(float *x, tree *hier, int c, int stride)
{
    float p = 1;
    while(c >= 0){
        p = p * x[c*stride];
        c = hier->parent[c];
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movss 0x220a2(%rip), %xmm0    # 0x7100c
movss %xmm0, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x4efa6
movss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
jmp 0x4ef6f
movss -0x1c(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/tree.c
// Function: hierarchy_predictions
void hierarchy_predictions(float *predictions, int n, tree *hier, int only_leaves, int stride)
{
    int j;
    for(j = 0; j < n; ++j){
        int parent = hier->parent[j];
        if(parent >= 0){
            predictions[j*stride] *= predictions[parent*stride]; 
        }
    }
    if(only_leaves){
        for(j = 0; j < n; ++j){
            if(!hier->leaf[j]) predictions[j*stride] = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4f025
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x4f018
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x20(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x4f01a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4efcd
cmpl $0x0, -0x1c(%rbp)
je 0x4f070
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4f06e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x4f061
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x20(%rbp), %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x4f063
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4f032
jmp 0x4f070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/tree.c
// Function: hierarchy_top_prediction
int hierarchy_top_prediction(float *predictions, tree *hier, float thresh, int stride)
{
    float p = 1;
    int group = 0;
    int i;
    while(1){
        float max = 0;
        int max_i = 0;

        for(i = 0; i < hier->group_size[group]; ++i){
            int index = i + hier->group_offset[group];
            float val = predictions[(i + hier->group_offset[group])*stride];
            if(val > max){
                max_i = index;
                max = val;
            }
        }
        if(p*max > thresh){
            p = p*max;
            group = hier->child[max_i];
            if(hier->child[max_i] < 0) return max_i;
        } else if (group == 0){
            return max_i;
        } else {
            return hier->parent[hier->group_offset[group]];
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movss 0x21f70(%rip), %xmm0    # 0x7100c
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rcx
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x4f136
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rcx
movslq -0x28(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rdx
movq 0x40(%rdx), %rdx
movslq -0x28(%rbp), %rsi
addl (%rdx,%rsi,4), %ecx
imull -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
ucomiss -0x30(%rbp), %xmm0
jbe 0x4f129
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
jmp 0x4f12b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4f0be
movss -0x24(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
ucomiss -0x1c(%rbp), %xmm0
jbe 0x4f183
movss -0x24(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x34(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0x4f181
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4f1b6
jmp 0x4f1b1
cmpl $0x0, -0x28(%rbp)
jne 0x4f191
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4f1b6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rcx
movslq -0x28(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x4f1b6
jmp 0x4f0a8
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/lstm_layer.c
// Function: update_lstm_layer
void update_lstm_layer(layer l, update_args a)
{
    update_connected_layer(*(l.wf), a);
    update_connected_layer(*(l.wi), a);
    update_connected_layer(*(l.wg), a);
    update_connected_layer(*(l.wo), a);
    update_connected_layer(*(l.uf), a);
    update_connected_layer(*(l.ui), a);
    update_connected_layer(*(l.ug), a);
    update_connected_layer(*(l.uo), a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
leaq 0x4b0(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x468(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x478(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x488(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x458(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x460(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x470(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x450(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/l2norm_layer.c
// Function: make_l2norm_layer
layer make_l2norm_layer(int batch, int inputs)
{
    fprintf(stderr, "l2norm                                         %4d\n",  inputs);
    layer l = {0};
    l.type = L2NORM;
    l.batch = batch;
    l.inputs = inputs;
    l.outputs = inputs;
    l.output = calloc(inputs*batch, sizeof(float));
    l.scales = calloc(inputs*batch, sizeof(float));
    l.delta = calloc(inputs*batch, sizeof(float));

    l.forward = forward_l2norm_layer;
    l.backward = backward_l2norm_layer;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movq 0x3179b(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x23e2a(%rip), %rsi     # 0x75694
movb $0x0, %al
callq 0x3240
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x18(%rbp), %rdi
movl $0x1c, (%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x54(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x58(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, 0x268(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, 0x240(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x260(%rdi)
leaq 0x18(%rip), %rcx        # 0x51920
movq %rcx, 0x10(%rdi)
leaq 0x7d(%rip), %rcx        # 0x51990
movq %rcx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/yolo_layer.c
// Function: resize_yolo_layer
void resize_yolo_layer(layer *l, int w, int h)
{
    l->w = w;
    l->h = h;

    l->outputs = h*w*l->n*(l->classes + 4 + 1);
    l->inputs = l->outputs;

    l->output = realloc(l->output, l->batch*l->outputs*sizeof(float));
    l->delta = realloc(l->delta, 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)
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x84(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0xfc(%rax), %eax
addl $0x4, %eax
addl $0x1, %eax
imull %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%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)
movq -0x8(%rbp), %rax
movq 0x260(%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, 0x260(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/yolo_layer.c
// Function: get_yolo_box
box get_yolo_box(float *x, float *biases, int n, int index, int i, int j, int lw, int lh, int w, int h, int stride)
{
    box b;
    b.x = (i + x[index + 0*stride]) / lw;
    b.y = (j + x[index + 1*stride]) / lh;
    b.w = exp(x[index + 2*stride]) * biases[2*n]   / w;
    b.h = exp(x[index + 3*stride]) * biases[2*n+1] / h;
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movl %ecx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
cvtsi2ssl -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
addss %xmm1, %xmm0
cvtsi2ssl 0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
cvtsi2ssl -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl 0x30(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
addss %xmm1, %xmm0
cvtsi2ssl 0x18(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %esi
movl 0x30(%rbp), %ecx
movl %ecx, %edx
movl %esi, %ecx
leal (%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x34a0
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl 0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl 0x30(%rbp), %esi
movl %esi, %edx
leal (%rdx,%rdx,2), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x34a0
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
movss 0x4(%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl 0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/yolo_layer.c
// Function: delta_yolo_class
void delta_yolo_class(float *output, float *delta, int index, int class, int classes, int stride, float *avg_cat)
{
    int n;
    if (delta[index]){
        delta[index + stride*class] = 1 - output[index + stride*class];
        if(avg_cat) *avg_cat += output[index + stride*class];
        return;
    }
    for(n = 0; n < classes; ++n){
        delta[index + stride*n] = ((n == class)?1 : 0) - output[index + stride*n];
        if(n == class && avg_cat) *avg_cat += output[index + stride*n];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x52e97
jp 0x52e97
jmp 0x52eff
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl -0x20(%rbp), %edx
imull -0x18(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss 0x1e15a(%rip), %xmm0    # 0x7100c
subss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl -0x20(%rbp), %edx
imull -0x18(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
cmpq $0x0, 0x10(%rbp)
je 0x52efa
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl -0x20(%rbp), %edx
imull -0x18(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x10(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
jmp 0x52f9b
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x52f9b
movl -0x24(%rbp), %edx
movl -0x18(%rbp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl -0x20(%rbp), %edx
imull -0x24(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
subss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl -0x20(%rbp), %edx
imull -0x24(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x52f8b
cmpq $0x0, 0x10(%rbp)
je 0x52f8b
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl -0x20(%rbp), %edx
imull -0x24(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x10(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
jmp 0x52f8d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x52f06
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/yolo_layer.c
// Function: yolo_num_detections
int yolo_num_detections(layer l, float thresh)
{
    int i, n;
    int count = 0;
    for (i = 0; i < l.w*l.h; ++i){
        for(n = 0; n < l.n; ++n){
            int obj_index  = entry_index(l, 0, n*l.w*l.h + i, 4);
            if(l.output[obj_index] > thresh){
                ++count;
            }
        }
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss %xmm0, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rdx
movl -0x8(%rbp), %eax
movl 0x70(%rdx), %ecx
imull 0x6c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x532c8
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x532b8
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %eax
imull 0x70(%rsi), %eax
imull 0x6c(%rsi), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
movl -0x24(%rbp), %esi
xorl %edi, %edi
movl $0x4, %edx
callq 0x52fa0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x268(%rax), %rax
movslq -0x14(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x4(%rbp), %xmm0
jbe 0x532ab
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x532ad
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x53243
jmp 0x532ba
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x53226
movl -0x10(%rbp), %eax
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/iseg_layer.c
// Function: resize_iseg_layer
void resize_iseg_layer(layer *l, int w, int h)
{
    l->w = w;
    l->h = h;

    l->outputs = h*w*l->c;
    l->inputs = l->outputs;

    l->output = realloc(l->output, l->batch*l->outputs*sizeof(float));
    l->delta = realloc(l->delta, 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)
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x74(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%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)
movq -0x8(%rbp), %rax
movq 0x260(%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, 0x260(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/captcha.c
// Function: fix_data_captcha
void fix_data_captcha(data d, int mask)
{
    matrix labels = d.y;
    int i, j;
    for(i = 0; i < d.y.rows; ++i){
        for(j = 0; j < d.y.cols; j += 2){
            if (mask){
                if(!labels.vals[i][j]){
                    labels.vals[i][j] = SECRET_NUM;
                    labels.vals[i][j+1] = SECRET_NUM;
                }else if(labels.vals[i][j+1]){
                    labels.vals[i][j] = 0;
                }
            } else{
                if (labels.vals[i][j]) {
                    labels.vals[i][j+1] = 0;
                } else {
                    labels.vals[i][j+1] = 1;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl %edi, -0x4(%rbp)
movq 0x18(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x5470d
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x546fd
cmpl $0x0, -0x4(%rbp)
je 0x54689
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x54647
jp 0x54647
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss 0x1fcfe(%rip), %xmm0    # 0x7431c
movss %xmm0, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss 0x1fcdc(%rip), %xmm0    # 0x7431c
movss %xmm0, (%rax,%rcx,4)
jmp 0x54687
movq -0x10(%rbp), %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
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x5466d
jp 0x5466d
jmp 0x54685
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x54687
jmp 0x546ed
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x546aa
jp 0x546aa
jmp 0x546c9
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x546eb
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss 0x1c926(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
jmp 0x546ed
jmp 0x546ef
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
jmp 0x545cd
jmp 0x546ff
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x545b6
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/captcha.c
// Function: run_captcha
void run_captcha(int argc, char **argv)
{
    if(argc < 4){
        fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
        return;
    }

    char *cfg = argv[3];
    char *weights = (argc > 4) ? argv[4] : 0;
    char *filename = (argc > 5) ? argv[5]: 0;
    if(0==strcmp(argv[2], "train")) train_captcha(cfg, weights);
    else if(0==strcmp(argv[2], "test")) test_captcha(cfg, weights, filename);
    else if(0==strcmp(argv[2], "valid")) valid_captcha(cfg, weights, filename);
    //if(0==strcmp(argv[2], "test")) test_captcha(cfg, weights);
    //else if(0==strcmp(argv[2], "encode")) encode_captcha(cfg, weights);
    //else if(0==strcmp(argv[2], "decode")) decode_captcha(cfg, weights);
    //else if(0==strcmp(argv[2], "valid")) validate_captcha(cfg, weights);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0x54f71
movq 0x2e0ac(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x2092b(%rip), %rsi     # 0x75890
movb $0x0, %al
callq 0x3240
jmp 0x55050
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x4, -0x4(%rbp)
jle 0x54f91
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x54f99
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x54f99
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x5, -0x4(%rbp)
jle 0x54fb5
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x54fbd
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x54fbd
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x20be8(%rip), %rsi     # 0x75bbc
callq 0x3230
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x54ff0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x54710
jmp 0x55050
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x2199a(%rip), %rsi     # 0x76999
callq 0x3230
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x5501f
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x54af0
jmp 0x5504e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x1e945(%rip), %rsi     # 0x73973
callq 0x3230
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x5504c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x54cf0
jmp 0x5504e
jmp 0x55050
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)