LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: show_images
void show_images(image *ims, int n, char *window)
{
    image m = collapse_images_vert(ims, n);
    /*
       int w = 448;
       int h = ((float)m.h/m.w) * 448;
       if(h > 896){
       h = 896;
       w = ((float)m.w/m.h) * 896;
       }
       image sized = resize_image(m, w, h);
     */
    normalize_image(m);
    save_image(m, window);
    show_image(m, window, 1);
    free_image(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x15280
leaq -0x30(%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 0x10e50
movq -0x18(%rbp), %rdi
leaq -0x30(%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 0x11330
movq -0x18(%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 0x112c0
leaq -0x30(%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
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/activations.c
// Function: get_activation_string
char *get_activation_string(ACTIVATION a)
{
    switch(a){
        case LOGISTIC:
            return "logistic";
        case LOGGY:
            return "loggy";
        case RELU:
            return "relu";
        case ELU:
            return "elu";
        case SELU:
            return "selu";
        case RELIE:
            return "relie";
        case RAMP:
            return "ramp";
        case LINEAR:
            return "linear";
        case TANH:
            return "tanh";
        case PLSE:
            return "plse";
        case LEAKY:
            return "leaky";
        case STAIR:
            return "stair";
        case HARDTAN:
            return "hardtan";
        case LHTAN:
            return "lhtan";
        default:
            break;
    }
    return "relu";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xd, %rax
ja 0x2d631
movq -0x18(%rbp), %rax
leaq 0x46a91(%rip), %rcx     # 0x73ff4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x46b71(%rip), %rax     # 0x740e4
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b6a(%rip), %rax     # 0x740ed
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b60(%rip), %rax     # 0x740f3
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b51(%rip), %rax     # 0x740f4
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b45(%rip), %rax     # 0x740f8
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b3a(%rip), %rax     # 0x740fd
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b33(%rip), %rax     # 0x74103
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b2b(%rip), %rax     # 0x74108
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b25(%rip), %rax     # 0x7410f
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b1d(%rip), %rax     # 0x74114
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b15(%rip), %rax     # 0x74119
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b0e(%rip), %rax     # 0x7411f
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b07(%rip), %rax     # 0x74125
movq %rax, -0x8(%rbp)
jmp 0x2d63e
leaq 0x46b02(%rip), %rax     # 0x7412d
movq %rax, -0x8(%rbp)
jmp 0x2d63e
jmp 0x2d633
leaq 0x46ab9(%rip), %rax     # 0x740f3
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/activations.c
// Function: get_activation
ACTIVATION get_activation(char *s)
{
    if (strcmp(s, "logistic")==0) return LOGISTIC;
    if (strcmp(s, "loggy")==0) return LOGGY;
    if (strcmp(s, "relu")==0) return RELU;
    if (strcmp(s, "elu")==0) return ELU;
    if (strcmp(s, "selu")==0) return SELU;
    if (strcmp(s, "relie")==0) return RELIE;
    if (strcmp(s, "plse")==0) return PLSE;
    if (strcmp(s, "hardtan")==0) return HARDTAN;
    if (strcmp(s, "lhtan")==0) return LHTAN;
    if (strcmp(s, "linear")==0) return LINEAR;
    if (strcmp(s, "ramp")==0) return RAMP;
    if (strcmp(s, "leaky")==0) return LEAKY;
    if (strcmp(s, "tanh")==0) return TANH;
    if (strcmp(s, "stair")==0) return STAIR;
    fprintf(stderr, "Couldn't find activation function %s, going with ReLU\n", s);
    return RELU;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x46a7d(%rip), %rsi     # 0x740e4
callq 0x3230
cmpl $0x0, %eax
jne 0x2d67d
movl $0x0, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x46a65(%rip), %rsi     # 0x740ed
callq 0x3230
cmpl $0x0, %eax
jne 0x2d69e
movl $0x9, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x46a4a(%rip), %rsi     # 0x740f3
callq 0x3230
cmpl $0x0, %eax
jne 0x2d6bf
movl $0x1, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x46a2a(%rip), %rsi     # 0x740f4
callq 0x3230
cmpl $0x0, %eax
jne 0x2d6e0
movl $0x8, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x46a0d(%rip), %rsi     # 0x740f8
callq 0x3230
cmpl $0x0, %eax
jne 0x2d701
movl $0xd, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x469f1(%rip), %rsi     # 0x740fd
callq 0x3230
cmpl $0x0, %eax
jne 0x2d722
movl $0x2, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x469e7(%rip), %rsi     # 0x74114
callq 0x3230
cmpl $0x0, %eax
jne 0x2d743
movl $0x6, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x469d7(%rip), %rsi     # 0x74125
callq 0x3230
cmpl $0x0, %eax
jne 0x2d764
movl $0xb, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x469be(%rip), %rsi     # 0x7412d
callq 0x3230
cmpl $0x0, %eax
jne 0x2d785
movl $0xc, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x46978(%rip), %rsi     # 0x74108
callq 0x3230
cmpl $0x0, %eax
jne 0x2d7a6
movl $0x3, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x46952(%rip), %rsi     # 0x74103
callq 0x3230
cmpl $0x0, %eax
jne 0x2d7c4
movl $0x4, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x4694a(%rip), %rsi     # 0x74119
callq 0x3230
cmpl $0x0, %eax
jne 0x2d7e2
movl $0x7, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x46922(%rip), %rsi     # 0x7410f
callq 0x3230
cmpl $0x0, %eax
jne 0x2d800
movl $0x5, -0x4(%rbp)
jmp 0x2d841
movq -0x10(%rbp), %rdi
leaq 0x46914(%rip), %rsi     # 0x7411f
callq 0x3230
cmpl $0x0, %eax
jne 0x2d81e
movl $0xa, -0x4(%rbp)
jmp 0x2d841
movq 0x557d3(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x46900(%rip), %rsi     # 0x74133
movb $0x0, %al
callq 0x3240
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/activations.c
// Function: activate
float activate(float x, ACTIVATION a)
{
    switch(a){
        case LINEAR:
            return linear_activate(x);
        case LOGISTIC:
            return logistic_activate(x);
        case LOGGY:
            return loggy_activate(x);
        case RELU:
            return relu_activate(x);
        case ELU:
            return elu_activate(x);
        case SELU:
            return selu_activate(x);
        case RELIE:
            return relie_activate(x);
        case RAMP:
            return ramp_activate(x);
        case LEAKY:
            return leaky_activate(x);
        case TANH:
            return tanh_activate(x);
        case PLSE:
            return plse_activate(x);
        case STAIR:
            return stair_activate(x);
        case HARDTAN:
            return hardtan_activate(x);
        case LHTAN:
            return lhtan_activate(x);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xd, %rax
ja 0x2d985
movq -0x18(%rbp), %rax
leaq 0x467b0(%rip), %rcx     # 0x7402c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss -0x8(%rbp), %xmm0
callq 0x2d9a0
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2d9b0
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2da00
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2da60
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2da90
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2db20
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2dbe0
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2dc30
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2dc80
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2dcd0
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2dd40
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2de00
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2deb0
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
movss -0x8(%rbp), %xmm0
callq 0x2df10
movss %xmm0, -0x4(%rbp)
jmp 0x2d98d
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/activations.c
// Function: gradient
float gradient(float x, ACTIVATION a)
{
    switch(a){
        case LINEAR:
            return linear_gradient(x);
        case LOGISTIC:
            return logistic_gradient(x);
        case LOGGY:
            return loggy_gradient(x);
        case RELU:
            return relu_gradient(x);
        case ELU:
            return elu_gradient(x);
        case SELU:
            return selu_gradient(x);
        case RELIE:
            return relie_gradient(x);
        case RAMP:
            return ramp_gradient(x);
        case LEAKY:
            return leaky_gradient(x);
        case TANH:
            return tanh_gradient(x);
        case PLSE:
            return plse_gradient(x);
        case STAIR:
            return stair_gradient(x);
        case HARDTAN:
            return hardtan_gradient(x);
        case LHTAN:
            return lhtan_gradient(x);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xd, %rax
ja 0x2e135
movq -0x18(%rbp), %rax
leaq 0x46038(%rip), %rcx     # 0x74064
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss -0x8(%rbp), %xmm0
callq 0x2e150
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e170
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e190
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e1f0
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e220
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e270
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e2e0
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e330
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e370
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e3c0
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e400
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e470
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e4c0
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
movss -0x8(%rbp), %xmm0
callq 0x2e510
movss %xmm0, -0x4(%rbp)
jmp 0x2e13d
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/im2col.c
// Function: im2col_get_pixel
float im2col_get_pixel(float *im, int height, int width, int channels,
                        int row, int col, int channel, int pad)
{
    row -= pad;
    col -= pad;

    if (row < 0 || col < 0 ||
        row >= height || col >= width) return 0;
    return im[col + width*(row + height*channel)];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl 0x18(%rbp), %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movl 0x18(%rbp), %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x2e611
cmpl $0x0, -0x24(%rbp)
jl 0x2e611
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2e611
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x2e61b
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x2e643
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x18(%rbp), %edx
movl -0x20(%rbp), %esi
movl -0x14(%rbp), %edi
imull 0x10(%rbp), %edi
addl %edi, %esi
imull %esi, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/im2col.c
// Function: im2col_cpu
void im2col_cpu(float* data_im,
     int channels,  int height,  int width,
     int ksize,  int stride, int pad, float* data_col) 
{
    int c,h,w;
    int height_col = (height + 2*pad - ksize) / stride + 1;
    int width_col = (width + 2*pad - ksize) / stride + 1;

    int channels_col = channels * ksize * ksize;
    for (c = 0; c < channels_col; ++c) {
        int w_offset = c % ksize;
        int h_offset = (c / ksize) % ksize;
        int c_im = c / ksize / ksize;
        for (h = 0; h < height_col; ++h) {
            for (w = 0; w < width_col; ++w) {
                int im_row = h_offset + h * stride;
                int im_col = w_offset + w * stride;
                int col_index = (c * height_col + h) * width_col + w;
                data_col[col_index] = im2col_get_pixel(data_im, height, width, channels,
                        im_row, im_col, c_im, pad);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x10(%rbp), %eax
movl 0x10(%rbp), %ecx
shll %ecx
addl %ecx, %eax
subl -0x18(%rbp), %eax
cltd
idivl -0x1c(%rbp)
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl 0x10(%rbp), %ecx
shll %ecx
addl %ecx, %eax
subl -0x18(%rbp), %eax
cltd
idivl -0x1c(%rbp)
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x2e79e
movl -0x20(%rbp), %eax
cltd
idivl -0x18(%rbp)
movl %edx, -0x38(%rbp)
movl -0x20(%rbp), %eax
cltd
idivl -0x18(%rbp)
cltd
idivl -0x18(%rbp)
movl %edx, -0x3c(%rbp)
movl -0x20(%rbp), %eax
cltd
idivl -0x18(%rbp)
cltd
idivl -0x18(%rbp)
movl %eax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2e78e
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x2e77e
movl -0x3c(%rbp), %eax
movl -0x24(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x38(%rbp), %eax
movl -0x28(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x48(%rbp)
movl -0x20(%rbp), %eax
imull -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
imull -0x30(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x44(%rbp), %r8d
movl -0x48(%rbp), %r9d
movl -0x40(%rbp), %r10d
movl 0x10(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x2e5c0
movq 0x18(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2e703
jmp 0x2e780
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2e6f0
jmp 0x2e790
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2e6b7
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/col2im.c
// Function: col2im_add_pixel
void col2im_add_pixel(float *im, int height, int width, int channels,
                        int row, int col, int channel, int pad, float val)
{
    row -= pad;
    col -= pad;

    if (row < 0 || col < 0 ||
        row >= height || col >= width) return;
    im[col + width*(row + height*channel)] += val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movl 0x18(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl 0x18(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x2e806
cmpl $0x0, -0x1c(%rbp)
jl 0x2e806
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2e806
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x2e808
jmp 0x2e835
movss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl -0x10(%rbp), %edx
movl -0x18(%rbp), %esi
movl -0xc(%rbp), %edi
imull 0x10(%rbp), %edi
addl %edi, %esi
imull %esi, %edx
addl %edx, %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: flatten
void flatten(float *x, int size, int layers, int batch, int forward)
{
    float *swap = calloc(size*layers*batch, sizeof(float));
    int i,c,b;
    for(b = 0; b < batch; ++b){
        for(c = 0; c < layers; ++c){
            for(i = 0; i < size; ++i){
                int i1 = b*layers*size + c*size + i;
                int i2 = b*layers*size + i*layers + c;
                if (forward) swap[i2] = x[i1];
                else swap[i1] = x[i2];
            }
        }
    }
    memcpy(x, swap, size*layers*batch*sizeof(float));
    free(swap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2ec5e
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2ec4e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2ec3e
movl -0x2c(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
movl -0x28(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl %ecx, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
movl -0x24(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl %ecx, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2ec14
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x2ec2e
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x2ec30
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ebb2
jmp 0x2ec40
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2eb9f
jmp 0x2ec50
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2eb8c
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x3280
movq -0x20(%rbp), %rdi
callq 0x3030
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: weighted_delta_cpu
void weighted_delta_cpu(float *a, float *b, float *s, float *da, float *db, float *ds, int n, float *dc)
{
    int i;
    for(i = 0; i < n; ++i){
        if(da) da[i] += dc[i] * s[i];
        if(db) db[i] += dc[i] * (1-s[i]);
        ds[i] += dc[i] * (a[i] - b[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x2ee63
cmpq $0x0, -0x20(%rbp)
je 0x2edd1
movq 0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
cmpq $0x0, -0x28(%rbp)
je 0x2ee14
movq 0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss 0x42217(%rip), %xmm2    # 0x7100c
subss (%rax,%rcx,4), %xmm2
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq 0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
subss (%rax,%rcx,4), %xmm2
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2ed8a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: mean_cpu
void mean_cpu(float *x, int batch, int filters, int spatial, float *mean)
{
    float scale = 1./(batch * spatial);
    int i,j,k;
    for(i = 0; i < filters; ++i){
        mean[i] = 0;
        for(j = 0; j < batch; ++j){
            for(k = 0; k < spatial; ++k){
                int index = j*filters*spatial + i*spatial + k;
                mean[i] += x[index];
            }
        }
        mean[i] *= scale;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl -0xc(%rbp), %eax
imull -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm1
movsd 0x41f78(%rip), %xmm0    # 0x71060
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2f1ac
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2f187
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f17a
movl -0x2c(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movl -0x28(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl %ecx, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2f12e
jmp 0x2f17c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2f11f
movss -0x24(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2f0fc
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: variance_cpu
void variance_cpu(float *x, float *mean, int batch, int filters, int spatial, float *variance)
{
    float scale = 1./(batch * spatial - 1);
    int i,j,k;
    for(i = 0; i < filters; ++i){
        variance[i] = 0;
        for(j = 0; j < batch; ++j){
            for(k = 0; k < spatial; ++k){
                int index = j*filters*spatial + i*spatial + k;
                variance[i] += pow((x[index] - mean[i]), 2);
            }
        }
        variance[i] *= scale;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0x14(%rbp), %eax
imull -0x1c(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0x41e7c(%rip), %xmm0    # 0x71060
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2f2dc
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f2b7
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2f2a7
movl -0x34(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl -0x30(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x41de2(%rip), %xmm1    # 0x71058
callq 0x30e0
movaps %xmm0, %xmm1
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2f22e
jmp 0x2f2a9
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2f21b
movss -0x2c(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2f1f8
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: l2normalize_cpu
void l2normalize_cpu(float *x, float *dx, int batch, int filters, int spatial)
{
    int b,f,i;
    for(b = 0; b < batch; ++b){
        for(i = 0; i < spatial; ++i){
            float sum = 0;
            for(f = 0; f < filters; ++f){
                int index = b*filters*spatial + f*spatial + i;
                sum += powf(x[index], 2);
            }
            sum = sqrtf(sum);
            for(f = 0; f < filters; ++f){
                int index = b*filters*spatial + f*spatial + i;
                x[index] /= sum;
                dx[index] = (1 - x[index]) / sum;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f435
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2f425
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2f390
movl -0x20(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl -0x24(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x41e9a(%rip), %xmm1    # 0x71210
callq 0x3320
addss -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2f33f
movss -0x2c(%rbp), %xmm0
callq 0x32b0
movss %xmm0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2f415
movl -0x20(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl -0x24(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
movss -0x2c(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss 0x41c19(%rip), %xmm0    # 0x7100c
subss (%rax,%rcx,4), %xmm0
divss -0x2c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2f3a6
jmp 0x2f417
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2f324
jmp 0x2f427
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2f311
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: normalize_cpu
void normalize_cpu(float *x, float *mean, float *variance, int batch, int filters, int spatial)
{
    int b, f, i;
    for(b = 0; b < batch; ++b){
        for(f = 0; f < filters; ++f){
            for(i = 0; i < spatial; ++i){
                int index = b*filters*spatial + f*spatial + i;
                x[index] = (x[index] - mean[f])/(sqrt(variance[f]) + .000001f);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2f542
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2f532
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2f522
movl -0x28(%rbp), %eax
imull -0x20(%rbp), %eax
imull -0x24(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl %ecx, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3430
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
movsd 0x44c75(%rip), %xmm2    # 0x74170
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2f48c
jmp 0x2f524
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2f479
jmp 0x2f534
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2f466
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: deinter_cpu
void deinter_cpu(int NX, float *X, int NY, float *Y, int B, float *OUT)
{
    int i, j;
    int index = 0;
    for(j = 0; j < B; ++j) {
        for(i = 0; i < NX; ++i){
            if(X) X[j*NX + i] += OUT[index];
            ++index;
        }
        for(i = 0; i < NY; ++i){
            if(Y) Y[j*NY + i] += OUT[index];
            ++index;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2f878
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2f816
cmpq $0x0, -0x10(%rbp)
je 0x2f802
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movl -0x38(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2f7cb
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f868
cmpq $0x0, -0x20(%rbp)
je 0x2f854
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rax
movl -0x38(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2f81d
jmp 0x2f86a
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2f7b8
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: inter_cpu
void inter_cpu(int NX, float *X, int NY, float *Y, int B, float *OUT)
{
    int i, j;
    int index = 0;
    for(j = 0; j < B; ++j) {
        for(i = 0; i < NX; ++i){
            OUT[index++] = X[j*NX + i];
        }
        for(i = 0; i < NY; ++i){
            OUT[index++] = Y[j*NY + i];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2f952
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2f8fb
movq -0x10(%rbp), %rax
movl -0x38(%rbp), %ecx
imull -0x4(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x3c(%rbp)
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2f8bb
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2f942
movq -0x20(%rbp), %rax
movl -0x38(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x3c(%rbp)
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2f902
jmp 0x2f944
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2f8a8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: smooth_l1_cpu
void smooth_l1_cpu(int n, float *pred, float *truth, float *delta, float *error)
{
    int i;
    for(i = 0; i < n; ++i){
        float diff = truth[i] - pred[i];
        float abs_val = fabs(diff);
        if(abs_val < 1) {
            error[i] = diff * diff;
            delta[i] = diff;
        }
        else {
            error[i] = 2*abs_val - 1;
            delta[i] = (diff < 0) ? 1 : -1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2fb2a
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x416a7(%rip), %xmm1    # 0x71130
pand %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movss 0x4156e(%rip), %xmm0    # 0x7100c
ucomiss -0x34(%rbp), %xmm0
jbe 0x2facf
movss -0x30(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x2fb1a
movss -0x34(%rbp), %xmm0
addss %xmm0, %xmm0
movss 0x445fc(%rip), %xmm1    # 0x740dc
addss %xmm1, %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x30(%rbp), %xmm1
xorps %xmm0, %xmm0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
ucomiss %xmm1, %xmm0
cmoval %ecx, %eax
cvtsi2ss %eax, %xmm0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x2fb1c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fa4e
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: l1_cpu
void l1_cpu(int n, float *pred, float *truth, float *delta, float *error)
{
    int i;
    for(i = 0; i < n; ++i){
        float diff = truth[i] - pred[i];
        error[i] = fabs(diff);
        delta[i] = diff > 0 ? 1 : -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2fbce
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x415ab(%rip), %xmm1    # 0x71130
pand %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
ucomiss %xmm1, %xmm0
cmoval %ecx, %eax
cvtsi2ss %eax, %xmm0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fb4e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: softmax_x_ent_cpu
void softmax_x_ent_cpu(int n, float *pred, float *truth, float *delta, float *error)
{
    int i;
    for(i = 0; i < n; ++i){
        float t = truth[i];
        float p = pred[i];
        error[i] = (t) ? -log(p) : 0;
        delta[i] = t-p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2fca4
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2fc33
jp 0x2fc33
jmp 0x2fc5f
movss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x31a0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x2fc69
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x2fc69
movsd -0x40(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x30(%rbp), %xmm0
subss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fbf2
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: logistic_x_ent_cpu
void logistic_x_ent_cpu(int n, float *pred, float *truth, float *delta, float *error)
{
    int i;
    for(i = 0; i < n; ++i){
        float t = truth[i];
        float p = pred[i];
        error[i] = -t*log(p) - (1-t)*log(1-p);
        delta[i] = t-p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2fdc7
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x31a0
movsd %xmm0, -0x48(%rbp)
movss 0x412d4(%rip), %xmm0    # 0x7100c
subss -0x30(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movss 0x412be(%rip), %xmm0    # 0x7100c
subss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x31a0
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x40(%rbp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x30(%rbp), %xmm0
subss -0x34(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fcd2
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: l2_cpu
void l2_cpu(int n, float *pred, float *truth, float *delta, float *error)
{
    int i;
    for(i = 0; i < n; ++i){
        float diff = truth[i] - pred[i];
        error[i] = diff * diff;
        delta[i] = diff;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2fe49
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
subss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fdee
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: softmax
void softmax(float *input, int n, float temp, int stride, float *output)
{
    int i;
    float sum = 0;
    float largest = -FLT_MAX;
    for(i = 0; i < n; ++i){
        if(input[i*stride] > largest) largest = input[i*stride];
    }
    for(i = 0; i < n; ++i){
        float e = exp(input[i*stride]/temp - largest/temp);
        sum += e;
        output[i*stride] = e;
    }
    for(i = 0; i < n; ++i){
        output[i*stride] /= sum;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss 0x44271(%rip), %xmm0    # 0x7416c
movss %xmm0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2ff4d
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss -0x2c(%rbp), %xmm0
jbe 0x2ff40
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0x2ff42
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ff07
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2ffc6
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
divss -0x10(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
divss -0x10(%rbp), %xmm1
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x34a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
addss -0x28(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ff54
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x30001
movss -0x28(%rbp), %xmm1
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ffcd
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: softmax_cpu
void softmax_cpu(float *input, int n, int batch, int batch_offset, int groups, int group_offset, int stride, float temp, float *output)
{
    int g, b;
    for(b = 0; b < batch; ++b){
        for(g = 0; g < groups; ++g){
            softmax(input + b*batch_offset + g*group_offset, n, temp, stride, output + b*batch_offset + g*group_offset);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x300ce
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x300be
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %eax
imull -0x14(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
movl -0x24(%rbp), %eax
imull -0x1c(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
movss -0x20(%rbp), %xmm0
movl 0x10(%rbp), %edx
movq 0x18(%rbp), %rcx
movl -0x28(%rbp), %eax
imull -0x14(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rcx
movl -0x24(%rbp), %eax
imull -0x1c(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rcx
callq 0x2fed0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x30053
jmp 0x300c0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x30040
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/blas.c
// Function: upsample_cpu
void upsample_cpu(float *in, int w, int h, int c, int batch, int stride, int forward, float scale, float *out)
{
    int i, j, k, b;
    for(b = 0; b < batch; ++b){
        for(k = 0; k < c; ++k){
            for(j = 0; j < h*stride; ++j){
                for(i = 0; i < w*stride; ++i){
                    int in_index = b*w*h*c + k*w*h + (j/stride)*w + i/stride;
                    int out_index = b*w*h*c*stride*stride + k*w*h*stride*stride + j*w*stride + i;
                    if(forward) out[out_index] = scale*in[in_index];
                    else in[in_index] += scale*out[out_index];
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x30274
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x30264
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x10(%rbp), %ecx
imull -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x30254
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0xc(%rbp), %ecx
imull -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x30244
movl -0x30(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x40(%rbp)
movl -0x28(%rbp), %eax
cltd
idivl -0x1c(%rbp)
movl %eax, %ecx
movl -0x40(%rbp), %eax
imull -0xc(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x24(%rbp), %eax
cltd
idivl -0x1c(%rbp)
movl %eax, %ecx
movl -0x3c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
imull -0x1c(%rbp), %eax
imull -0x1c(%rbp), %eax
movl -0x2c(%rbp), %ecx
imull -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
imull -0x1c(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
movl -0x28(%rbp), %ecx
imull -0xc(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0x30208
movss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
mulss (%rax,%rcx,4), %xmm0
movq 0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x30234
movss -0x20(%rbp), %xmm0
movq 0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x30236
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3014b
jmp 0x30246
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x30132
jmp 0x30256
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3011f
jmp 0x30266
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3010c
popq %rbp
retq
nopw %cs:(%rax,%rax)