LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, 0xc(%rsp)
movq %rcx, 0x28(%rsp)
testl %r9d, %r9d
jle 0x3cc96
movl %r9d, %ebx
movq %rdx, %r15
movq 0x78(%rsp), %r14
movl 0x70(%rsp), %r10d
movl %r9d, %eax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %ebp
movl %r10d, %r12d
imull %r10d, %ebx
xorl %r11d, %r11d
xorl %r13d, %r13d
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movl $0x0, (%r14,%r13,4)
cmpl $0x0, 0xc(%rsp)
jle 0x3cc26
xorps %xmm0, %xmm0
movl %r11d, %eax
xorl %ecx, %ecx
testl %r10d, %r10d
jle 0x3cc1c
movslq %eax, %r8
leaq (%rsi,%r8,4), %rdx
leaq (%rdi,%r8,4), %r8
xorl %r9d, %r9d
movss (%r8,%r9,4), %xmm1
subss (%r15,%r13,4), %xmm1
mulss (%rdx,%r9,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%r14,%r13,4)
incq %r9
cmpq %r9, %r12
jne 0x3cbf8
incq %rcx
addl %ebx, %eax
cmpq %rbp, %rcx
jne 0x3cbe5
movq 0x28(%rsp), %rax
movss (%rax,%r13,4), %xmm0
addss 0x1ce47(%rip), %xmm0    # 0x59a80
cvtss2sd %xmm0, %xmm0
movsd 0x1d113(%rip), %xmm1    # 0x59d58
movq %r11, 0x30(%rsp)
callq 0x3110
movq 0x30(%rsp), %r11
movl 0x70(%rsp), %r10d
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorps %xmm1, %xmm1
cvtss2sd (%r14,%r13,4), %xmm1
mulsd 0x1d0ec(%rip), %xmm0    # 0x59d60
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%r14,%r13,4)
incq %r13
addl %r10d, %r11d
cmpq 0x10(%rsp), %r13
jne 0x3cbce
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, 0x30(%rsp)
testl %r9d, %r9d
jle 0x3ce69
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %rbx
movl 0xa8(%rsp), %edi
movl 0xa0(%rsp), %r10d
movl %edi, %eax
imull %r9d, %eax
cvtsi2sd %eax, %xmm2
cvtsi2ss %eax, %xmm3
movl %r10d, %eax
movq %rax, 0x38(%rsp)
movl %r9d, %eax
movq %rax, 0x20(%rsp)
movl %edi, %r9d
movl %edi, %eax
imull %r10d, %eax
movl %eax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movss 0x1cd68(%rip), %xmm4    # 0x59a80
xorpd %xmm5, %xmm5
xorl %r10d, %r10d
movsd %xmm2, 0x48(%rsp)
movss %xmm3, 0x1c(%rsp)
movq %r9, 0x40(%rsp)
movq %r10, 0x28(%rsp)
cmpl $0x0, 0xa0(%rsp)
jle 0x3ce48
movq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
xorl %r13d, %r13d
testl %edi, %edi
jle 0x3ce2f
movslq 0xc(%rsp), %rax
movq 0xb0(%rsp), %rdi
leaq (%rdi,%rax,4), %r10
movq 0x30(%rsp), %rdi
leaq (%rdi,%rax,4), %rax
xorl %r15d, %r15d
movq %r10, 0x58(%rsp)
movq %rax, 0x50(%rsp)
xorps %xmm6, %xmm6
cvtss2sd (%r10,%r15,4), %xmm6
movss (%r14,%r13,4), %xmm0
addss %xmm4, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm5, %xmm0
jb 0x3cda1
sqrtsd %xmm0, %xmm0
jmp 0x3cdd9
movsd %xmm6, 0x60(%rsp)
callq 0x3460
movsd 0x60(%rsp), %xmm6
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %r10
xorpd %xmm5, %xmm5
movss 0x1ccb8(%rip), %xmm4    # 0x59a80
movq 0x40(%rsp), %r9
movss 0x1c(%rsp), %xmm3
movsd 0x48(%rsp), %xmm2
divsd %xmm0, %xmm6
xorps %xmm0, %xmm0
cvtss2sd (%r12,%r13,4), %xmm0
addsd %xmm0, %xmm0
movss (%rax,%r15,4), %xmm1
subss (%rbx,%r13,4), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
addsd %xmm6, %xmm1
movss (%rbp,%r13,4), %xmm0
divss %xmm3, %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r10,%r15,4)
incq %r15
cmpq %r15, %r9
jne 0x3cd7e
incq %r13
movl 0xa8(%rsp), %edi
addl %edi, 0xc(%rsp)
cmpq 0x38(%rsp), %r13
jne 0x3cd4f
movq 0x28(%rsp), %r10
incq %r10
movq 0x10(%rsp), %rax
addl 0x18(%rsp), %eax
movq %rax, 0x10(%rsp)
cmpq 0x20(%rsp), %r10
jne 0x3cd30
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/region_layer.c
// Function: delta_region_class
void delta_region_class(float *output, float *delta, int index, int class, int classes, tree *hier, float scale, int stride, float *avg_cat, int tag)
{
    int i, n;
    if(hier){
        float pred = 1;
        while(class >= 0){
            pred *= output[index + stride*class];
            int g = hier->group[class];
            int offset = hier->group_offset[g];
            for(i = 0; i < hier->group_size[g]; ++i){
                delta[index + stride*(offset + i)] = scale * (0 - output[index + stride*(offset + i)]);
            }
            delta[index + stride*class] = scale * (1 - output[index + stride*class]);

            class = hier->parent[class];
        }
        *avg_cat += pred;
    } else {
        if (delta[index] && tag){
            delta[index + stride*class] = scale * (1 - output[index + stride*class]);
            return;
        }
        for(n = 0; n < classes; ++n){
            delta[index + stride*n] = scale * (((n == class)?1 : 0) - output[index + stride*n]);
            if(n == class) *avg_cat += output[index + stride*n];
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x40(%rsp), %rax
movl 0x38(%rsp), %r10d
testq %r9, %r9
je 0x3e100
testl %ecx, %ecx
js 0x3e13c
movq 0x10(%r9), %r8
movq 0x20(%r9), %r11
movq 0x40(%r9), %rbx
movq 0x38(%r9), %r9
movslq %r10d, %r14
movslq %edx, %r15
leaq (,%r14,4), %r12
movss 0x16f77(%rip), %xmm2    # 0x55008
movaps %xmm2, %xmm1
movl %ecx, %r13d
imull %r10d, %ecx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rdi,%rcx,4), %xmm3
movslq (%r11,%r13,4), %rax
movslq (%r9,%rax,4), %rbp
movaps %xmm3, %xmm4
testq %rbp, %rbp
jle 0x3e0e2
movslq (%rbx,%rax,4), %rax
imulq %r14, %rax
addq %r15, %rax
shlq $0x2, %rax
xorps %xmm4, %xmm4
subss (%rdi,%rax), %xmm4
mulss %xmm0, %xmm4
movss %xmm4, (%rsi,%rax)
addq %r12, %rax
decq %rbp
jne 0x3e0c4
movss (%rdi,%rcx,4), %xmm4
mulss %xmm3, %xmm1
movaps %xmm2, %xmm3
subss %xmm4, %xmm3
mulss %xmm0, %xmm3
movss %xmm3, (%rsi,%rcx,4)
movl (%r8,%r13,4), %ecx
testl %ecx, %ecx
jns 0x3e094
jmp 0x3e144
movslq %edx, %r9
cmpl $0x0, 0x48(%rsp)
je 0x3e15c
movss (%rsi,%r9,4), %xmm1
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x3e11a
jnp 0x3e15c
imull %ecx, %r10d
addl %edx, %r10d
movslq %r10d, %rax
movss 0x16edc(%rip), %xmm1    # 0x55008
subss (%rdi,%rax,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rsi,%rax,4)
jmp 0x3e151
movss 0x16ec4(%rip), %xmm1    # 0x55008
movq 0x40(%rsp), %rax
addss (%rax), %xmm1
movss %xmm1, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r8d, %r8d
jle 0x3e151
movl %ecx, %ecx
movslq %r10d, %rdx
movl %r8d, %r8d
shlq $0x2, %r9
shlq $0x2, %rdx
xorl %r10d, %r10d
movss 0x16e8c(%rip), %xmm1    # 0x55008
movaps %xmm1, %xmm2
cmpq %r10, %rcx
je 0x3e187
xorps %xmm2, %xmm2
subss (%rdi,%r9), %xmm2
mulss %xmm0, %xmm2
movss %xmm2, (%rsi,%r9)
jne 0x3e1a7
movss (%rdi,%r9), %xmm2
addss (%rax), %xmm2
movss %xmm2, (%rax)
incq %r10
addq %rdx, %r9
cmpq %r10, %r8
jne 0x3e17c
jmp 0x3e151
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/region_layer.c
// Function: correct_region_boxes
void correct_region_boxes(detection *dets, int n, int w, int h, int netw, int neth, int relative)
{
    int i;
    int new_w=0;
    int new_h=0;
    if (((float)netw/w) < ((float)neth/h)) {
        new_w = netw;
        new_h = (h * netw)/w;
    } else {
        new_h = neth;
        new_w = (w * neth)/h;
    }
    for (i = 0; i < n; ++i){
        box b = dets[i].bbox;
        b.x =  (b.x - (netw - new_w)/2./netw) / ((float)new_w/netw); 
        b.y =  (b.y - (neth - new_h)/2./neth) / ((float)new_h/neth); 
        b.w *= (float)netw/new_w;
        b.h *= (float)neth/new_h;
        if(!relative){
            b.x *= w;
            b.w *= w;
            b.y *= h;
            b.h *= h;
        }
        dets[i].bbox = b;
    }
}

// Assembly:
movl %r8d, %eax
movl %edx, %r8d
movd %r9d, %xmm0
movd %eax, %xmm2
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
cvtdq2ps %xmm2, %xmm0
movd %ecx, %xmm1
movd %edx, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
cvtdq2ps %xmm3, %xmm1
movaps %xmm0, %xmm3
divps %xmm1, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
ucomiss %xmm3, %xmm4
jbe 0x3e26a
imull %ecx, %eax
cltd
idivl %r8d
movd %eax, %xmm3
punpcklqdq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0]
shufps $0xe2, %xmm2, %xmm3     # xmm3 = xmm3[2,0],xmm2[2,3]
jmp 0x3e27f
imull %r8d, %r9d
movl %r9d, %eax
cltd
idivl %ecx
movd %eax, %xmm4
movaps %xmm2, %xmm3
movss %xmm4, %xmm3            # xmm3 = xmm4[0],xmm3[1,2,3]
testl %esi, %esi
jle 0x3e2ee
movl 0x8(%rsp), %eax
movlhps %xmm1, %xmm1            # xmm1 = xmm1[0,0]
cvtdq2pd %xmm2, %xmm4
cvtdq2ps %xmm3, %xmm5
psubd %xmm3, %xmm2
cvtdq2pd %xmm2, %xmm2
mulpd 0x1703f(%rip), %xmm2    # 0x552e0
divpd %xmm4, %xmm2
movaps %xmm5, %xmm3
divps %xmm0, %xmm3
cvtps2pd %xmm3, %xmm3
divps %xmm5, %xmm0
movl %esi, %ecx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
cvtps2pd (%rdi,%rdx), %xmm4
subpd %xmm2, %xmm4
divpd %xmm3, %xmm4
cvtpd2ps %xmm4, %xmm4
movsd 0x8(%rdi,%rdx), %xmm5
mulps %xmm0, %xmm5
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
testl %eax, %eax
jne 0x3e2e1
mulps %xmm1, %xmm4
movups %xmm4, (%rdi,%rdx)
addq $0x30, %rdx
cmpq %rdx, %rcx
jne 0x3e2bd
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0xa0(%rsp), %esi
imull 0x9c(%rsp), %esi
testl %esi, %esi
jle 0x3e9d3
leaq 0x30(%rsp), %rax
movl 0x84(%rax), %edi
movl 0xfc(%rax), %ecx
movl 0x100(%rax), %r8d
leal (%r8,%rcx), %r9d
incl %r9d
movq 0x268(%rax), %r10
leal 0x3(%rdi), %r11d
andl $-0x4, %r11d
leal -0x1(%rdi), %eax
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
leal (%rsi,%rsi,2), %ebx
leal (,%rsi,4), %ebp
leal (%rsi,%rsi), %r14d
xorl %r15d, %r15d
movdqa 0x1b4c8(%rip), %xmm1    # 0x59db0
movdqa 0x167a0(%rip), %xmm2    # 0x55090
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x1b4c0(%rip), %xmm4    # 0x59dc0
testl %edi, %edi
jle 0x3e9c7
movl %r11d, %r12d
movl %r15d, %ecx
movdqa %xmm1, %xmm5
movdqa %xmm5, %xmm6
pxor %xmm2, %xmm6
pcmpgtd %xmm0, %xmm6
movd %xmm6, %eax
notl %eax
testb $0x1, %al
je 0x3e943
movl %ecx, %eax
cltd
idivl %esi
imull %r9d, %eax
addl %r8d, %eax
imull %esi, %eax
addl %edx, %eax
cltq
movl $0x0, (%r10,%rax,4)
pxor %xmm3, %xmm6
pextrw $0x2, %xmm6, %eax
testb $0x1, %al
je 0x3e96c
leal (%rsi,%rcx), %eax
cltd
idivl %esi
imull %r9d, %eax
addl %r8d, %eax
imull %esi, %eax
addl %edx, %eax
cltq
movl $0x0, (%r10,%rax,4)
pextrw $0x4, %xmm6, %eax
testb $0x1, %al
je 0x3e992
leal (%r14,%rcx), %eax
cltd
idivl %esi
imull %r9d, %eax
addl %r8d, %eax
imull %esi, %eax
addl %edx, %eax
cltq
movl $0x0, (%r10,%rax,4)
pextrw $0x6, %xmm6, %eax
testb $0x1, %al
je 0x3e9b7
leal (%rbx,%rcx), %eax
cltd
idivl %esi
imull %r9d, %eax
addl %r8d, %eax
imull %esi, %eax
addl %edx, %eax
cltq
movl $0x0, (%r10,%rax,4)
paddd %xmm4, %xmm5
addl %ebp, %ecx
addl $-0x4, %r12d
jne 0x3e912
incl %r15d
cmpl %esi, %r15d
jne 0x3e900
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4e0(%rsp), %rax
leaq 0x40(%rsp), %r12
cmpl $0x0, 0xa0(%r12)
je 0x3ebe0
movq 0x268(%r12), %r14
movq 0xd8(%rax), %rsi
movslq 0x58(%r12), %rdx
movslq 0x48(%r12), %rbx
imulq %rbx, %rdx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0x32b0
movl 0x6c(%r12), %esi
movl 0x74(%r12), %edx
imull 0x70(%r12), %esi
cmpl $0x0, 0x9c(%r12)
je 0x3ec3f
movq %r14, %rdi
movl %ebx, %ecx
xorl %r8d, %r8d
jmp 0x3ec4a
cmpl $0x0, 0x64(%r12)
je 0x3ec5d
movslq 0x48(%r12), %r13
testq %r13, %r13
jle 0x3ec39
movslq 0x54(%r12), %rbx
movq 0xd8(%rax), %r14
movq 0x268(%r12), %r15
movslq 0x58(%r12), %r12
shlq $0x2, %r12
movq %rbx, %rbp
shlq $0x2, %rbp
movl %ebx, %edi
movq %r14, %rsi
movl $0x1, %edx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x29fe0
addq %r12, %r15
addq %rbp, %r14
decq %r13
jne 0x3ec16
addq $0x8, %rsp
jmp 0x3eca4
movq %r14, %rdi
movl %ebx, %ecx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29414
cmpl $0x0, 0x9c(%r12)
movq 0xd8(%rax), %rdi
movl 0x70(%r12), %esi
movl 0x48(%r12), %r8d
movl 0x6c(%r12), %edx
movl 0x74(%r12), %ecx
movl 0x98(%r12), %r9d
movq 0x268(%r12), %rax
je 0x3ec98
pushq %rax
pushq $0x1
jmp 0x3ec9b
pushq %rax
pushq $0x0
callq 0x2928c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4e0(%rsp), %rax
leaq 0x40(%rsp), %r15
cmpl $0x0, 0xa0(%r15)
je 0x3ed1b
movq 0xe8(%rax), %r14
movq 0x260(%r15), %rsi
movslq 0x58(%r15), %rdx
movslq 0x48(%r15), %rbx
imulq %rbx, %rdx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0x32b0
movl 0x6c(%r15), %esi
movl 0x74(%r15), %edx
imull 0x70(%r15), %esi
cmpl $0x0, 0x9c(%r15)
je 0x3ed56
movq %r14, %rdi
movl %ebx, %ecx
movl $0x1, %r8d
jmp 0x3ed5e
cmpl $0x0, 0x9c(%r15)
je 0x3ed71
movq 0x260(%r15), %rdi
movl 0x70(%r15), %esi
movl 0x48(%r15), %r8d
movl 0x6c(%r15), %edx
movl 0x74(%r15), %ecx
movl 0x98(%r15), %r9d
pushq 0xe8(%rax)
pushq $0x0
callq 0x2928c
addq $0x18, %rsp
jmp 0x3edc9
movq %r14, %rdi
movl %ebx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29414
cmpl $0x0, 0x64(%r15)
je 0x3edd4
movslq 0x48(%r15), %r12
testq %r12, %r12
jle 0x3edc5
movslq 0x54(%r15), %rbx
movq 0x260(%r15), %r14
movslq 0x58(%r15), %r13
movq 0xe8(%rax), %r15
movq %rbx, %rbp
shlq $0x2, %rbp
shlq $0x2, %r13
movl %ebx, %edi
movq %r14, %rsi
movl $0x1, %edx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x29fe0
addq %rbp, %r15
addq %r13, %r14
decq %r12
jne 0x3eda2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x260(%r15), %rdi
movl 0x70(%r15), %esi
movl 0x48(%r15), %r8d
movl 0x6c(%r15), %edx
movl 0x74(%r15), %ecx
movl 0x98(%r15), %r9d
pushq 0xe8(%rax)
pushq $0x1
jmp 0x3ed4b
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rdi, %rbx
movl 0x74(%rdi), %edi
movl 0x98(%rbx), %r9d
movl %edx, 0x6c(%rbx)
movl %esi, 0x70(%rbx)
movl %r9d, %ecx
imull %r9d, %ecx
cmpl $0x0, 0x9c(%rbx)
je 0x3ee3a
imull %r9d, %esi
imull %r9d, %r8d
movl %edi, %eax
cltd
idivl %ecx
movl %eax, %ecx
jmp 0x3ee4f
movl %esi, %eax
cltd
idivl %r9d
movl %eax, %esi
movl %r8d, %eax
cltd
idivl %r9d
imull %edi, %ecx
movl %eax, %r8d
movl %esi, 0x7c(%rbx)
movl %r8d, 0x78(%rbx)
movl %ecx, 0x80(%rbx)
imull %r8d, %esi
imull %ecx, %esi
movl %esi, 0x58(%rbx)
movl %esi, 0x54(%rbx)
movslq 0x48(%rbx), %rax
movslq %esi, %r14
imulq %rax, %r14
movq 0x268(%rbx), %rdi
shlq $0x2, %r14
movq %r14, %rsi
callq 0x3350
movq %rax, 0x268(%rbx)
movq 0x260(%rbx), %rdi
movq %r14, %rsi
callq 0x3350
movq %rax, 0x260(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edx, %edx
js 0x3eed1
movq 0x10(%rsi), %rax
movss 0x1614c(%rip), %xmm0    # 0x55008
movl %edx, %esi
imull %ecx, %edx
movslq %edx, %rdx
mulss (%rdi,%rdx,4), %xmm0
movl (%rax,%rsi,4), %edx
testl %edx, %edx
jns 0x3eebc
retq
movss 0x1612f(%rip), %xmm0    # 0x55008
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x3ef4e
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdx), %r10
movslq %r8d, %rax
movl %esi, %r9d
shlq $0x2, %rax
xorl %r11d, %r11d
movq %rdi, %rbx
movl (%r10,%r11,4), %ebp
testl %ebp, %ebp
js 0x3ef13
imull %r8d, %ebp
movslq %ebp, %r14
movss (%rdi,%r14,4), %xmm0
mulss (%rbx), %xmm0
movss %xmm0, (%rbx)
incq %r11
addq %rax, %rbx
cmpq %r11, %r9
jne 0x3eef6
testl %esi, %esi
setle %sil
testl %ecx, %ecx
sete %cl
orb %sil, %cl
jne 0x3ef4a
movq (%rdx), %rcx
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,4)
jne 0x3ef3f
movl $0x0, (%rdi)
incq %rdx
addq %rax, %rdi
cmpq %rdx, %r9
jne 0x3ef33
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x38(%rsi), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
movss 0x160a6(%rip), %xmm1    # 0x55008
xorl %r8d, %r8d
movl %r8d, %r8d
movslq (%rcx,%r8,4), %r9
testq %r9, %r9
jle 0x3efa8
movq 0x40(%rsi), %rax
movslq (%rax,%r8,4), %r10
movq %r10, %r11
imulq %rdx, %r11
addq %rdi, %r11
xorps %xmm3, %xmm3
xorl %eax, %eax
movss (%r11), %xmm2
ucomiss %xmm3, %xmm2
maxss %xmm3, %xmm2
cmoval %r10d, %eax
incl %r10d
addq %rdx, %r11
movaps %xmm2, %xmm3
decq %r9
jne 0x3ef88
jmp 0x3efad
xorps %xmm2, %xmm2
xorl %eax, %eax
mulss %xmm2, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3efc7
movq 0x18(%rsi), %r8
movslq %eax, %r9
movl (%r8,%r9,4), %r8d
testl %r8d, %r8d
jns 0x3ef65
retq
testq %r8, %r8
je 0x3efc6
movq 0x10(%rsi), %rax
movq 0x40(%rsi), %rcx
movslq (%rcx,%r8,4), %rcx
movl (%rax,%rcx,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x4c8, %rsp            # imm = 0x4C8
movq 0x938(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x990(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movaps 0x970(%rsp), %xmm0
movaps 0x980(%rsp), %xmm1
movups %xmm1, 0x4b0(%rsp)
movups %xmm0, 0x4a0(%rsp)
callq 0x337f6
movq 0x948(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x990(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movaps 0x970(%rsp), %xmm0
movaps 0x980(%rsp), %xmm1
movups %xmm1, 0x4b0(%rsp)
movups %xmm0, 0x4a0(%rsp)
callq 0x337f6
movq 0x958(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x990(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movaps 0x970(%rsp), %xmm0
movaps 0x980(%rsp), %xmm1
movups %xmm1, 0x4b0(%rsp)
movups %xmm0, 0x4a0(%rsp)
callq 0x337f6
movq 0x928(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x990(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movaps 0x970(%rsp), %xmm0
movaps 0x980(%rsp), %xmm1
movups %xmm1, 0x4b0(%rsp)
movups %xmm0, 0x4a0(%rsp)
callq 0x337f6
movq 0x930(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x990(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movaps 0x970(%rsp), %xmm0
movaps 0x980(%rsp), %xmm1
movups %xmm1, 0x4b0(%rsp)
movups %xmm0, 0x4a0(%rsp)
callq 0x337f6
movq 0x940(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x990(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movaps 0x970(%rsp), %xmm0
movaps 0x980(%rsp), %xmm1
movups %xmm1, 0x4b0(%rsp)
movups %xmm0, 0x4a0(%rsp)
callq 0x337f6
movq 0x950(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x990(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movaps 0x970(%rsp), %xmm0
movaps 0x980(%rsp), %xmm1
movups %xmm1, 0x4b0(%rsp)
movups %xmm0, 0x4a0(%rsp)
callq 0x337f6
movq 0x920(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x990(%rsp), %eax
movl %eax, 0x4c0(%rsp)
movaps 0x970(%rsp), %xmm0
movaps 0x980(%rsp), %xmm1
movups %xmm1, 0x4b0(%rsp)
movups %xmm0, 0x4a0(%rsp)
callq 0x337f6
addq $0x4c8, %rsp            # imm = 0x4C8
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x10(%rsp), %rax
movslq %edx, %r10
movss (%rsi,%r10,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x41ca1
jnp 0x41cd1
imull %ecx, %r9d
addl %edx, %r9d
movslq %r9d, %rcx
movss 0x13355(%rip), %xmm0    # 0x55008
subss (%rdi,%rcx,4), %xmm0
movss %xmm0, (%rsi,%rcx,4)
testq %rax, %rax
je 0x41d30
movss (%rdi,%rcx,4), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
jmp 0x41d30
testl %r8d, %r8d
jle 0x41d30
movl %ecx, %ecx
movslq %r9d, %rdx
movl %r8d, %r8d
shlq $0x2, %r10
shlq $0x2, %rdx
xorl %r9d, %r9d
movss 0x13317(%rip), %xmm0    # 0x55008
testq %rax, %rax
sete %r11b
movaps %xmm0, %xmm1
cmpq %r9, %rcx
setne %bl
je 0x41d06
xorps %xmm1, %xmm1
subss (%rdi,%r10), %xmm1
movss %xmm1, (%rsi,%r10)
orb %bl, %r11b
jne 0x41d25
movss (%rdi,%r10), %xmm1
addss (%rax), %xmm1
movss %xmm1, (%rax)
incq %r9
addq %rdx, %r10
cmpq %r9, %r8
jne 0x41cf1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl 0x7c(%rsp), %edi
imull 0x80(%rsp), %edi
testl %edi, %edi
jle 0x41e75
leaq 0x10(%rsp), %rax
movl 0x84(%rax), %r8d
movl 0xfc(%rax), %r9d
addl $0x5, %r9d
movq 0x268(%rax), %r10
xorl %r11d, %r11d
xorl %ecx, %ecx
testl %r8d, %r8d
jle 0x41e6b
movl %r11d, %esi
movl %r8d, %ebx
movl %esi, %eax
cltd
idivl %edi
imull %r9d, %eax
addl $0x4, %eax
imull %edi, %eax
addl %edx, %eax
cltq
movss (%r10,%rax,4), %xmm1
xorl %eax, %eax
ucomiss %xmm0, %xmm1
seta %al
addl %eax, %ecx
addl %edi, %esi
decl %ebx
jne 0x41e42
incl %r11d
cmpl %edi, %r11d
jne 0x41e37
jmp 0x41e77
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/yolo_layer.c
// Function: avg_flipped_yolo
void avg_flipped_yolo(layer l)
{
    int i,j,n,z;
    float *flip = l.output + l.outputs;
    for (j = 0; j < l.h; ++j) {
        for (i = 0; i < l.w/2; ++i) {
            for (n = 0; n < l.n; ++n) {
                for(z = 0; z < l.classes + 4 + 1; ++z){
                    int i1 = z*l.w*l.h*l.n + n*l.w*l.h + j*l.w + i;
                    int i2 = z*l.w*l.h*l.n + n*l.w*l.h + j*l.w + (l.w - i - 1);
                    float swap = flip[i1];
                    flip[i1] = flip[i2];
                    flip[i2] = swap;
                    if(z == 0){
                        flip[i1] = -flip[i1];
                        flip[i2] = -flip[i2];
                    }
                }
            }
        }
    }
    for(i = 0; i < l.outputs; ++i){
        l.output[i] = (l.output[i] + flip[i])/2.;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x2a0(%rsp), %rax
movslq 0x90(%rsp), %rcx
movq %rax, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
leaq (%rax,%rcx,4), %rdx
movl 0xa4(%rsp), %eax
movl %eax, -0x38(%rsp)
testl %eax, %eax
jle 0x41fe5
leaq 0x38(%rsp), %rax
movl 0x70(%rax), %ecx
movl 0x84(%rax), %r8d
movl %ecx, %esi
shrl $0x1f, %esi
addl %ecx, %esi
sarl %esi
movl %esi, -0x1c(%rsp)
movl 0xfc(%rax), %r10d
leal 0x4(%r10), %r11d
xorl %esi, %esi
testl %r11d, %r11d
movl $0x0, %eax
movq %rax, -0x28(%rsp)
cmovlel %esi, %r11d
incl %r11d
movl -0x38(%rsp), %ebp
imull %ecx, %ebp
movl %ebp, %r14d
imull %r8d, %r14d
leal -0x1(%rcx), %eax
movl %eax, -0x34(%rsp)
movaps 0x13181(%rip), %xmm0    # 0x55090
xorl %esi, %esi
movq %rcx, -0x8(%rsp)
movl %esi, -0x20(%rsp)
cmpl $0x2, %ecx
jl 0x41fc0
xorl %r13d, %r13d
movl -0x34(%rsp), %eax
movl %eax, -0x2c(%rsp)
movq -0x28(%rsp), %rax
movl %eax, -0x30(%rsp)
testl %r8d, %r8d
jle 0x41faa
xorl %eax, %eax
movl -0x2c(%rsp), %ecx
movl -0x30(%rsp), %ebx
cmpl $-0x4, %r10d
jl 0x41f9f
movl %ecx, %r15d
movl %ebx, %esi
xorl %r9d, %r9d
movslq %esi, %r12
movss (%rdx,%r12,4), %xmm1
movslq %r15d, %rdi
movss (%rdx,%rdi,4), %xmm2
movss %xmm2, (%rdx,%r12,4)
movss %xmm1, (%rdx,%rdi,4)
testq %r9, %r9
jne 0x41f91
movss (%rdx,%r12,4), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rdx,%r12,4)
movss (%rdx,%rdi,4), %xmm1
xorps %xmm0, %xmm1
movss %xmm1, (%rdx,%rdi,4)
incq %r9
addl %r14d, %esi
addl %r14d, %r15d
cmpq %r9, %r11
jne 0x41f54
incl %eax
addl %ebp, %ebx
addl %ebp, %ecx
cmpl %r8d, %eax
jne 0x41f46
incl %r13d
incl -0x30(%rsp)
decl -0x2c(%rsp)
cmpl -0x1c(%rsp), %r13d
jne 0x41f37
movl -0x20(%rsp), %esi
incl %esi
movq -0x8(%rsp), %rcx
movq -0x28(%rsp), %rax
addl %ecx, %eax
movq %rax, -0x28(%rsp)
addl %ecx, -0x34(%rsp)
cmpl -0x38(%rsp), %esi
jne 0x41f16
movq -0x18(%rsp), %rsi
testl %esi, %esi
movq -0x10(%rsp), %rcx
jle 0x42018
xorl %eax, %eax
movss 0x13267(%rip), %xmm0    # 0x55264
movss (%rcx,%rax,4), %xmm1
addss (%rdx,%rax,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rcx,%rax,4)
incq %rax
cmpq %rax, %rsi
jne 0x41ffd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x20(%rsp), %rax
testq %rax, %rax
jle 0x42b5c
leaq 0x8(%rsp), %rdx
movq 0x20(%rdx), %rcx
movslq 0x1c(%rdx), %rdx
xorl %esi, %esi
xorps %xmm0, %xmm0
movsd 0x15edc(%rip), %xmm1    # 0x589d0
testl %edx, %edx
jle 0x42b54
movq (%rcx,%rsi,8), %r8
xorl %r9d, %r9d
movss (%r8,%r9,4), %xmm2
testl %edi, %edi
je 0x42b28
ucomiss %xmm0, %xmm2
jne 0x42b10
jnp 0x42b3a
movss 0x4(%r8,%r9,4), %xmm2
ucomiss %xmm0, %xmm2
jne 0x42b1e
jnp 0x42b4b
movl $0x0, (%r8,%r9,4)
jmp 0x42b4b
ucomiss %xmm0, %xmm2
jne 0x42b2f
jnp 0x42b42
movl $0x0, 0x4(%r8,%r9,4)
jmp 0x42b4b
movsd %xmm1, (%r8,%r9,4)
jmp 0x42b4b
movl $0x3f800000, 0x4(%r8,%r9,4) # imm = 0x3F800000
addq $0x2, %r9
cmpq %rdx, %r9
jl 0x42aff
incq %rsi
cmpq %rax, %rsi
jne 0x42af4
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/captcha.c
// Function: test_captcha
void test_captcha(char *cfgfile, char *weightfile, char *filename)
{
    network *net = load_network(cfgfile, weightfile, 0);
    set_batch_network(net, 1);
    srand(2222222);
    int i = 0;
    char **names = get_labels("/data/captcha/reimgs.labels.list");
    char buff[256];
    char *input = buff;
    int indexes[26];
    while(1){
        if(filename){
            strncpy(input, filename, 256);
        }else{
            //printf("Enter Image Path: ");
            //fflush(stdout);
            input = fgets(input, 256, stdin);
            if(!input) return;
            strtok(input, "\n");
        }
        image im = load_image_color(input, net->w, net->h);
        float *X = im.data;
        float *predictions = network_predict(net, X);
        top_predictions(net, 26, indexes);
        //printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
        for(i = 0; i < 26; ++i){
            int index = indexes[i];
            if(i != 0) printf(", ");
            printf("%s %f", names[index], predictions[index]);
        }
        printf("\n");
        fflush(stdout);
        free_image(im);
        if (filename) break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, %rbx
xorl %edx, %edx
callq 0x316bc
movq %rax, 0x20(%rsp)
movq %rax, %rdi
movl $0x1, %esi
callq 0x320a7
movl $0x21e88e, %edi         # imm = 0x21E88E
callq 0x3220
leaq 0x170c9(%rip), %rdi     # 0x59ffc
callq 0x2d26c
movq %rax, %r15
leaq 0xc0(%rsp), %rbp
leaq 0x1715f(%rip), %r13     # 0x5a0a9
leaq 0x17186(%rip), %r12     # 0x5a0d7
movq %rbx, 0x28(%rsp)
testq %rbx, %rbx
je 0x42f6d
movl $0x100, %edx            # imm = 0x100
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x3080
jmp 0x42f9f
movq 0x29064(%rip), %rax     # 0x6bfd8
movq (%rax), %rdx
movq %rbp, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x3230
testq %rax, %rax
je 0x43060
movq %rax, %rbp
movq %rax, %rdi
leaq 0x176c7(%rip), %rsi     # 0x5a661
callq 0x33b0
movq 0x20(%rsp), %r14
movl 0x90(%r14), %ecx
movl 0x94(%r14), %edx
leaq 0x38(%rsp), %rdi
movq %rbp, 0x30(%rsp)
movq %rbp, %rsi
callq 0x16ac9
movq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x32690
movq %rax, %rbx
movq %r14, %rdi
movl $0x1a, %esi
leaq 0x50(%rsp), %rdx
callq 0x32679
xorl %r14d, %r14d
movslq 0x50(%rsp,%r14,4), %rbp
testq %r14, %r14
je 0x42ffd
movq %r12, %rdi
xorl %eax, %eax
callq 0x3160
movq (%r15,%rbp,8), %rsi
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%rbp,4), %xmm0
movq %r13, %rdi
movb $0x1, %al
callq 0x3160
incq %r14
cmpq $0x1a, %r14
jne 0x42fe9
movl $0xa, %edi
callq 0x3060
movq 0x28fa3(%rip), %rax     # 0x6bfd0
movq (%rax), %rdi
callq 0x3310
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x1657b
movq 0x28(%rsp), %rbx
testq %rbx, %rbx
movq 0x30(%rsp), %rbp
je 0x42f56
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edi
jle 0x43310
cmpl $0x4, %edi
jne 0x4327f
xorl %ebx, %ebx
jmp 0x4328e
movq 0x20(%rsi), %rbx
cmpl $0x6, %edi
jb 0x4328e
movq 0x28(%rsi), %r14
jmp 0x43291
xorl %r14d, %r14d
movq 0x18(%rsi), %r15
movq 0x10(%rsi), %r12
leaq 0x17174(%rip), %rsi     # 0x5a414
movq %r12, %rdi
callq 0x3260
testl %eax, %eax
je 0x4331a
leaq 0x17fa2(%rip), %rsi     # 0x5b255
movq %r12, %rdi
callq 0x3260
testl %eax, %eax
je 0x432de
leaq 0x14d9e(%rip), %rsi     # 0x58064
movq %r12, %rdi
callq 0x3260
testl %eax, %eax
je 0x432f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42ef5
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x43072
movq %rsi, %rdi
callq 0x9205
jmp 0x432d2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x42b5d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/lsd.c
// Function: slerp
void slerp(float *start, float *end, float s, int n, float *out)
{
    float omega = acos(dot_cpu(n, start, 1, end, 1));
    float so = sin(omega);
    fill_cpu(n, 0, out, 1);
    axpy_cpu(n, sin((1-s)*omega)/so, start, 1, out, 1);
    axpy_cpu(n, sin(s*omega)/so, end, 1, out, 1);

    float mag = mag_array(out, n);
    scale_array(out, n, 1./mag);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %edx, %ebx
movss %xmm0, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %edi
movq %r12, %rsi
movl $0x1, %edx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x2a280
cvtss2sd %xmm0, %xmm0
callq 0x3200
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
cvtss2sd %xmm0, %xmm0
callq 0x33d0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movl %ebx, %edi
movq %r14, %rsi
movl $0x1, %edx
callq 0x29d83
movss 0x11c6c(%rip), %xmm0    # 0x55008
subss 0xc(%rsp), %xmm0
mulss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x33d0
cvtss2sd 0x10(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movl %ebx, %edi
movq %r12, %rsi
movl $0x1, %edx
movq %r14, %rcx
movl $0x1, %r8d
callq 0x29d31
movss 0x8(%rsp), %xmm0
mulss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x33d0
divsd 0x10(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movl %ebx, %edi
movq %r15, %rsi
movl $0x1, %edx
movq %r14, %rcx
movl $0x1, %r8d
callq 0x29d31
movq %r14, %rdi
movl %ebx, %esi
callq 0xf92d
movss 0x11be2(%rip), %xmm1    # 0x55008
divss %xmm0, %xmm1
movq %r14, %rdi
movl %ebx, %esi
movaps %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf95e
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/lsd.c
// Function: random_unit_vector_image
image random_unit_vector_image(int w, int h, int c)
{
    image im = make_image(w, h, c);
    int i;
    for(i = 0; i < im.w*im.h*im.c; ++i){
        im.data[i] = rand_normal();
    }
    float mag = mag_array(im.data, im.w*im.h*im.c);
    scale_array(im.data, im.w*im.h*im.c, 1./mag);
    return im;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x15d43
movl 0x4(%rbx), %esi
imull (%rbx), %esi
imull 0x8(%rbx), %esi
testl %esi, %esi
jle 0x4348d
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xfb17
movq 0x10(%rbx), %rdi
movss %xmm0, (%rdi,%r14,4)
incq %r14
movslq (%rbx), %rax
movslq 0x4(%rbx), %rcx
imulq %rax, %rcx
movslq 0x8(%rbx), %rsi
imulq %rcx, %rsi
cmpq %rsi, %r14
jl 0x4345f
jmp 0x43491
movq 0x10(%rbx), %rdi
callq 0xf92d
movq 0x10(%rbx), %rdi
movl 0x4(%rbx), %esi
imull (%rbx), %esi
imull 0x8(%rbx), %esi
movss 0x11b5c(%rip), %xmm1    # 0x55008
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
callq 0xf95e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/lsd.c
// Function: test_dcgan
void test_dcgan(char *cfgfile, char *weightfile)
{
    network *net = load_network(cfgfile, weightfile, 0);
    set_batch_network(net, 1);
    srand(2222222);

    clock_t time;
    char buff[256];
    char *input = buff;
    int imlayer = 0;

    imlayer = net->n-1;

    while(1){
        image im = make_image(net->w, net->h, net->c);
        int i;
        for(i = 0; i < im.w*im.h*im.c; ++i){
            im.data[i] = rand_normal();
        }
        //float mag = mag_array(im.data, im.w*im.h*im.c);
        //scale_array(im.data, im.w*im.h*im.c, 1./mag);

        float *X = im.data;
        time=clock();
        network_predict(net, X);
        image out = get_network_image_layer(net, imlayer);
        //yuv_to_rgb(out);
        normalize_image(out);
        printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
        save_image(out, "out");
        show_image(out, "out", 0);

        free_image(im);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
xorl %edx, %edx
callq 0x316bc
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
callq 0x320a7
movl $0x21e88e, %edi         # imm = 0x21E88E
callq 0x3220
movl (%rbx), %ebp
decl %ebp
leaq 0x50(%rsp), %r13
leaq 0x17b33(%rip), %r14     # 0x5b316
movl 0x90(%rbx), %edx
movl 0x94(%rbx), %esi
movl 0x98(%rbx), %ecx
leaq 0x20(%rsp), %rdi
callq 0x15d43
movl 0x24(%rsp), %eax
imull 0x20(%rsp), %eax
imull 0x28(%rsp), %eax
testl %eax, %eax
jle 0x43847
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xfb17
movq 0x30(%rsp), %r15
movss %xmm0, (%r15,%r12,4)
incq %r12
movslq 0x20(%rsp), %rax
movslq 0x24(%rsp), %rcx
imulq %rax, %rcx
movslq 0x28(%rsp), %rax
imulq %rcx, %rax
cmpq %rax, %r12
jl 0x43814
jmp 0x4384c
movq 0x30(%rsp), %r15
callq 0x3120
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x32690
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x32548
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x1807b
callq 0x3120
subq %r12, %rax
movq %rax, %rdi
callq 0xf0bf
cvtss2sd %xmm0, %xmm0
leaq 0x1687b(%rip), %rdi     # 0x5a11c
movq %r13, %rsi
movb $0x1, %al
callq 0x3160
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x18301
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x40f9
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x1657b
jmp 0x437e3
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/lsd.c
// Function: set_network_alpha_beta
void set_network_alpha_beta(network *net, float alpha, float beta)
{
    int i;
    for(i = 0; i < net->n; ++i){
        if(net->layers[i].type == SHORTCUT){
            net->layers[i].alpha = alpha;
            net->layers[i].beta = beta;
        }
    }
}

// Assembly:
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0x43939
movq 0x20(%rdi), %rax
imulq $0x4a0, %rcx, %rcx      # imm = 0x4A0
xorl %edx, %edx
cmpl $0xd, (%rax,%rdx)
jne 0x4392d
movss %xmm0, 0x134(%rax,%rdx)
movss %xmm1, 0x138(%rax,%rdx)
addq $0x4a0, %rdx            # imm = 0x4A0
cmpq %rdx, %rcx
jne 0x43915
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/super.c
// Function: test_super
void test_super(char *cfgfile, char *weightfile, char *filename)
{
    network *net = load_network(cfgfile, weightfile, 0);
    set_batch_network(net, 1);
    srand(2222222);

    clock_t time;
    char buff[256];
    char *input = buff;
    while(1){
        if(filename){
            strncpy(input, filename, 256);
        }else{
            printf("Enter Image Path: ");
            fflush(stdout);
            input = fgets(input, 256, stdin);
            if(!input) return;
            strtok(input, "\n");
        }
        image im = load_image_color(input, 0, 0);
        resize_network(net, im.w, im.h);
        printf("%d %d\n", im.w, im.h);

        float *X = im.data;
        time=clock();
        network_predict(net, X);
        image out = get_network_image(net);
        printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
        save_image(out, "out");
        show_image(out, "out", 0);

        free_image(im);
        if (filename) break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdx, %rbx
xorl %edx, %edx
callq 0x316bc
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0x320a7
movl $0x21e88e, %edi         # imm = 0x21E88E
callq 0x3220
leaq 0x50(%rsp), %r13
leaq 0x17185(%rip), %r12     # 0x5b316
testq %rbx, %rbx
je 0x441a8
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3080
jmp 0x441f7
leaq 0x15f93(%rip), %rdi     # 0x5a142
xorl %eax, %eax
callq 0x3160
movq 0x27e13(%rip), %rax     # 0x6bfd0
movq (%rax), %rdi
callq 0x3310
movq 0x27e0c(%rip), %rax     # 0x6bfd8
movq (%rax), %rdx
movq %r13, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x3230
testq %rax, %rax
je 0x442d1
movq %rax, %r13
movq %rax, %rdi
leaq 0x1646f(%rip), %rsi     # 0x5a661
callq 0x33b0
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x16ac9
movl 0x20(%rsp), %esi
movl 0x24(%rsp), %edx
movq %r14, %rdi
callq 0x321b7
movl 0x20(%rsp), %esi
movl 0x24(%rsp), %edx
leaq 0x15765(%rip), %rdi     # 0x5998c
xorl %eax, %eax
callq 0x3160
movq 0x30(%rsp), %r15
callq 0x3120
movq %rax, %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x32690
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x325ae
callq 0x3120
subq %rbp, %rax
movq %rax, %rdi
callq 0xf0bf
cvtss2sd %xmm0, %xmm0
leaq 0x15eae(%rip), %rdi     # 0x5a11c
movq %r13, %rsi
movb $0x1, %al
callq 0x3160
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x18301
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
xorl %esi, %esi
callq 0x40f9
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x1657b
testq %rbx, %rbx
je 0x44191
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/super.c
// Function: run_super
void run_super(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;
    int clear = find_arg(argc, argv, "-clear");
    if(0==strcmp(argv[2], "train")) train_super(cfg, weights, clear);
    else if(0==strcmp(argv[2], "test")) test_super(cfg, weights, filename);
    /*
    else if(0==strcmp(argv[2], "valid")) validate_super(cfg, weights);
    */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
cmpl $0x3, %edi
jle 0x44385
cmpl $0x4, %edi
jne 0x44300
xorl %ebx, %ebx
jmp 0x4430f
movq 0x20(%r15), %rbx
cmpl $0x6, %edi
jb 0x4430f
movq 0x28(%r15), %r14
jmp 0x44312
xorl %r14d, %r14d
movq 0x18(%r15), %r12
leaq 0x15e38(%rip), %rdx     # 0x5a155
movq %r15, %rsi
callq 0xeca2
movl %eax, %ebp
movq 0x10(%r15), %r15
leaq 0x160e2(%rip), %rsi     # 0x5a414
movq %r15, %rdi
callq 0x3260
testl %eax, %eax
je 0x4435a
leaq 0x16f10(%rip), %rsi     # 0x5b255
movq %r15, %rdi
callq 0x3260
testl %eax, %eax
je 0x4436f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x43d64
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x44150
movq %r15, %rdi
callq 0x9249
jmp 0x44351
nop