LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/upsample_layer.c
// Function: resize_upsample_layer
void resize_upsample_layer(layer *l, int w, int h)
{
    l->w = w;
    l->h = h;
    l->out_w = w*l->stride;
    l->out_h = h*l->stride;
    if(l->reverse){
        l->out_w = w/l->stride;
        l->out_h = h/l->stride;
    }
    l->outputs = l->out_w*l->out_h*l->out_c;
    l->inputs = l->h*l->w*l->c;
    l->delta =  realloc(l->delta, l->outputs*l->batch*sizeof(float));
    l->output = realloc(l->output, l->outputs*l->batch*sizeof(float));

    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x70(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x98(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x98(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x448eb
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x98(%rcx)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x98(%rcx)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x78(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x80(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x70(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x74(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x268(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: nms_comparator
int nms_comparator(const void *pa, const void *pb)
{
    detection a = *(detection *)pa;
    detection b = *(detection *)pb;
    float diff = 0;
    if(b.sort_class >= 0){
        diff = a.prob[b.sort_class] - b.prob[b.sort_class];
    } else {
        diff = a.objectness - b.objectness;
    }
    if(diff < 0) return 1;
    else if(diff > 0) return -1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movl $0x30, %edx
callq 0x3280
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0x30, %edx
callq 0x3280
xorps %xmm0, %xmm0
movss %xmm0, -0x7c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jl 0x44a06
movq -0x30(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x60(%rbp), %rax
movslq -0x4c(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x7c(%rbp)
jmp 0x44a15
movss -0x20(%rbp), %xmm0
subss -0x50(%rbp), %xmm0
movss %xmm0, -0x7c(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x7c(%rbp), %xmm0
jbe 0x44a27
movl $0x1, -0x4(%rbp)
jmp 0x44a46
movss -0x7c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x44a3d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44a46
jmp 0x44a3f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: float_to_box
box float_to_box(float *f, int stride)
{
    box b = {0};
    b.x = f[0];
    b.y = f[1*stride];
    b.w = f[2*stride];
    b.h = f[3*stride];
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x8(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %edx
movl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: overlap
float overlap(float x1, float w1, float x2, float w2)
{
    float l1 = x1 - w1/2;
    float l2 = x2 - w2/2;
    float left = l1 > l2 ? l1 : l2;
    float r1 = x1 + w1/2;
    float r2 = x2 + w2/2;
    float right = r1 < r2 ? r1 : r2;
    return right - left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss 0x2bf46(%rip), %xmm2    # 0x71210
divss %xmm2, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movss 0x2bf27(%rip), %xmm2    # 0x71210
divss %xmm2, %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x14(%rbp), %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0x4530d
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0x45317
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x4(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss 0x2bedd(%rip), %xmm2    # 0x71210
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movss 0x2bebe(%rip), %xmm2    # 0x71210
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x20(%rbp), %xmm1
movss -0x24(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4537a
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
jmp 0x45384
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: box_intersection
float box_intersection(box a, box b)
{
    float w = overlap(a.x, a.w, b.x, b.w);
    float h = overlap(a.y, a.h, b.y, b.h);
    if(w < 0 || h < 0) return 0;
    float area = w*h;
    return area;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x14(%rbp)
movlpd %xmm1, -0xc(%rbp)
movlpd %xmm2, -0x24(%rbp)
movlpd %xmm3, -0x1c(%rbp)
movss -0x14(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x1c(%rbp), %xmm3
callq 0x452a0
movss %xmm0, -0x28(%rbp)
movss -0x10(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss -0x20(%rbp), %xmm2
movss -0x18(%rbp), %xmm3
callq 0x452a0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x28(%rbp), %xmm0
ja 0x4540a
xorps %xmm0, %xmm0
ucomiss -0x2c(%rbp), %xmm0
jbe 0x45414
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x4542d
movss -0x28(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: box_rmse
float box_rmse(box a, box b)
{
    return sqrt(pow(a.x-b.x, 2) + 
                pow(a.y-b.y, 2) + 
                pow(a.w-b.w, 2) + 
                pow(a.h-b.h, 2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movlpd %xmm2, -0x20(%rbp)
movlpd %xmm3, -0x18(%rbp)
movss -0x10(%rbp), %xmm0
subss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2bb76(%rip), %xmm1    # 0x71058
callq 0x30e0
movsd %xmm0, -0x38(%rbp)
movss -0xc(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2bb56(%rip), %xmm1    # 0x71058
callq 0x30e0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x8(%rbp), %xmm0
subss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2bb2a(%rip), %xmm1    # 0x71058
callq 0x30e0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movss -0x4(%rbp), %xmm0
subss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2bafe(%rip), %xmm1    # 0x71058
callq 0x30e0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x3430
cvtsd2ss %xmm0, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: dintersect
dbox dintersect(box a, box b)
{
    float w = overlap(a.x, a.w, b.x, b.w);
    float h = overlap(a.y, a.h, b.y, b.h);
    dbox dover = derivative(a, b);
    dbox di;

    di.dw = dover.dw*h;
    di.dx = dover.dx*h;
    di.dh = dover.dh*w;
    di.dy = dover.dy*w;

    return di;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movlpd %xmm2, -0x30(%rbp)
movlpd %xmm3, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movss -0x30(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
callq 0x452a0
movss %xmm0, -0x34(%rbp)
movss -0x1c(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movss -0x24(%rbp), %xmm3
callq 0x452a0
movss %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
callq 0x44fe0
movlpd %xmm0, -0x48(%rbp)
movlpd %xmm1, -0x40(%rbp)
movss -0x40(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x48(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x3c(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x44(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: dunion
dbox dunion(box a, box b)
{
    dbox du;

    dbox di = dintersect(a, b);
    du.dw = a.h - di.dw;
    du.dh = a.w - di.dh;
    du.dx = -di.dx;
    du.dy = -di.dy;

    return du;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movlpd %xmm2, -0x30(%rbp)
movlpd %xmm3, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
callq 0x45580
movlpd %xmm0, -0x40(%rbp)
movlpd %xmm1, -0x38(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x40(%rbp), %xmm0
movaps 0x2faef(%rip), %xmm1    # 0x751c0
pxor %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x3c(%rbp), %xmm0
pxor %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: do_nms
void do_nms(box *boxes, float **probs, int total, int classes, float thresh)
{
    int i, j, k;
    for(i = 0; i < total; ++i){
        int any = 0;
        for(k = 0; k < classes; ++k) any = any || (probs[i][k] > 0);
        if(!any) {
            continue;
        }
        for(j = i+1; j < total; ++j){
            if (box_iou(boxes[i], boxes[j]) > thresh){
                for(k = 0; k < classes; ++k){
                    if (probs[i][k] < probs[j][k]) probs[i][k] = 0;
                    else probs[j][k] = 0;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x462ba
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x461c6
movb $0x1, %al
cmpl $0x0, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
jne 0x461b0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
seta %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4617c
cmpl $0x0, -0x2c(%rbp)
jne 0x461d1
jmp 0x462ac
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x462aa
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rdx
shlq $0x4, %rdx
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
movsd (%rax,%rdx), %xmm0
movsd 0x8(%rax,%rdx), %xmm1
movsd (%rax,%rcx), %xmm2
movsd 0x8(%rax,%rcx), %xmm3
callq 0x44cd0
ucomiss -0x1c(%rbp), %xmm0
jbe 0x4629a
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x46298
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x46273
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x4628b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x4628d
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x46222
jmp 0x4629a
jmp 0x4629c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x461da
jmp 0x462ac
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x46162
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: encode_box
box encode_box(box b, box anchor)
{
    box encode;
    encode.x = (b.x - anchor.x) / anchor.w;
    encode.y = (b.y - anchor.y) / anchor.h;
    encode.w = log2(b.w / anchor.w);
    encode.h = log2(b.h / anchor.h);
    return encode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movlpd %xmm2, -0x30(%rbp)
movlpd %xmm3, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x30(%rbp), %xmm2
movss -0x28(%rbp), %xmm1
subss %xmm2, %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x1c(%rbp), %xmm0
movss -0x2c(%rbp), %xmm2
movss -0x24(%rbp), %xmm1
subss %xmm2, %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3040
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3040
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/box.c
// Function: decode_box
box decode_box(box b, box anchor)
{
    box decode;
    decode.x = b.x * anchor.w + anchor.x;
    decode.y = b.y * anchor.h + anchor.y;
    decode.w = pow(2., b.w) * anchor.w;
    decode.h = pow(2., b.h) * anchor.h;
    return decode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movlpd %xmm2, -0x30(%rbp)
movlpd %xmm3, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss -0x28(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x1c(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x2ac83(%rip), %xmm0    # 0x71058
movsd %xmm0, -0x38(%rbp)
callq 0x30e0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
movss -0x28(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, -0x8(%rbp)
movss -0x14(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
callq 0x30e0
movss -0x24(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/normalization_layer.c
// Function: backward_normalization_layer
void backward_normalization_layer(const layer layer, network net)
{
    // TODO This is approximate ;-)
    // Also this should add in to delta instead of overwritting.

    int w = layer.w;
    int h = layer.h;
    int c = layer.c;
    pow_cpu(w*h*c*layer.batch, -layer.beta, layer.norms, 1, net.delta, 1);
    mul_cpu(w*h*c*layer.batch, layer.delta, 1, net.delta, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x70(%rcx), %edx
movl %edx, -0x4(%rbp)
movl 0x6c(%rcx), %edx
movl %edx, -0x8(%rbp)
movl 0x74(%rcx), %edx
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
imull -0x8(%rbp), %edi
imull -0xc(%rbp), %edi
imull 0x48(%rcx), %edi
movss 0x138(%rcx), %xmm0
movd %xmm0, %edx
xorl $0x80000000, %edx       # imm = 0x80000000
movd %edx, %xmm0
movq 0x280(%rcx), %rsi
movq 0xe8(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f600
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %edi
imull -0x8(%rbp), %edi
imull -0xc(%rbp), %edi
imull 0x48(%rcx), %edi
movq 0x260(%rcx), %rsi
movq 0xe8(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f5a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/normalization_layer.c
// Function: resize_normalization_layer
void resize_normalization_layer(layer *layer, int w, int h)
{
    int c = layer->c;
    int batch = layer->batch;
    layer->h = h;
    layer->w = w;
    layer->out_h = h;
    layer->out_w = w;
    layer->inputs = w*h*c;
    layer->outputs = layer->inputs;
    layer->output = realloc(layer->output, h * w * c * batch * sizeof(float));
    layer->delta = realloc(layer->delta, h * w * c * batch * sizeof(float));
    layer->squared = realloc(layer->squared, h * w * c * batch * sizeof(float));
    layer->norms = realloc(layer->norms, h * w * c * batch * sizeof(float));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x70(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
imull -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x268(%rax)
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rdi
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x278(%rax)
movq -0x8(%rbp), %rax
movq 0x280(%rax), %rdi
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x280(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/avgpool_layer.c
// Function: make_avgpool_layer
avgpool_layer make_avgpool_layer(int batch, int w, int h, int c)
{
    fprintf(stderr, "avg                     %4d x%4d x%4d   ->  %4d\n",  w, h, c, c);
    avgpool_layer l = {0};
    l.type = AVGPOOL;
    l.batch = batch;
    l.h = h;
    l.w = w;
    l.c = c;
    l.out_w = 1;
    l.out_h = 1;
    l.out_c = c;
    l.outputs = l.out_c;
    l.inputs = h*w*c;
    int output_size = l.outputs * batch;
    l.output =  calloc(output_size, sizeof(float));
    l.delta =   calloc(output_size, sizeof(float));
    l.forward = forward_avgpool_layer;
    l.backward = backward_avgpool_layer;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movq 0x3c454(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0x2e775(%rip), %rsi     # 0x75331
movb $0x0, %al
callq 0x3240
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x28(%rbp), %rdi
movl $0xb, (%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x6c(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x70(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x74(%rdi)
movl $0x1, 0x7c(%rdi)
movl $0x1, 0x78(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x80(%rdi)
movl 0x80(%rdi), %eax
movl %eax, 0x58(%rdi)
movl -0xc(%rbp), %eax
imull -0x8(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, 0x54(%rdi)
movl 0x58(%rdi), %eax
imull -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq -0x28(%rbp), %rdi
movq %rax, 0x268(%rdi)
movslq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x260(%rdi)
leaq 0x23(%rip), %rcx        # 0x46c90
movq %rcx, 0x10(%rdi)
leaq 0x148(%rip), %rcx       # 0x46dc0
movq %rcx, 0x18(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/avgpool_layer.c
// Function: forward_avgpool_layer
void forward_avgpool_layer(const avgpool_layer l, network net)
{
    int b,i,k;

    for(b = 0; b < l.batch; ++b){
        for(k = 0; k < l.c; ++k){
            int out_index = k + b*l.c;
            l.output[out_index] = 0;
            for(i = 0; i < l.h*l.w; ++i){
                int in_index = i + l.h*l.w*(k + b*l.c);
                l.output[out_index] += net.input[in_index];
            }
            l.output[out_index] /= l.h*l.w;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x20(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x46db3
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x74(%rcx), %eax
jge 0x46da3
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl -0x4(%rbp), %edx
imull 0x74(%rax), %edx
addl %edx, %ecx
movl %ecx, -0x10(%rbp)
movq 0x268(%rax), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rdx
movl -0x8(%rbp), %eax
movl 0x6c(%rdx), %ecx
imull 0x70(%rdx), %ecx
cmpl %ecx, %eax
jge 0x46d6d
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x8(%rbp), %edx
movl 0x6c(%rax), %esi
imull 0x70(%rax), %esi
movl -0xc(%rbp), %edi
movl -0x4(%rbp), %r8d
imull 0x74(%rax), %r8d
addl %r8d, %edi
imull %edi, %esi
addl %esi, %edx
movl %edx, -0x14(%rbp)
movq 0xd8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movq 0x268(%rax), %rax
movslq -0x10(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x46d02
movq -0x20(%rbp), %rax
movl 0x6c(%rax), %ecx
imull 0x70(%rax), %ecx
cvtsi2ss %ecx, %xmm1
movq 0x268(%rax), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x46cc5
jmp 0x46da5
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x46cae
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/avgpool_layer.c
// Function: backward_avgpool_layer
void backward_avgpool_layer(const avgpool_layer l, network net)
{
    int b,i,k;

    for(b = 0; b < l.batch; ++b){
        for(k = 0; k < l.c; ++k){
            int out_index = k + b*l.c;
            for(i = 0; i < l.h*l.w; ++i){
                int in_index = i + l.h*l.w*(k + b*l.c);
                net.delta[in_index] += l.delta[out_index] / (l.h*l.w);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x20(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x46eb9
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x74(%rcx), %eax
jge 0x46ea9
movq -0x20(%rbp), %rdx
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
imull 0x74(%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rdx
movl -0x8(%rbp), %eax
movl 0x6c(%rdx), %ecx
imull 0x70(%rdx), %ecx
cmpl %ecx, %eax
jge 0x46e99
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movl -0x8(%rbp), %ecx
movl 0x6c(%rdx), %esi
imull 0x70(%rdx), %esi
movl -0xc(%rbp), %edi
movl -0x4(%rbp), %r8d
imull 0x74(%rdx), %r8d
addl %r8d, %edi
imull %edi, %esi
addl %esi, %ecx
movl %ecx, -0x14(%rbp)
movq 0x260(%rdx), %rcx
movslq -0x10(%rbp), %rsi
movss (%rcx,%rsi,4), %xmm0
movl 0x6c(%rdx), %ecx
imull 0x70(%rdx), %ecx
cvtsi2ss %ecx, %xmm1
divss %xmm1, %xmm0
movq 0xe8(%rax), %rax
movslq -0x14(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x46e1f
jmp 0x46e9b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x46df5
jmp 0x46eab
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x46dde
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/local_layer.c
// Function: local_out_height
int local_out_height(local_layer l)
{
    int h = l.h;
    if (!l.pad) h -= l.size;
    else h -= 1;
    return h/l.stride + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x6c(%rax), %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, 0xa8(%rax)
jne 0x4741f
movq -0x10(%rbp), %rax
movl 0x90(%rax), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x47428
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
cltd
idivl 0x98(%rcx)
addl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/local_layer.c
// Function: local_out_width
int local_out_width(local_layer l)
{
    int w = l.w;
    if (!l.pad) w -= l.size;
    else w -= 1;
    return w/l.stride + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x70(%rax), %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, 0xa8(%rax)
jne 0x4746f
movq -0x10(%rbp), %rax
movl 0x90(%rax), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x47478
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
cltd
idivl 0x98(%rcx)
addl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/local_layer.c
// Function: update_local_layer
void update_local_layer(local_layer l, update_args a)
{
    float learning_rate = a.learning_rate*l.learning_rate_scale;
    float momentum = a.momentum;
    float decay = a.decay;
    int batch = a.batch;

    int locations = l.out_w*l.out_h;
    int size = l.size*l.size*l.c*l.n*locations;
    axpy_cpu(l.outputs, learning_rate/batch, l.bias_updates, 1, l.biases, 1);
    scal_cpu(l.outputs, momentum, l.bias_updates, 1);

    axpy_cpu(size, -decay*batch, l.weights, 1, l.weight_updates, 1);
    axpy_cpu(size, learning_rate/batch, l.weight_updates, 1, l.weights, 1);
    scal_cpu(size, momentum, l.weight_updates, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4b0(%rbp), %rcx
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss 0x4(%rcx), %xmm0
mulss 0xec(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
movss 0x8(%rcx), %xmm0
movss %xmm0, -0x8(%rbp)
movss 0xc(%rcx), %xmm0
movss %xmm0, -0xc(%rbp)
movl (%rcx), %ecx
movl %ecx, -0x10(%rbp)
movl 0x7c(%rax), %ecx
imull 0x78(%rax), %ecx
movl %ecx, -0x14(%rbp)
movl 0x90(%rax), %ecx
imull 0x90(%rax), %ecx
imull 0x74(%rax), %ecx
imull 0x84(%rax), %ecx
imull -0x14(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0x58(%rax), %edi
movss -0x4(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq 0x238(%rax), %rsi
movq 0x230(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x20(%rbp), %rax
movl 0x58(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x238(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %edi
movss -0xc(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
movq 0x250(%rax), %rsi
movq 0x258(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %edi
movss -0x4(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq 0x258(%rax), %rsi
movq 0x250(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %edi
movss -0x8(%rbp), %xmm0
movq 0x258(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/shortcut_layer.c
// Function: make_shortcut_layer
layer make_shortcut_layer(int batch, int index, int w, int h, int c, int w2, int h2, int c2)
{
    fprintf(stderr, "res  %3d                %4d x%4d x%4d   ->  %4d x%4d x%4d\n",index, w2,h2,c2, w,h,c);
    layer l = {0};
    l.type = SHORTCUT;
    l.batch = batch;
    l.w = w2;
    l.h = h2;
    l.c = c2;
    l.out_w = w;
    l.out_h = h;
    l.out_c = c;
    l.outputs = w*h*c;
    l.inputs = l.outputs;

    l.index = index;

    l.delta =  calloc(l.outputs*batch, sizeof(float));
    l.output = calloc(l.outputs*batch, sizeof(float));;

    l.forward = forward_shortcut_layer;
    l.backward = backward_shortcut_layer;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movl %r9d, -0x14(%rbp)
movq 0x3b0a7(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
movl 0x10(%rbp), %ecx
movl 0x18(%rbp), %r8d
movl 0x20(%rbp), %r9d
movl -0xc(%rbp), %r11d
movl -0x10(%rbp), %r10d
movl -0x14(%rbp), %eax
leaq 0x2d431(%rip), %rsi     # 0x753a5
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x3240
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x28(%rbp), %rdi
movl $0xd, (%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl 0x10(%rbp), %eax
movl %eax, 0x70(%rdi)
movl 0x18(%rbp), %eax
movl %eax, 0x6c(%rdi)
movl 0x20(%rbp), %eax
movl %eax, 0x74(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x7c(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x78(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x80(%rdi)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, 0x58(%rdi)
movl 0x58(%rdi), %eax
movl %eax, 0x54(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0xb4(%rdi)
movl 0x58(%rdi), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x28(%rbp), %rdi
movq %rax, 0x260(%rdi)
movl 0x58(%rdi), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x268(%rdi)
leaq 0x18(%rip), %rcx        # 0x48050
movq %rcx, 0x10(%rdi)
leaq 0xdd(%rip), %rcx        # 0x48120
movq %rcx, 0x18(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/shortcut_layer.c
// Function: resize_shortcut_layer
void resize_shortcut_layer(layer *l, int w, int h)
{
    assert(l->w == l->out_w);
    assert(l->h == l->out_h);
    l->w = l->out_w = w;
    l->h = l->out_h = h;
    l->outputs = w*h*l->out_c;
    l->inputs = l->outputs;
    l->delta =  realloc(l->delta, l->outputs*l->batch*sizeof(float));
    l->output = realloc(l->output, l->outputs*l->batch*sizeof(float));

    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x70(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x7c(%rcx), %eax
jne 0x48214
jmp 0x48233
leaq 0x2d1c5(%rip), %rdi     # 0x753e0
leaq 0x2d1cf(%rip), %rsi     # 0x753f1
movl $0x24, %edx
leaq 0x2d1d4(%rip), %rcx     # 0x75402
callq 0x3180
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jne 0x48245
jmp 0x48264
leaq 0x2d1e4(%rip), %rdi     # 0x75430
leaq 0x2d19e(%rip), %rsi     # 0x753f1
movl $0x25, %edx
leaq 0x2d1a3(%rip), %rcx     # 0x75402
callq 0x3180
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x70(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movl -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x80(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x268(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/logistic_layer.c
// Function: make_logistic_layer
layer make_logistic_layer(int batch, int inputs)
{
    fprintf(stderr, "logistic x entropy                             %4d\n",  inputs);
    layer l = {0};
    l.type = LOGXENT;
    l.batch = batch;
    l.inputs = inputs;
    l.outputs = inputs;
    l.loss = calloc(inputs*batch, sizeof(float));
    l.output = calloc(inputs*batch, sizeof(float));
    l.delta = calloc(inputs*batch, sizeof(float));
    l.cost = calloc(1, sizeof(float));

    l.forward = forward_logistic_layer;
    l.backward = backward_logistic_layer;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movq 0x3acbb(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x2d0f7(%rip), %rsi     # 0x75441
movb $0x0, %al
callq 0x3240
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x18(%rbp), %rdi
movl $0x1b, (%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x54(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x58(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, 0x270(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, 0x268(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, 0x260(%rdi)
movl $0x1, %edi
movl $0x4, %esi
callq 0x3220
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1d8(%rdi)
leaq 0x1e(%rip), %rcx        # 0x48420
movq %rcx, 0x10(%rdi)
leaq 0xe3(%rip), %rcx        # 0x484f0
movq %rcx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/logistic_layer.c
// Function: forward_logistic_layer
void forward_logistic_layer(const layer l, network net)
{
    copy_cpu(l.outputs*l.batch, net.input, 1, l.output, 1);
    activate_array(l.output, l.outputs*l.batch, LOGISTIC);
    if(net.truth){
        logistic_x_ent_cpu(l.batch*l.inputs, l.output, net.truth, l.delta, l.loss);
        l.cost[0] = sum_array(l.loss, l.batch*l.inputs);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4b0(%rbp), %rcx
movq %rcx, -0x8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x58(%rax), %edi
imull 0x48(%rax), %edi
movq 0xd8(%rcx), %rsi
movq 0x268(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f960
movq -0x10(%rbp), %rax
movq 0x268(%rax), %rdi
movl 0x58(%rax), %esi
imull 0x48(%rax), %esi
xorl %edx, %edx
callq 0x2dfa0
movq -0x8(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x484db
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x48(%rax), %edi
imull 0x54(%rax), %edi
movq 0x268(%rax), %rsi
movq 0xe0(%rcx), %rdx
movq 0x260(%rax), %rcx
movq 0x270(%rax), %r8
callq 0x2fcb0
movq -0x10(%rbp), %rax
movq 0x270(%rax), %rdi
movl 0x48(%rax), %esi
imull 0x54(%rax), %esi
callq 0x5480
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movss %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/activation_layer.c
// Function: make_activation_layer
layer make_activation_layer(int batch, int inputs, ACTIVATION activation)
{
    layer l = {0};
    l.type = ACTIVE;

    l.inputs = inputs;
    l.outputs = inputs;
    l.batch=batch;

    l.output = calloc(batch*inputs, sizeof(float*));
    l.delta = calloc(batch*inputs, sizeof(float*));

    l.forward = forward_activation_layer;
    l.backward = backward_activation_layer;
    l.activation = activation;
    fprintf(stderr, "Activation Layer: %d inputs\n", inputs);
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x20(%rbp), %rdi
movl $0xe, (%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x54(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x58(%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq %rax, 0x268(%rdi)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq %rax, 0x260(%rdi)
leaq 0x47(%rip), %rax        # 0x48600
movq %rax, 0x10(%rdi)
leaq 0x9c(%rip), %rax        # 0x48660
movq %rax, 0x18(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x4(%rdi)
movq 0x3aa23(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x2ce93(%rip), %rsi     # 0x75475
movb $0x0, %al
callq 0x3240
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/rnn_layer.c
// Function: increment_layer
static void increment_layer(layer *l, int steps)
{
    int num = l->outputs*l->batch*steps;
    l->output += num;
    l->delta += num;
    l->x += num;
    l->x_norm += num;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
imull -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x268(%rax)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x260(%rax)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x2c0(%rax)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x2c8(%rax), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x2c8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
leaq 0x4b0(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x438(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x428(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x448(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x430(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x420(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
movq -0x10(%rbp), %rax
movq 0x440(%rax), %rsi
movq %rsp, %rax
movl $0x94, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %edx
movl %edx, 0x4c0(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x4b0(%rax)
movups %xmm0, 0x4a0(%rax)
callq 0x3c9e0
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/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
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x8(%rbp)
cmpl $0x0, 0xf8(%rax)
jne 0x4b574
movq -0x8(%rbp), %rax
movq 0x2b0(%rax), %rcx
movq %rcx, 0x290(%rax)
movq 0x2b8(%rax), %rcx
movq %rcx, 0x298(%rax)
movq -0x8(%rbp), %rax
movq 0x238(%rax), %rdi
movq 0x260(%rax), %rsi
movl 0x48(%rax), %edx
movl 0x80(%rax), %ecx
movl 0x7c(%rax), %r8d
imull 0x78(%rax), %r8d
callq 0x8980
movq -0x8(%rbp), %rax
movq 0x2c8(%rax), %rdi
movq 0x260(%rax), %rsi
movl 0x48(%rax), %edx
movl 0x80(%rax), %ecx
movl 0x7c(%rax), %r8d
imull 0x78(%rax), %r8d
movq 0x248(%rax), %r9
callq 0x4b700
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
movq 0x240(%rax), %rsi
movl 0x48(%rax), %edx
movl 0x80(%rax), %ecx
movl 0x78(%rax), %r8d
imull 0x7c(%rax), %r8d
callq 0x88e0
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
movq 0x298(%rax), %rsi
movl 0x48(%rax), %edx
movl 0x80(%rax), %ecx
movl 0x7c(%rax), %r8d
imull 0x78(%rax), %r8d
movq 0x2a0(%rax), %r9
callq 0x4b7e0
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rdi
movq 0x260(%rax), %rsi
movq 0x290(%rax), %rdx
movq 0x298(%rax), %rcx
movl 0x48(%rax), %r8d
movl 0x80(%rax), %r9d
movl 0x7c(%rax), %r10d
imull 0x78(%rax), %r10d
movq 0x2a8(%rax), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x4b8f0
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rdi
movq 0x290(%rax), %rsi
movq 0x298(%rax), %rdx
movq 0x2a0(%rax), %rcx
movq 0x2a8(%rax), %r8
movl 0x48(%rax), %r9d
movl 0x80(%rax), %r11d
movl 0x7c(%rax), %r10d
imull 0x78(%rax), %r10d
movq 0x260(%rax), %rax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x4ba40
movq -0x8(%rbp), %rax
cmpl $0x13, (%rax)
jne 0x4b6f8
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x58(%rcx), %edi
imull 0x48(%rcx), %edi
movq 0x260(%rcx), %rsi
movq 0xe8(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f960
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4b7d6
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4b7b1
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4b7a4
movl -0x2c(%rbp), %eax
movl -0x1c(%rbp), %ecx
movl -0x34(%rbp), %edx
movl -0x18(%rbp), %esi
imull -0x30(%rbp), %esi
addl %esi, %edx
imull %edx, %ecx
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x38(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4b74b
jmp 0x4b7a6
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4b73c
movss -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4b721
popq %rbp
retq
nopl (%rax,%rax)