LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/gru_layer.c
// Function: update_gru_layer
void update_gru_layer(layer l, update_args a)
{
    update_connected_layer(*(l.ur), a);
    update_connected_layer(*(l.uz), a);
    update_connected_layer(*(l.uh), a);
    update_connected_layer(*(l.wr), a);
    update_connected_layer(*(l.wz), a);
    update_connected_layer(*(l.wh), a);
}

// Assembly:
subq $0x4c8, %rsp            # imm = 0x4C8
movq 0x908(%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 0x31838
movq 0x8f8(%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 0x31838
movq 0x918(%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 0x31838
movq 0x900(%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 0x31838
movq 0x8f0(%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 0x31838
movq 0x910(%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 0x31838
addq $0x4c8, %rsp            # imm = 0x4C8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/batchnorm_layer.c
// Function: backward_batchnorm_layer
void backward_batchnorm_layer(layer l, network net)
{
    if(!net.train){
        l.mean = l.rolling_mean;
        l.variance = l.rolling_variance;
    }
    backward_bias(l.bias_updates, l.delta, l.batch, l.out_c, l.out_w*l.out_h);
    backward_scale_cpu(l.x_norm, l.delta, l.batch, l.out_c, l.out_w*l.out_h, l.scale_updates);

    scale_bias(l.delta, l.scales, l.batch, l.out_c, l.out_h*l.out_w);

    mean_delta_cpu(l.delta, l.variance, l.batch, l.out_c, l.out_w*l.out_h, l.mean_delta);
    variance_delta_cpu(l.x, l.delta, l.mean, l.variance, l.batch, l.out_c, l.out_w*l.out_h, l.variance_delta);
    normalize_delta_cpu(l.x, l.mean, l.variance, l.mean_delta, l.variance_delta, l.batch, l.out_c, l.out_w*l.out_h, l.delta);
    if(l.type == BATCHNORM) copy_cpu(l.outputs*l.batch, l.delta, 1, net.delta, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x60(%rsp), %rbx
cmpl $0x0, 0x5f8(%rsp)
jne 0x3a59b
movups 0x2b0(%rbx), %xmm0
movups %xmm0, 0x290(%rbx)
movq 0x238(%rbx), %rdi
movq 0x260(%rbx), %r13
movl 0x48(%rbx), %ebp
movl 0x78(%rbx), %r15d
movl 0x80(%rbx), %r14d
imull 0x7c(%rbx), %r15d
movq %r13, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x10a7a
movq 0x248(%rbx), %r9
movq 0x2c8(%rbx), %rdi
movq %r13, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x3a6d6
movq 0x240(%rbx), %rsi
movq %r13, %rdi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x10a08
movq 0x298(%rbx), %r12
movq 0x2a0(%rbx), %r9
movq %r9, 0x20(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x3a768
movq 0x2c0(%rbx), %rdi
movq %rdi, 0x18(%rsp)
movq 0x290(%rbx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x2a8(%rbx), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rsi
movq %r12, %rcx
movl %ebp, %r8d
movl %r14d, %r9d
pushq %rax
pushq %r15
callq 0x3a895
addq $0x8, %rsp
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r12, %rdx
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %r8
movl %ebp, %r9d
pushq %r13
pushq %r15
pushq %r14
callq 0x3a9bf
addq $0x20, %rsp
cmpl $0x13, (%rbx)
jne 0x3a6c7
leaq 0x500(%rsp), %rax
imull 0x58(%rbx), %ebp
movq 0xe8(%rax), %rcx
movl %ebp, %edi
movq %r13, %rsi
movl $0x1, %edx
movl $0x1, %r8d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2879c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/batchnorm_layer.c
// Function: backward_scale_cpu
void backward_scale_cpu(float *x_norm, float *delta, int batch, int n, int size, float *scale_updates)
{
    int i,b,f;
    for(f = 0; f < n; ++f){
        float sum = 0;
        for(b = 0; b < batch; ++b){
            for(i = 0; i < size; ++i){
                int index = i + size*(f + n*b);
                sum += delta[index] * x_norm[index];
            }
        }
        scale_updates[f] += sum;
    }
}

// Assembly:
testl %ecx, %ecx
jle 0x3a767
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %eax
movl %r8d, %ecx
movl %edx, %r10d
leaq (,%rcx,4), %r11
movq %rcx, %rbx
imulq %rax, %rbx
shlq $0x2, %rbx
xorl %r14d, %r14d
xorps %xmm0, %xmm0
testl %edx, %edx
jle 0x3a743
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
testl %r8d, %r8d
jle 0x3a735
xorl %ebp, %ebp
movss (%r15,%rbp,4), %xmm1
mulss (%r12,%rbp,4), %xmm1
addss %xmm1, %xmm0
incq %rbp
cmpq %rbp, %rcx
jne 0x3a71d
incq %r13
addq %rbx, %r12
addq %rbx, %r15
cmpq %r10, %r13
jne 0x3a716
addss (%r9,%r14,4), %xmm0
movss %xmm0, (%r9,%r14,4)
incq %r14
addq %r11, %rdi
addq %r11, %rsi
cmpq %rax, %r14
jne 0x3a706
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %ecx, %ecx
jle 0x3a894
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %ecx, %r10d
movl %edx, %r12d
movl %r8d, %r15d
imull %r8d, %r14d
xorl %r11d, %r11d
movss 0x1d165(%rip), %xmm3    # 0x57904
xorpd %xmm4, %xmm4
movsd 0x1bdfd(%rip), %xmm5    # 0x565a8
xorl %r13d, %r13d
movl %edx, 0x4(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %r10, 0x8(%rsp)
movl $0x0, (%rbx,%r13,4)
testl %edx, %edx
jle 0x3a805
movl %r11d, %eax
xorl %ecx, %ecx
testl %ebp, %ebp
jle 0x3a7fa
movslq %eax, %r8
leaq (%rdi,%r8,4), %r9
movss (%rbx,%r13,4), %xmm0
xorl %r8d, %r8d
addss (%r9,%r8,4), %xmm0
movss %xmm0, (%rbx,%r13,4)
incq %r8
cmpq %r8, %r15
jne 0x3a7e6
incq %rcx
addl %r14d, %eax
cmpq %r12, %rcx
jne 0x3a7d2
movss (%rsi,%r13,4), %xmm0
addss %xmm3, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm4, %xmm0
jb 0x3a81f
sqrtsd %xmm0, %xmm0
jmp 0x3a855
movq %r11, 0x20(%rsp)
callq 0x3470
movsd 0x1bd77(%rip), %xmm5    # 0x565a8
xorpd %xmm4, %xmm4
movss 0x1d0c7(%rip), %xmm3    # 0x57904
movq 0x20(%rsp), %r11
movq 0x8(%rsp), %r10
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rsp), %edx
movapd %xmm5, %xmm1
xorps %xmm2, %xmm2
cvtss2sd (%rbx,%r13,4), %xmm2
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movss %xmm0, (%rbx,%r13,4)
incq %r13
addl %ebp, %r11d
cmpq %r10, %r13
jne 0x3a7c1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a9b0
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 0x3a940
movl %r11d, %eax
xorl %ecx, %ecx
testl %r10d, %r10d
jle 0x3a936
movslq %eax, %r8
leaq (%rsi,%r8,4), %rdx
leaq (%rdi,%r8,4), %r8
xorl %r9d, %r9d
movss (%r8,%r9,4), %xmm0
subss (%r15,%r13,4), %xmm0
mulss (%rdx,%r9,4), %xmm0
addss (%r14,%r13,4), %xmm0
movss %xmm0, (%r14,%r13,4)
incq %r9
cmpq %r9, %r12
jne 0x3a910
incq %rcx
addl %ebx, %eax
cmpq %rbp, %rcx
jne 0x3a8fd
movq 0x28(%rsp), %rax
movss (%rax,%r13,4), %xmm0
addss 0x1cfb1(%rip), %xmm0    # 0x57904
cvtss2sd %xmm0, %xmm0
movsd 0x1d311(%rip), %xmm1    # 0x57c70
movq %r11, 0x30(%rsp)
callq 0x3120
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 0x1d2ea(%rip), %xmm0    # 0x57c78
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%r14,%r13,4)
incq %r13
addl %r10d, %r11d
cmpq 0x10(%rsp), %r13
jne 0x3a8e9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ab83
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 %r9d, %eax
movq %rax, 0x20(%rsp)
movl %r10d, %eax
movq %rax, 0x38(%rsp)
movl %edi, %r9d
movl %edi, %eax
imull %r10d, %eax
movl %eax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movss 0x1ced2(%rip), %xmm4    # 0x57904
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 0x3ab62
movq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
xorl %r13d, %r13d
testl %edi, %edi
jle 0x3ab49
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 0x3aabb
sqrtsd %xmm0, %xmm0
jmp 0x3aaf3
movsd %xmm6, 0x60(%rsp)
callq 0x3470
movsd 0x60(%rsp), %xmm6
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %r10
xorpd %xmm5, %xmm5
movss 0x1ce22(%rip), %xmm4    # 0x57904
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 0x3aa98
incq %r13
movl 0xa8(%rsp), %edi
addl %edi, 0xc(%rsp)
cmpq 0x38(%rsp), %r13
jne 0x3aa69
movq 0x28(%rsp), %r10
incq %r10
movq 0x10(%rsp), %rax
addl 0x18(%rsp), %eax
movq %rax, 0x10(%rsp)
cmpq 0x20(%rsp), %r10
jne 0x3aa4a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl %esi, 0x70(%rdi)
movl %edx, 0x6c(%rdi)
imull %esi, %edx
imull 0x84(%rdi), %edx
movl 0xfc(%rdi), %eax
movl 0x100(%rdi), %ecx
addl %ecx, %eax
incl %eax
imull %edx, %eax
movl %eax, 0x58(%rdi)
movl %eax, 0x54(%rdi)
movq 0x268(%rdi), %rdi
movslq 0x48(%rbx), %rcx
movslq %eax, %rsi
imulq %rcx, %rsi
shlq $0x2, %rsi
callq 0x3360
movq %rax, 0x268(%rbx)
movq 0x260(%rbx), %rdi
movslq 0x48(%rbx), %rax
movslq 0x58(%rbx), %rsi
imulq %rax, %rsi
shlq $0x2, %rsi
callq 0x3360
movq %rax, 0x260(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x70(%rsp), %r12d
cvtsi2ss %r8d, %xmm1
movl 0x60(%rsp), %ebp
movslq %ecx, %r13
addss (%rdi,%r13,4), %xmm1
cvtsi2ss %ebp, %xmm0
divss %xmm0, %xmm1
movaps %xmm1, %xmm2
xorps %xmm0, %xmm0
cvtsi2ss %r9d, %xmm0
leal (%r12,%r13), %eax
cltq
xorps %xmm1, %xmm1
cvtsi2ssl 0x68(%rsp), %xmm1
addss (%rdi,%rax,4), %xmm0
divss %xmm1, %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps %xmm2, 0x10(%rsp)
leal (%r13,%r12,2), %eax
cltq
xorps %xmm0, %xmm0
cvtss2sd (%rdi,%rax,4), %xmm0
callq 0x34e0
leal (%r14,%r14), %eax
cltq
xorps %xmm1, %xmm1
cvtss2sd (%rbx,%rax,4), %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps %xmm0, (%rsp)
leal (%r12,%r12,2), %eax
addl %r13d, %eax
cltq
xorps %xmm0, %xmm0
cvtss2sd (%r15,%rax,4), %xmm0
callq 0x34e0
leal 0x1(,%r14,2), %eax
cltq
xorps %xmm1, %xmm1
cvtss2sd (%rbx,%rax,4), %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl 0x68(%rsp), %xmm2
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps 0x10(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/region_layer.c
// Function: delta_region_box
float delta_region_box(box truth, float *x, float *biases, int n, int index, int i, int j, int w, int h, float *delta, float scale, int stride)
{
    box pred = get_region_box(x, biases, n, index, i, j, w, h, stride);
    float iou = box_iou(pred, truth);

    float tx = (truth.x*w - i);
    float ty = (truth.y*h - j);
    float tw = log(truth.w*w / biases[2*n]);
    float th = log(truth.h*h / biases[2*n + 1]);

    delta[index + 0*stride] = scale * (tx - x[index + 0*stride]);
    delta[index + 1*stride] = scale * (ty - x[index + 1*stride]);
    delta[index + 2*stride] = scale * (tw - x[index + 2*stride]);
    delta[index + 3*stride] = scale * (th - x[index + 3*stride]);
    return iou;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movss %xmm2, 0xc(%rsp)
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
movaps %xmm1, 0x30(%rsp)
movl 0x90(%rsp), %r11d
movl 0x98(%rsp), %r10d
movl 0xa8(%rsp), %eax
subq $0x8, %rsp
pushq %rax
pushq %r10
pushq %r11
callq 0x3bb20
addq $0x20, %rsp
movaps 0x20(%rsp), %xmm2
movaps 0x10(%rsp), %xmm3
callq 0x36754
movl 0x90(%rsp), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %r13d, %xmm0
movaps 0x20(%rsp), %xmm2
mulss %xmm1, %xmm2
movl 0x98(%rsp), %eax
xorps %xmm3, %xmm3
cvtsi2ss %eax, %xmm3
movss %xmm3, 0x4(%rsp)
subss %xmm0, %xmm2
movaps %xmm2, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %r12d, %xmm0
movaps 0x30(%rsp), %xmm2
mulss %xmm3, %xmm2
subss %xmm0, %xmm2
movaps %xmm2, 0x30(%rsp)
movaps 0x10(%rsp), %xmm0
mulss %xmm1, %xmm0
leal (%r15,%r15), %eax
cltq
divss (%r14,%rax,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x31e0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movaps 0x40(%rsp), %xmm0
mulss 0x4(%rsp), %xmm0
leal 0x1(%r15,%r15), %eax
cltq
divss (%r14,%rax,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x31e0
cvtsd2ss %xmm0, %xmm0
movslq %ebp, %rax
movaps 0x20(%rsp), %xmm2
subss (%rbx,%rax,4), %xmm2
movss 0xc(%rsp), %xmm1
mulss %xmm1, %xmm2
movq 0xa0(%rsp), %rdx
movss %xmm2, (%rdx,%rax,4)
movl 0xa8(%rsp), %esi
leal (%rsi,%rax), %ecx
movslq %ecx, %rcx
movaps 0x30(%rsp), %xmm2
subss (%rbx,%rcx,4), %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%rdx,%rcx,4)
leal (%rax,%rsi,2), %ecx
movslq %ecx, %rcx
movss 0x10(%rsp), %xmm2
subss (%rbx,%rcx,4), %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%rdx,%rcx,4)
leal (%rsi,%rsi,2), %ecx
addl %eax, %ecx
movslq %ecx, %rax
subss (%rbx,%rax,4), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%rdx,%rax,4)
movss 0x8(%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3beac
testl %ecx, %ecx
js 0x3bee8
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 0x171c0(%rip), %xmm2    # 0x53008
movaps %xmm2, %xmm1
movl %ecx, %r13d
imull %r10d, %ecx
addl %edx, %ecx
movslq %ecx, %rcx
mulss (%rdi,%rcx,4), %xmm1
movslq (%r11,%r13,4), %rax
movslq (%r9,%rax,4), %rbp
testq %rbp, %rbp
jle 0x3be91
movslq (%rbx,%rax,4), %rax
imulq %r14, %rax
addq %r15, %rax
shlq $0x2, %rax
xorps %xmm3, %xmm3
subss (%rdi,%rax), %xmm3
mulss %xmm0, %xmm3
movss %xmm3, (%rsi,%rax)
addq %r12, %rax
decq %rbp
jne 0x3be78
movaps %xmm2, %xmm3
subss (%rdi,%rcx,4), %xmm3
mulss %xmm0, %xmm3
movss %xmm3, (%rsi,%rcx,4)
movl (%r8,%r13,4), %ecx
testl %ecx, %ecx
jns 0x3be4b
jmp 0x3bef0
movslq %edx, %r9
cmpl $0x0, 0x48(%rsp)
je 0x3bf08
movss (%rsi,%r9,4), %xmm1
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x3bec6
jnp 0x3bf08
imull %ecx, %r10d
addl %edx, %r10d
movslq %r10d, %rax
movss 0x17130(%rip), %xmm1    # 0x53008
subss (%rdi,%rax,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rsi,%rax,4)
jmp 0x3befd
movss 0x17118(%rip), %xmm1    # 0x53008
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 0x3befd
movl %ecx, %ecx
movslq %r10d, %rdx
movl %r8d, %r8d
shlq $0x2, %r9
shlq $0x2, %rdx
xorl %r10d, %r10d
movss 0x170e0(%rip), %xmm1    # 0x53008
movaps %xmm1, %xmm2
cmpq %r10, %rcx
je 0x3bf33
xorps %xmm2, %xmm2
subss (%rdi,%r9), %xmm2
mulss %xmm0, %xmm2
movss %xmm2, (%rsi,%r9)
jne 0x3bf53
movss (%rdi,%r9), %xmm2
addss (%rax), %xmm2
movss %xmm2, (%rax)
incq %r10
addq %rdx, %r9
cmpq %r10, %r8
jne 0x3bf28
jmp 0x3befd
// File: /workspace/github_c_makefile_star2_O1/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 %edx, %r10d
cvtsi2ss %r8d, %xmm0
cvtsi2ss %edx, %xmm1
movaps %xmm0, %xmm4
cvtsi2ss %r9d, %xmm2
divss %xmm1, %xmm4
cvtsi2ss %ecx, %xmm3
movaps %xmm2, %xmm5
divss %xmm3, %xmm5
ucomiss %xmm4, %xmm5
jbe 0x3c001
imull %r8d, %ecx
movl %ecx, %eax
cltd
idivl %r10d
movl %r8d, %ecx
jmp 0x3c010
imull %r9d, %r10d
movl %r10d, %eax
cltd
idivl %ecx
movl %eax, %ecx
movl %r9d, %eax
testl %esi, %esi
jle 0x3c120
xorps %xmm5, %xmm5
cvtsi2sd %r8d, %xmm5
movl 0x8(%rsp), %edx
subl %ecx, %r8d
xorps %xmm4, %xmm4
cvtsi2sd %r8d, %xmm4
movsd 0x170e9(%rip), %xmm7    # 0x53120
cvtsi2ss %ecx, %xmm8
mulsd %xmm7, %xmm4
divsd %xmm5, %xmm4
movaps %xmm8, %xmm5
divss %xmm0, %xmm5
cvtss2sd %xmm5, %xmm5
cvtsi2sd %r9d, %xmm9
subl %eax, %r9d
cvtsi2sd %r9d, %xmm6
mulsd %xmm7, %xmm6
divsd %xmm9, %xmm6
xorps %xmm9, %xmm9
cvtsi2ss %eax, %xmm9
movaps %xmm9, %xmm7
divss %xmm2, %xmm7
cvtss2sd %xmm7, %xmm7
divss %xmm8, %xmm0
divss %xmm9, %xmm2
movl %esi, %eax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
xorps %xmm8, %xmm8
cvtss2sd (%rdi,%rcx), %xmm8
subsd %xmm4, %xmm8
divsd %xmm5, %xmm8
cvtsd2ss %xmm8, %xmm8
xorps %xmm9, %xmm9
cvtss2sd 0x4(%rdi,%rcx), %xmm9
subsd %xmm6, %xmm9
divsd %xmm7, %xmm9
xorps %xmm10, %xmm10
cvtsd2ss %xmm9, %xmm10
movss 0x8(%rdi,%rcx), %xmm9
mulss %xmm0, %xmm9
movss 0xc(%rdi,%rcx), %xmm11
mulss %xmm2, %xmm11
testl %edx, %edx
jne 0x3c0f8
mulss %xmm1, %xmm8
mulss %xmm1, %xmm9
mulss %xmm3, %xmm10
mulss %xmm3, %xmm11
movss %xmm8, (%rdi,%rcx)
movss %xmm10, 0x4(%rdi,%rcx)
movss %xmm9, 0x8(%rdi,%rcx)
movss %xmm11, 0xc(%rdi,%rcx)
addq $0x30, %rcx
cmpq %rcx, %rax
jne 0x3c091
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl 0x80(%rsp), %esi
imull 0x7c(%rsp), %esi
testl %esi, %esi
jle 0x3c748
leaq 0x10(%rsp), %rax
movl 0x84(%rax), %edi
movl 0xfc(%rax), %ecx
movl 0x100(%rax), %r8d
leal (%r8,%rcx), %r9d
incl %r9d
movq 0x268(%rax), %r10
xorl %r11d, %r11d
testl %edi, %edi
jle 0x3c740
movl %r11d, %ecx
movl %edi, %ebx
movl %ecx, %eax
cltd
idivl %esi
imull %r9d, %eax
addl %r8d, %eax
imull %esi, %eax
addl %edx, %eax
cltq
movl $0x0, (%r10,%rax,4)
addl %esi, %ecx
decl %ebx
jne 0x3c71f
incl %r11d
cmpl %esi, %r11d
jne 0x3c716
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3c957
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 0x32c0
movl 0x6c(%r12), %esi
movl 0x74(%r12), %edx
imull 0x70(%r12), %esi
cmpl $0x0, 0x9c(%r12)
je 0x3c9b6
movq %r14, %rdi
movl %ebx, %ecx
xorl %r8d, %r8d
jmp 0x3c9c1
cmpl $0x0, 0x64(%r12)
je 0x3c9d4
movslq 0x48(%r12), %r13
testq %r13, %r13
jle 0x3c9b0
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 0x2879c
addq %r12, %r15
addq %rbp, %r14
decq %r13
jne 0x3c98d
addq $0x8, %rsp
jmp 0x3ca1b
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 0x27d8d
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 0x3ca0f
pushq %rax
pushq $0x1
jmp 0x3ca12
pushq %rax
pushq $0x0
callq 0x27bf4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ca92
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 0x32c0
movl 0x6c(%r15), %esi
movl 0x74(%r15), %edx
imull 0x70(%r15), %esi
cmpl $0x0, 0x9c(%r15)
je 0x3cacd
movq %r14, %rdi
movl %ebx, %ecx
movl $0x1, %r8d
jmp 0x3cad5
cmpl $0x0, 0x9c(%r15)
je 0x3cae8
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 0x27bf4
addq $0x18, %rsp
jmp 0x3cb40
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 0x27d8d
cmpl $0x0, 0x64(%r15)
je 0x3cb4b
movslq 0x48(%r15), %r12
testq %r12, %r12
jle 0x3cb3c
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 0x2879c
addq %rbp, %r15
addq %r13, %r14
decq %r12
jne 0x3cb19
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 0x3cac2
// File: /workspace/github_c_makefile_star2_O1/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
movl %esi, %eax
movq %rdi, %rbx
movl 0x74(%rdi), %esi
movl 0x98(%rdi), %edi
movl %edx, 0x6c(%rbx)
movl %eax, 0x70(%rbx)
movl %edi, %ecx
imull %edi, %ecx
cmpl $0x0, 0x9c(%rbx)
je 0x3cbb6
imull %edi, %eax
movl %eax, 0x7c(%rbx)
imull %edi, %r8d
movl %r8d, 0x78(%rbx)
movl %esi, %eax
cltd
idivl %ecx
movl %eax, %ecx
jmp 0x3cbc8
cltd
idivl %edi
movl %eax, 0x7c(%rbx)
movl %r8d, %eax
cltd
idivl %edi
movl %eax, 0x78(%rbx)
imull %esi, %ecx
movl %ecx, 0x80(%rbx)
movslq 0x78(%rbx), %rax
movslq 0x7c(%rbx), %rdx
imulq %rax, %rdx
movslq %ecx, %rax
imulq %rdx, %rax
movl %eax, 0x58(%rbx)
movl %eax, 0x54(%rbx)
movslq 0x48(%rbx), %r14
imulq %rax, %r14
movq 0x268(%rbx), %rdi
shlq $0x2, %r14
movq %r14, %rsi
callq 0x3360
movq %rax, 0x268(%rbx)
movq 0x260(%rbx), %rdi
movq %r14, %rsi
callq 0x3360
movq %rax, 0x260(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3cc4d
movq 0x10(%rsi), %rax
movss 0x163d0(%rip), %xmm0    # 0x53008
movl %edx, %esi
imull %ecx, %edx
movslq %edx, %rdx
mulss (%rdi,%rdx,4), %xmm0
movl (%rax,%rsi,4), %edx
testl %edx, %edx
jns 0x3cc38
retq
movss 0x163b3(%rip), %xmm0    # 0x53008
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
movslq %r8d, %rax
movl %esi, %r9d
testl %esi, %esi
jle 0x3cca1
movq 0x10(%rdx), %r10
leaq (,%rax,4), %r11
xorl %ebx, %ebx
movq %rdi, %r14
movl (%r10,%rbx,4), %ebp
testl %ebp, %ebp
js 0x3cc96
imull %r8d, %ebp
movslq %ebp, %r15
movss (%rdi,%r15,4), %xmm0
mulss (%r14), %xmm0
movss %xmm0, (%r14)
incq %rbx
addq %r11, %r14
cmpq %rbx, %r9
jne 0x3cc77
testl %ecx, %ecx
sete %cl
testl %esi, %esi
setle %sil
orb %cl, %sil
jne 0x3ccd1
movq (%rdx), %rcx
shlq $0x2, %rax
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,4)
jne 0x3ccc6
movl $0x0, (%rdi)
incq %rdx
addq %rax, %rdi
cmpq %rdx, %r9
jne 0x3ccba
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq 0x38(%rsi), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
movss 0x1631a(%rip), %xmm1    # 0x53008
xorl %r8d, %r8d
movslq %r8d, %r9
movslq (%rcx,%r9,4), %r11
testq %r11, %r11
jle 0x3cd34
movq 0x40(%rsi), %r10
movslq (%r10,%r9,4), %rbx
movq %rbx, %r14
imulq %rdx, %r14
addq %rdi, %r14
xorps %xmm3, %xmm3
xorl %r10d, %r10d
movss (%r14), %xmm2
ucomiss %xmm3, %xmm2
maxss %xmm3, %xmm2
cmoval %ebx, %r10d
incl %ebx
addq %rdx, %r14
movaps %xmm2, %xmm3
decq %r11
jne 0x3cd15
jmp 0x3cd3a
xorps %xmm2, %xmm2
xorl %r10d, %r10d
mulss %xmm1, %xmm2
ucomiss %xmm0, %xmm2
jbe 0x3cd5e
movq 0x18(%rsi), %r8
movslq %r10d, %r10
movl (%r8,%r10,4), %r8d
testl %r8d, %r8d
setns %r9b
cmovnsl %eax, %r10d
movl %r10d, %eax
jmp 0x3cd87
testl %r8d, %r8d
je 0x3cd7b
movq 0x10(%rsi), %rax
movq 0x40(%rsi), %r10
movslq (%r10,%r9,4), %r9
movl (%rax,%r9,4), %eax
xorl %r9d, %r9d
movaps %xmm1, %xmm2
jmp 0x3cd87
xorl %r8d, %r8d
movaps %xmm1, %xmm2
movl %r10d, %eax
xorl %r9d, %r9d
movaps %xmm2, %xmm1
testb %r9b, %r9b
jne 0x3ccf1
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x31838
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 0x31838
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 0x31838
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 0x31838
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 0x31838
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 0x31838
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 0x31838
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 0x31838
addq $0x4c8, %rsp            # imm = 0x4C8
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl %esi, 0x70(%rdi)
movl %edx, 0x6c(%rdi)
imull %esi, %edx
movslq 0x84(%rdi), %rax
movslq %edx, %rcx
imulq %rax, %rcx
movslq 0xfc(%rdi), %rax
addq $0x5, %rax
imulq %rcx, %rax
movl %eax, 0x58(%rdi)
movl %eax, 0x54(%rdi)
movq 0x268(%rdi), %rdi
movslq 0x48(%rbx), %rsi
imulq %rax, %rsi
shlq $0x2, %rsi
callq 0x3360
movq %rax, 0x268(%rbx)
movq 0x260(%rbx), %rdi
movslq 0x48(%rbx), %rax
movslq 0x58(%rbx), %rsi
imulq %rax, %rsi
shlq $0x2, %rsi
callq 0x3360
movq %rax, 0x260(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
cvtsi2ss %r8d, %xmm1
movl 0x70(%rsp), %r13d
movslq %ecx, %r12
addss (%rdi,%r12,4), %xmm1
cvtsi2ssl 0x50(%rsp), %xmm0
divss %xmm0, %xmm1
movaps %xmm1, %xmm2
xorps %xmm0, %xmm0
cvtsi2ss %r9d, %xmm0
leal (%r13,%r12), %eax
cltq
xorps %xmm1, %xmm1
cvtsi2ssl 0x58(%rsp), %xmm1
addss (%rdi,%rax,4), %xmm0
divss %xmm1, %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps %xmm2, 0x10(%rsp)
leal (%r12,%r13,2), %eax
cltq
xorps %xmm0, %xmm0
cvtss2sd (%rdi,%rax,4), %xmm0
callq 0x34e0
leal (%r14,%r14), %eax
cltq
xorps %xmm1, %xmm1
cvtss2sd (%rbx,%rax,4), %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl 0x60(%rsp), %xmm0
divsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps %xmm0, (%rsp)
leal (%r13,%r13,2), %eax
addl %r12d, %eax
cltq
xorps %xmm0, %xmm0
cvtss2sd (%r15,%rax,4), %xmm0
callq 0x34e0
leal 0x1(,%r14,2), %eax
cltq
xorps %xmm1, %xmm1
cvtss2sd (%rbx,%rax,4), %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl 0x68(%rsp), %xmm2
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps 0x10(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/yolo_layer.c
// Function: delta_yolo_box
float delta_yolo_box(box truth, float *x, float *biases, int n, int index, int i, int j, int lw, int lh, int w, int h, float *delta, float scale, int stride)
{
    box pred = get_yolo_box(x, biases, n, index, i, j, lw, lh, w, h, stride);
    float iou = box_iou(pred, truth);

    float tx = (truth.x*lw - i);
    float ty = (truth.y*lh - j);
    float tw = log(truth.w*w / biases[2*n]);
    float th = log(truth.h*h / biases[2*n + 1]);

    delta[index + 0*stride] = scale * (tx - x[index + 0*stride]);
    delta[index + 1*stride] = scale * (ty - x[index + 1*stride]);
    delta[index + 2*stride] = scale * (tw - x[index + 2*stride]);
    delta[index + 3*stride] = scale * (th - x[index + 3*stride]);
    return iou;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movss %xmm2, 0xc(%rsp)
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, 0x4(%rsp)
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
movaps %xmm1, 0x30(%rsp)
movl 0x98(%rsp), %ebp
movl 0xa0(%rsp), %r11d
movl 0xa8(%rsp), %r10d
movl 0xb8(%rsp), %eax
subq $0x8, %rsp
pushq %rax
pushq %r10
pushq %r11
pushq %rbp
movl 0xb8(%rsp), %eax
pushq %rax
callq 0x3f69f
addq $0x30, %rsp
movaps 0x10(%rsp), %xmm2
movaps 0x20(%rsp), %xmm3
callq 0x36754
movl 0x90(%rsp), %eax
xorps %xmm3, %xmm3
cvtsi2ss %eax, %xmm3
xorps %xmm1, %xmm1
cvtsi2ss %r13d, %xmm1
movss %xmm0, 0x8(%rsp)
xorps %xmm2, %xmm2
cvtsi2ss %ebp, %xmm2
mulss 0x10(%rsp), %xmm3
xorps %xmm0, %xmm0
cvtsi2ss %r12d, %xmm0
subss %xmm1, %xmm3
movss %xmm3, (%rsp)
movl 0xa0(%rsp), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss 0x30(%rsp), %xmm2
subss %xmm0, %xmm2
movss %xmm2, 0x10(%rsp)
mulss 0x20(%rsp), %xmm1
leal (%r15,%r15), %eax
cltq
divss (%r14,%rax,4), %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
callq 0x31e0
movl 0xa8(%rsp), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
mulss 0x40(%rsp), %xmm1
leal 0x1(%r15,%r15), %eax
cltq
divss (%r14,%rax,4), %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
callq 0x31e0
cvtsd2ss %xmm0, %xmm0
movslq 0x4(%rsp), %rax
movss (%rsp), %xmm2
subss (%rbx,%rax,4), %xmm2
movss 0xc(%rsp), %xmm1
mulss %xmm1, %xmm2
movq 0xb0(%rsp), %rdx
movss %xmm2, (%rdx,%rax,4)
movl 0xb8(%rsp), %esi
leal (%rsi,%rax), %ecx
movslq %ecx, %rcx
movss 0x10(%rsp), %xmm2
subss (%rbx,%rcx,4), %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%rdx,%rcx,4)
leal (%rax,%rsi,2), %ecx
movslq %ecx, %rcx
movss 0x20(%rsp), %xmm2
subss (%rbx,%rcx,4), %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%rdx,%rcx,4)
leal (%rsi,%rsi,2), %ecx
addl %eax, %ecx
movslq %ecx, %rax
subss (%rbx,%rax,4), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%rdx,%rax,4)
movss 0x8(%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f97b
jnp 0x3f9ab
imull %ecx, %r9d
addl %edx, %r9d
movslq %r9d, %rcx
movss 0x1367b(%rip), %xmm0    # 0x53008
subss (%rdi,%rcx,4), %xmm0
movss %xmm0, (%rsi,%rcx,4)
testq %rax, %rax
je 0x3fa0a
movss (%rdi,%rcx,4), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
jmp 0x3fa0a
testl %r8d, %r8d
jle 0x3fa0a
movl %ecx, %ecx
movslq %r9d, %rdx
movl %r8d, %r8d
shlq $0x2, %r10
shlq $0x2, %rdx
xorl %r9d, %r9d
movss 0x1363d(%rip), %xmm0    # 0x53008
testq %rax, %rax
sete %r11b
movaps %xmm0, %xmm1
cmpq %r9, %rcx
setne %bl
je 0x3f9e0
xorps %xmm1, %xmm1
subss (%rdi,%r10), %xmm1
movss %xmm1, (%rsi,%r10)
orb %bl, %r11b
jne 0x3f9ff
movss (%rdi,%r10), %xmm1
addss (%rax), %xmm1
movss %xmm1, (%rax)
incq %r9
addq %rdx, %r10
cmpq %r9, %r8
jne 0x3f9cb
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x80(%rsp), %edi
imull 0x7c(%rsp), %edi
testl %edi, %edi
jle 0x3fbd5
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 0x3fbcb
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 0x3fba2
incl %r11d
cmpl %edi, %r11d
jne 0x3fb97
jmp 0x3fbd7
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq