LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: mag_array
float mag_array(float *a, int n)
{
    int i;
    float sum = 0;
    for(i = 0; i < n; ++i){
        sum += a[i]*a[i];   
    }
    return sqrt(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5a0d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x59ce
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3430
cvtsd2ss %xmm0, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: sample_array
int sample_array(float *a, int n)
{
    float sum = sum_array(a, n);
    scale_array(a, n, 1./sum);
    float r = rand_uniform(0, 1);
    int i;
    for(i = 0; i < n; ++i){
        r = r - a[i];
        if (r <= 0) return i;
    }
    return n-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5480
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x6b5a8(%rip), %xmm0    # 0x71060
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x5a30
xorps %xmm0, %xmm0
movss 0x6b53c(%rip), %xmm1    # 0x7100c
callq 0x5b30
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5b1e
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x1c(%rbp), %xmm0
jb 0x5b11
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5b27
jmp 0x5b13
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5ae1
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: rand_uniform
float rand_uniform(float min, float max)
{
    if(max < min){
        float swap = min;
        min = max;
        max = swap;
    }
    return ((float)rand()/RAND_MAX * (max - min)) + min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss -0x8(%rbp), %xmm1
movss -0x4(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x5b6f
movss -0x4(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
callq 0x34b0
cvtsi2ss %eax, %xmm0
movss 0x6b484(%rip), %xmm1    # 0x71004
divss %xmm1, %xmm0
movss -0x8(%rbp), %xmm2
subss -0x4(%rbp), %xmm2
movss -0x4(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: max_int_index
int max_int_index(int *a, int n)
{
    if(n <= 0) return -1;
    int i, max_i = 0;
    int max = a[0];
    for(i = 1; i < n; ++i){
        if(a[i] > max){
            max = a[i];
            max_i = i;
        }
    }
    return max_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x5bca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c20
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5c1a
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x20(%rbp), %eax
jle 0x5c0d
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5c0f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5be1
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: max_index
int max_index(float *a, int n)
{
    if(n <= 0) return -1;
    int i, max_i = 0;
    float max = a[0];
    for(i = 1; i < n; ++i){
        if(a[i] > max){
            max = a[i];
            max_i = i;
        }
    }
    return max_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x5c4a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5cab
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5ca5
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x20(%rbp), %xmm0
jbe 0x5c98
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5c9a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5c65
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: int_index
int int_index(int *a, int val, int n)
{
    int i;
    for(i = 0; i < n; ++i){
        if(a[i] == val) return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5cf2
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x5ce5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5cf9
jmp 0x5ce7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5cc5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: rand_int
int rand_int(int min, int max)
{
    if (max < min){
        int s = min;
        min = max;
        max = s;
    }
    int r = (rand()%(max - min + 1)) + min;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5d28
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
callq 0x34b0
movl -0x8(%rbp), %ecx
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
addl -0x4(%rbp), %edx
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: rand_normal
float rand_normal()
{
    static int haveSpare = 0;
    static double rand1, rand2;

    if(haveSpare)
    {
        haveSpare = 0;
        return sqrt(rand1) * sin(rand2);
    }

    haveSpare = 1;

    rand1 = rand() / ((double) RAND_MAX);
    if(rand1 < 1e-100) rand1 = 1e-100;
    rand1 = -2 * log(rand1);
    rand2 = (rand() / ((double) RAND_MAX)) * TWO_PI;

    return sqrt(rand1) * cos(rand2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x7e0c9(%rip)     # 0x83e28
je 0x5da4
movl $0x0, 0x7e0bd(%rip)     # 0x83e28
movsd 0x7e0bd(%rip), %xmm0    # 0x83e30
callq 0x3430
movsd %xmm0, -0x10(%rbp)
movsd 0x7e0b3(%rip), %xmm0    # 0x83e38
callq 0x33a0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x5e6e
movl $0x1, 0x7e07a(%rip)     # 0x83e28
callq 0x34b0
cvtsi2sd %eax, %xmm0
movsd 0x6b2b1(%rip), %xmm1    # 0x71070
divsd %xmm1, %xmm0
movsd %xmm0, 0x7e065(%rip)    # 0x83e30
movsd 0x6b295(%rip), %xmm0    # 0x71068
ucomisd 0x7e055(%rip), %xmm0    # 0x83e30
jbe 0x5ded
movsd 0x6b283(%rip), %xmm0    # 0x71068
movsd %xmm0, 0x7e043(%rip)    # 0x83e30
movsd 0x7e03b(%rip), %xmm0    # 0x83e30
callq 0x31a0
movaps %xmm0, %xmm1
movsd 0x6b27b(%rip), %xmm0    # 0x71080
mulsd %xmm1, %xmm0
movsd %xmm0, 0x7e01f(%rip)    # 0x83e30
callq 0x34b0
cvtsi2sd %eax, %xmm0
movsd 0x6b24e(%rip), %xmm1    # 0x71070
divsd %xmm1, %xmm0
movsd 0x6b24a(%rip), %xmm1    # 0x71078
mulsd %xmm1, %xmm0
movsd %xmm0, 0x7dffe(%rip)    # 0x83e38
movsd 0x7dfee(%rip), %xmm0    # 0x83e30
callq 0x3430
movsd %xmm0, -0x18(%rbp)
movsd 0x7dfe4(%rip), %xmm0    # 0x83e38
callq 0x31b0
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: rand_size_t
size_t rand_size_t()
{
    return  ((size_t)(rand()&0xff) << 56) | 
        ((size_t)(rand()&0xff) << 48) |
        ((size_t)(rand()&0xff) << 40) |
        ((size_t)(rand()&0xff) << 32) |
        ((size_t)(rand()&0xff) << 24) |
        ((size_t)(rand()&0xff) << 16) |
        ((size_t)(rand()&0xff) << 8) |
        ((size_t)(rand()&0xff) << 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x34b0
andl $0xff, %eax
cltq
shlq $0x38, %rax
movq %rax, -0x38(%rbp)
callq 0x34b0
movl %eax, %ecx
movq -0x38(%rbp), %rax
andl $0xff, %ecx
movslq %ecx, %rcx
shlq $0x30, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
callq 0x34b0
movl %eax, %ecx
movq -0x30(%rbp), %rax
andl $0xff, %ecx
movslq %ecx, %rcx
shlq $0x28, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
callq 0x34b0
movl %eax, %ecx
movq -0x28(%rbp), %rax
andl $0xff, %ecx
movslq %ecx, %rcx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
callq 0x34b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
andl $0xff, %ecx
movslq %ecx, %rcx
shlq $0x18, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
callq 0x34b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
andl $0xff, %ecx
movslq %ecx, %rcx
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
callq 0x34b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
andl $0xff, %ecx
movslq %ecx, %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
callq 0x34b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
andl $0xff, %ecx
movslq %ecx, %rcx
shlq $0x0, %rcx
orq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: one_hot_encode
float **one_hot_encode(float *a, int n, int k)
{
    int i;
    float **t = calloc(n, sizeof(float*));
    for(i = 0; i < n; ++i){
        t[i] = calloc(k, sizeof(float));
        int index = (int)a[i];
        t[i][index] = 1;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6078
movslq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cvttss2si (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movss 0x6afa4(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x601b
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/deconvolutional_layer.c
// Function: bilinear_init
void bilinear_init(layer l)
{
    int i,j,f;
    float center = (l.size-1) / 2.;
    for(f = 0; f < l.n; ++f){
        for(j = 0; j < l.size; ++j){
            for(i = 0; i < l.size; ++i){
                float val = (1 - fabs(i - center)) * (1 - fabs(j - center));
                int c = f%l.c;
                int ind = f*l.size*l.size*l.c + c*l.size*l.size + j*l.size + i;
                l.weights[ind] = val;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x90(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd 0x6af97(%rip), %xmm1    # 0x71058
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x6202
movl $0x0, -0x8(%rbp)
movq -0x28(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x90(%rcx), %eax
jge 0x61f2
movl $0x0, -0x4(%rbp)
movq -0x28(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x90(%rcx), %eax
jge 0x61e2
movq -0x28(%rbp), %rcx
cvtsi2ssl -0x4(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x6affb(%rip), %xmm0    # 0x71130
pand %xmm0, %xmm1
movsd 0x6af1f(%rip), %xmm0    # 0x71060
subsd %xmm1, %xmm0
cvtsi2ssl -0x8(%rbp), %xmm1
subss -0x10(%rbp), %xmm1
cvtss2sd %xmm1, %xmm2
movaps 0x6afd6(%rip), %xmm1    # 0x71130
pand %xmm1, %xmm2
movsd 0x6aefa(%rip), %xmm1    # 0x71060
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl 0x74(%rcx)
movq -0x28(%rbp), %rax
movl %edx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
imull 0x90(%rax), %ecx
imull 0x90(%rax), %ecx
imull 0x74(%rax), %ecx
movl -0x18(%rbp), %edx
imull 0x90(%rax), %edx
imull 0x90(%rax), %edx
addl %edx, %ecx
movl -0x8(%rbp), %edx
imull 0x90(%rax), %edx
addl %edx, %ecx
addl -0x4(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movss -0x14(%rbp), %xmm0
movq 0x250(%rax), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6109
jmp 0x61e4
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x60ef
jmp 0x61f4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x60d5
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/deconvolutional_layer.c
// Function: update_deconvolutional_layer
void update_deconvolutional_layer(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 size = l.size*l.size*l.c*l.n;
    axpy_cpu(l.n, learning_rate/batch, l.bias_updates, 1, l.biases, 1);
    scal_cpu(l.n, momentum, l.bias_updates, 1);

    if(l.scales){
        axpy_cpu(l.n, learning_rate/batch, l.scale_updates, 1, l.scales, 1);
        scal_cpu(l.n, momentum, l.scale_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 0x90(%rax), %ecx
imull 0x90(%rax), %ecx
imull 0x74(%rax), %ecx
imull 0x84(%rax), %ecx
movl %ecx, -0x14(%rbp)
movl 0x84(%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 0x84(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x238(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x240(%rax)
je 0x6d5f
movq -0x20(%rbp), %rax
movl 0x84(%rax), %edi
movss -0x4(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq 0x248(%rax), %rsi
movq 0x240(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x20(%rbp), %rax
movl 0x84(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x248(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
movq -0x20(%rbp), %rax
movl -0x14(%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 -0x14(%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 -0x14(%rbp), %edi
movss -0x8(%rbp), %xmm0
movq 0x258(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/deconvolutional_layer.c
// Function: denormalize_deconvolutional_layer
void denormalize_deconvolutional_layer(layer l)
{
    int i, j;
    for(i = 0; i < l.n; ++i){
        float scale = l.scales[i]/sqrt(l.rolling_variance[i] + .00001);
        for(j = 0; j < l.c*l.size*l.size; ++j){
            l.weights[i*l.c*l.size*l.size + j] *= scale;
        }
        l.biases[i] -= l.rolling_mean[i] * scale;
        l.scales[i] = 1;
        l.rolling_mean[i] = 0;
        l.rolling_variance[i] = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x6fb9
movq -0x18(%rbp), %rax
movq 0x240(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x2b8(%rax), %rax
movslq -0x4(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x6a285(%rip), %xmm1    # 0x71128
addsd %xmm1, %xmm0
callq 0x3430
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rdx
movl -0x8(%rbp), %eax
movl 0x74(%rdx), %ecx
imull 0x90(%rdx), %ecx
imull 0x90(%rdx), %ecx
cmpl %ecx, %eax
jge 0x6f24
movq -0x18(%rbp), %rdx
movss -0xc(%rbp), %xmm0
movq 0x250(%rdx), %rax
movl -0x4(%rbp), %ecx
imull 0x74(%rdx), %ecx
imull 0x90(%rdx), %ecx
imull 0x90(%rdx), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6ec8
movq -0x18(%rbp), %rax
movq 0x2b0(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movss -0xc(%rbp), %xmm2
movq 0x230(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm1
movd %xmm0, %esi
xorl $0x80000000, %esi       # imm = 0x80000000
movd %esi, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rcx,%rdx,4)
movq 0x240(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss 0x6a091(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rcx,%rdx,4)
movq 0x2b0(%rax), %rcx
movslq -0x4(%rbp), %rdx
xorps %xmm0, %xmm0
movss %xmm0, (%rcx,%rdx,4)
movq 0x2b8(%rax), %rax
movslq -0x4(%rbp), %rcx
movss 0x6a066(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e57
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: binarize_weights
void binarize_weights(float *weights, int n, int size, float *binary)
{
    int i, f;
    for(f = 0; f < n; ++f){
        float mean = 0;
        for(i = 0; i < size; ++i){
            mean += fabs(weights[f*size + i]);
        }
        mean = mean / size;
        for(i = 0; i < size; ++i){
            binary[f*size + i] = (weights[f*size + i] > 0) ? mean : -mean;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x72fb
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7262
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x69ef3(%rip), %xmm0    # 0x71130
pand %xmm0, %xmm1
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7214
movss -0x24(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x72eb
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x72ae
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x72c5
movss -0x24(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x727c
jmp 0x72ed
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x71f9
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: binarize_input
void binarize_input(float *input, int n, int size, float *binary)
{
    int i, s;
    for(s = 0; s < size; ++s){
        float mean = 0;
        for(i = 0; i < n; ++i){
            mean += fabs(input[i*size + s]);
        }
        mean = mean / n;
        for(i = 0; i < n; ++i){
            binary[i*size + s] = (input[i*size + s] > 0) ? mean : -mean;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x747b
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x73e2
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x69d73(%rip), %xmm0    # 0x71130
pand %xmm0, %xmm1
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7394
movss -0x24(%rbp), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x746b
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x742e
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x7445
movss -0x24(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x73fc
jmp 0x746d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7379
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: update_convolutional_layer
void update_convolutional_layer(convolutional_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;

    axpy_cpu(l.n, learning_rate/batch, l.bias_updates, 1, l.biases, 1);
    scal_cpu(l.n, momentum, l.bias_updates, 1);

    if(l.scales){
        axpy_cpu(l.n, learning_rate/batch, l.scale_updates, 1, l.scales, 1);
        scal_cpu(l.n, momentum, l.scale_updates, 1);
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4b0(%rbp), %rcx
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%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 0x84(%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 -0x18(%rbp), %rax
movl 0x84(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x238(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x240(%rax)
je 0x83f4
movq -0x18(%rbp), %rax
movl 0x84(%rax), %edi
movss -0x4(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq 0x248(%rax), %rsi
movq 0x240(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x18(%rbp), %rax
movl 0x84(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x248(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
movq -0x18(%rbp), %rax
movl 0x5c(%rax), %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 -0x18(%rbp), %rax
movl 0x5c(%rax), %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 -0x18(%rbp), %rax
movl 0x5c(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x258(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: resize_convolutional_layer
void resize_convolutional_layer(convolutional_layer *l, int w, int h)
{
    l->w = w;
    l->h = h;
    int out_w = convolutional_out_width(*l);
    int out_h = convolutional_out_height(*l);

    l->out_w = out_w;
    l->out_h = out_h;

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

    l->output = realloc(l->output, l->batch*l->outputs*sizeof(float));
    l->delta  = realloc(l->delta,  l->batch*l->outputs*sizeof(float));
    if(l->batch_normalize){
        l->x = realloc(l->x, l->batch*l->outputs*sizeof(float));
        l->x_norm  = realloc(l->x_norm, l->batch*l->outputs*sizeof(float));
    }

    l->workspace_size = get_workspace_size(*l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x70(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x8(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x74b0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x7480
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
movl 0x78(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x7c(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x80(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x70(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x6c(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x74(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x58(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x268(%rax)
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x58(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x260(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x8814
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x58(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2c0(%rax)
movq -0x8(%rbp), %rax
movq 0x2c8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x58(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2c8(%rax)
movq -0x8(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x8490
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x498(%rax)
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: add_bias
void add_bias(float *output, float *biases, int batch, int n, int size)
{
    int i,j,b;
    for(b = 0; b < batch; ++b){
        for(i = 0; i < n; ++i){
            for(j = 0; j < size; ++j){
                output[(b*n + i)*size + j] += biases[i];
            }
        }
    }
}

// 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)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x88d7
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x88ca
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x88bd
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x18(%rbp), %ecx
addl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x887b
jmp 0x88bf
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x886c
jmp 0x88cc
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x885d
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: scale_bias
void scale_bias(float *output, float *scales, int batch, int n, int size)
{
    int i,j,b;
    for(b = 0; b < batch; ++b){
        for(i = 0; i < n; ++i){
            for(j = 0; j < size; ++j){
                output[(b*n + i)*size + j] *= scales[i];
            }
        }
    }
}

// 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)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8977
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x896a
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x895d
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x18(%rbp), %ecx
addl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x891b
jmp 0x895f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x890c
jmp 0x896c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x88fd
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: backward_bias
void backward_bias(float *bias_updates, float *delta, int batch, int n, int size)
{
    int i,b;
    for(b = 0; b < batch; ++b){
        for(i = 0; i < n; ++i){
            bias_updates[i] += sum_array(delta+size*(i+b*n), size);
        }
    }
}

// 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)
movl %r8d, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8a09
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x89fc
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %edx
imull -0x18(%rbp), %edx
addl %edx, %ecx
imull %ecx, %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x5480
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x89b0
jmp 0x89fe
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x89a1
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: get_convolutional_weight
image get_convolutional_weight(convolutional_layer l, int i)
{
    int h = l.size;
    int w = l.size;
    int c = l.c/l.groups;
    return float_to_image(w,h,c,l.weights+i*h*w*c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl %esi, -0x4(%rbp)
movl 0x90(%rcx), %eax
movl %eax, -0x8(%rbp)
movl 0x90(%rcx), %eax
movl %eax, -0xc(%rbp)
movl 0x74(%rcx), %eax
cltd
idivl 0x8c(%rcx)
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0x10(%rbp), %ecx
movq 0x250(%rax), %r8
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %r8
callq 0xfbb0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: rgbgr_weights
void rgbgr_weights(convolutional_layer l)
{
    int i;
    for(i = 0; i < l.n; ++i){
        image im = get_convolutional_weight(l, i);
        if (im.c == 3) {
            rgbgr_image(im);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x28(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x8b0f
movq -0x28(%rbp), %rsi
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
movl -0x2c(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x8a10
cmpl $0x3, -0x18(%rbp)
jne 0x8b02
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x11230
jmp 0x8b04
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8aaa
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: rescale_weights
void rescale_weights(convolutional_layer l, float scale, float trans)
{
    int i;
    for(i = 0; i < l.n; ++i){
        image im = get_convolutional_weight(l, i);
        if (im.c == 3) {
            scale_image(im, scale);
            float sum = sum_array(im.data, im.w*im.h*im.c);
            l.biases[i] += sum*trans;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x8bf9
movq -0x38(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
movl -0x3c(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0x8a10
cmpl $0x3, -0x20(%rbp)
jne 0x8be9
movss -0x4(%rbp), %xmm0
leaq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x12420
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
imull -0x24(%rbp), %esi
imull -0x20(%rbp), %esi
callq 0x5480
movq -0x38(%rbp), %rax
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0x8(%rbp), %xmm2
movq 0x230(%rax), %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x8beb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8b44
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: get_weights
image *get_weights(convolutional_layer l)
{
    image *weights = calloc(l.n, sizeof(image));
    int i;
    for(i = 0; i < l.n; ++i){
        weights[i] = copy_image(get_convolutional_weight(l, i));
        normalize_image(weights[i]);
        /*
           char buff[256];
           sprintf(buff, "filter%d", i);
           save_image(weights[i], buff);
         */
    }
    //error("hey");
    return weights;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x500, %rsp            # imm = 0x500
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq 0x84(%rax), %rdi
movl $0x18, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x48(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x8d02
movq -0x48(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x54(%rbp)
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
movl -0x54(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x8a10
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xea60
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x10e50
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8c3f
movq -0x8(%rbp), %rax
addq $0x500, %rsp            # imm = 0x500
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/convolutional_layer.c
// Function: visualize_convolutional_layer
image *visualize_convolutional_layer(convolutional_layer l, char *window, image *prev_weights)
{
    image *single_weights = get_weights(l);
    show_images(single_weights, l.n, window);

    image delta = get_convolutional_image(l);
    image dc = collapse_image_layers(delta, 1);
    char buff[256];
    sprintf(buff, "%s: Output", window);
    //show_image(dc, buff);
    //save_image(dc, buff);
    free_image(dc);
    return single_weights;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x600, %rsp            # imm = 0x600
movq %rsi, %rax
leaq 0x10(%rbp), %rsi
movq %rsi, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x8c10
movq %rax, %rcx
movq -0x158(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl 0x84(%rax), %esi
movq -0x8(%rbp), %rdx
callq 0x157b0
movq -0x158(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
leaq -0x30(%rbp), %rdi
callq 0x74e0
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rax
movl $0x1, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x10c00
leaq -0x150(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x68418(%rip), %rsi     # 0x711d2
movb $0x0, %al
callq 0x33f0
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xedb0
movq -0x18(%rbp), %rax
addq $0x600, %rsp            # imm = 0x600
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/list.c
// Function: list_pop
void *list_pop(list *l){
    if(!l->back) return 0;
    node *b = l->back;
    void *val = b->val;
    l->back = b->prev;
    if(l->back) l->back->next = 0;
    free(b);
    --l->size;
    
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x8e61
movq $0x0, -0x8(%rbp)
jmp 0x8ebf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8ea3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/list.c
// Function: list_insert
void list_insert(list *l, void *val)
{
	node *new = malloc(sizeof(node));
	new->val = val;
	new->next = 0;

	if(!l->back){
		l->front = new;
		new->prev = 0;
	}else{
		l->back->next = new;
		new->prev = l->back;
	}
	l->back = new;
	++l->size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x8f2a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x8f4a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/list.c
// Function: free_node
void free_node(node *n)
{
	node *next;
	while(n) {
		next = n->next;
		free(n);
		n = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8fa2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8f7c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/list.c
// Function: free_list_contents
void free_list_contents(list *l)
{
	node *n = l->front;
	while(n){
		free(n->val);
		n = n->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9019
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8ff8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/list.c
// Function: list_to_array
void **list_to_array(list *l)
{
    void **a = calloc(l->size, sizeof(void*));
    int count = 0;
    node *n = l->front;
    while(n){
        a[count++] = n->val;
        n = n->next;
    }
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9086
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9054
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: get_color
float get_color(int c, int x, int max)
{
    float ratio = ((float)x/max)*5;
    int i = floor(ratio);
    int j = ceil(ratio);
    ratio -= i;
    float r = (1-ratio) * colors[i][c] + ratio*colors[j][c];
    //printf("%f\n", r);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cvtsi2ssl -0x8(%rbp), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movss 0x63085(%rip), %xmm1    # 0x7120c
mulss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x33b0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3450
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
cvtsi2ssl -0x14(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss 0x62e37(%rip), %xmm0    # 0x7100c
subss -0x10(%rbp), %xmm0
movslq -0x14(%rbp), %rcx
leaq 0x7516b(%rip), %rax     # 0x83350
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x10(%rbp), %xmm1
movslq -0x18(%rbp), %rcx
leaq 0x7514b(%rip), %rax     # 0x83350
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)