LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: place_image
void place_image(image im, int w, int h, int dx, int dy, image canvas)
{
    int x, y, c;
    for(c = 0; c < im.c; ++c){
        for(y = 0; y < h; ++y){
            for(x = 0; x < w; ++x){
                float rx = ((float)x / w) * im.w;
                float ry = ((float)y / h) * im.h;
                float val = bilinear_interpolate(im, rx, ry, c);
                set_pixel(canvas, x + dx, y + dy, c, val);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x119b0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x119a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x11990
movq -0x30(%rbp), %rax
cvtsi2ssl -0x14(%rbp), %xmm0
cvtsi2ssl -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
cvtsi2ssl (%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
cvtsi2ssl -0x18(%rbp), %xmm0
cvtsi2ssl -0x8(%rbp), %xmm1
divss %xmm1, %xmm0
cvtsi2ssl 0x4(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movl -0x1c(%rbp), %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x119c0
movq -0x38(%rbp), %rax
movss %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %edi
addl -0xc(%rbp), %edi
movl -0x18(%rbp), %esi
addl -0x10(%rbp), %esi
movl -0x1c(%rbp), %edx
movss -0x28(%rbp), %xmm0
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe6b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x118d5
jmp 0x11992
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x118c2
jmp 0x119a2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x118ab
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: bilinear_interpolate
static float bilinear_interpolate(image im, float x, float y, int c)
{
    int ix = (int) floorf(x);
    int iy = (int) floorf(y);

    float dx = x - ix;
    float dy = y - iy;

    float val = (1-dy) * (1-dx) * get_pixel_extend(im, ix, iy, c) + 
        dy     * (1-dx) * get_pixel_extend(im, ix, iy+1, c) + 
        (1-dy) *   dx   * get_pixel_extend(im, ix+1, iy, c) +
        dy     *   dx   * get_pixel_extend(im, ix+1, iy+1, c);
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x3390
cvttss2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x3390
movq -0x38(%rbp), %rax
cvttss2si %xmm0, %ecx
movl %ecx, -0x14(%rbp)
movss -0x4(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x8(%rbp), %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss 0x5f5db(%rip), %xmm0    # 0x7100c
subss -0x1c(%rbp), %xmm0
movss 0x5f5ce(%rip), %xmm1    # 0x7100c
subss -0x18(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movl -0x10(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe610
movq -0x38(%rbp), %rax
movss %xmm0, -0x44(%rbp)
movss -0x1c(%rbp), %xmm0
movss 0x5f583(%rip), %xmm1    # 0x7100c
subss -0x18(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x48(%rbp)
movl -0x10(%rbp), %edi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe610
movss -0x48(%rbp), %xmm1
movss -0x44(%rbp), %xmm2
movq -0x38(%rbp), %rax
movaps %xmm0, %xmm3
movss -0x40(%rbp), %xmm0
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
movss 0x5f51c(%rip), %xmm0    # 0x7100c
subss -0x1c(%rbp), %xmm0
mulss -0x18(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movl -0x10(%rbp), %edi
addl $0x1, %edi
movl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe610
movss -0x3c(%rbp), %xmm1
movq -0x38(%rbp), %rax
movaps %xmm0, %xmm2
movss -0x2c(%rbp), %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x1c(%rbp), %xmm0
mulss -0x18(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movl -0x10(%rbp), %edi
addl $0x1, %edi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe610
movss -0x28(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x24(%rbp), %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: center_crop_image
image center_crop_image(image im, int w, int h)
{
    int m = (im.w < im.h) ? im.w : im.h;   
    image c = crop_image(im, (im.w - m) / 2, (im.h - m)/2, m, m);
    image r = resize_image(c, w, h);
    free_image(c);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jge 0x11be0
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x11bea
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rax
movl -0x44(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movl (%rax), %eax
subl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
subl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl -0xc(%rbp), %r8d
leaq -0x28(%rbp), %rdi
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x11ca0
movq -0x40(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
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 0xfc00
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 0xedb0
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: crop_image
image crop_image(image im, int dx, int dy, int w, int h)
{
    image cropped = make_image(w, h, im.c);
    int i, j, k;
    for(k = 0; k < im.c; ++k){
        for(j = 0; j < h; ++j){
            for(i = 0; i < w; ++i){
                int r = j + dy;
                int c = i + dx;
                float val = 0;
                r = constrain_int(r, 0, im.h-1);
                c = constrain_int(c, 0, im.w-1);
                val = get_pixel(im, c, r, k);
                set_pixel(cropped, i, j, k, val);
            }
        }
    }
    return cropped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl 0x8(%rax), %ecx
callq 0xe3e0
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x11dec
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x11ddc
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11dcc
movq -0x30(%rbp), %rax
movl -0x18(%rbp), %ecx
addl -0x8(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movl -0x14(%rbp), %ecx
addl -0x4(%rbp), %ecx
movl %ecx, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movl -0x20(%rbp), %edi
movl 0x4(%rax), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x5760
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x20(%rbp)
movl -0x24(%rbp), %edi
movl (%rax), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x5760
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe580
movq -0x40(%rbp), %rax
movss %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movss -0x28(%rbp), %xmm0
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe6b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11d07
jmp 0x11dce
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11cf4
jmp 0x11dde
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11cdd
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: best_3d_shift
int best_3d_shift(image a, image b, int min, int max)
{
    int i;
    int best = 0;
    float best_distance = FLT_MAX;
    for(i = min; i <= max; i += 2){
        image c = crop_image(b, 0, i, b.w, b.h);
        float d = dist_array(c.data, a.data, a.w*a.h*a.c, 100);
        if(d < best_distance){
            best_distance = d;
            best = i;
        }
        printf("%d %f\n", i, d);
        free_image(c);
    }
    return best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movss 0x5eb77(%rip), %xmm0    # 0x71224
movss %xmm0, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x12783
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %edx
movl (%rax), %ecx
movl 0x4(%rax), %r8d
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x11ca0
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x10(%rax), %rsi
movl (%rax), %edx
imull 0x4(%rax), %edx
imull 0x8(%rax), %edx
movl $0x64, %ecx
callq 0x5800
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x12739
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %esi
movss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x60a1a(%rip), %rdi     # 0x73166
movb $0x1, %al
callq 0x3130
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
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x126b8
movl -0x10(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: load_image
image load_image(char *filename, int w, int h, int c)
{
    image out = load_image_stb(filename, c);

    if((h && w) && (h != out.h || w != out.w)){
        image resized = resize_image(out, w, h);
        free_image(out);
        out = resized;
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x14ff0
cmpl $0x0, -0x10(%rbp)
je 0x12b21
cmpl $0x0, -0xc(%rbp)
je 0x12b21
movq -0x40(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x12ab8
movq -0x40(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
je 0x12b21
movq -0x40(%rbp), %rax
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x30(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xfc00
movq -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 0xedb0
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: letterbox_image_into
void letterbox_image_into(image im, int w, int h, image boxed)
{
    int new_w = im.w;
    int new_h = im.h;
    if (((float)w/im.w) < ((float)h/im.h)) {
        new_w = w;
        new_h = (im.h * w)/im.w;
    } else {
        new_h = h;
        new_w = (im.w * h)/im.h;
    }
    image resized = resize_image(im, new_w, new_h);
    embed_image(resized, boxed, (w-new_w)/2, (h-new_h)/2); 
    free_image(resized);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl (%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x4(%rax), %ecx
movl %ecx, -0x10(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm1
cvtsi2ssl (%rax), %xmm0
divss %xmm0, %xmm1
cvtsi2ssl -0x8(%rbp), %xmm0
cvtsi2ssl 0x4(%rax), %xmm2
divss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x12b92
movq -0x30(%rbp), %rcx
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0x4(%rcx), %eax
imull -0x4(%rbp), %eax
cltd
idivl (%rcx)
movl %eax, -0x10(%rbp)
jmp 0x12ba9
movq -0x30(%rbp), %rcx
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl (%rcx), %eax
imull -0x8(%rbp), %eax
cltd
idivl 0x4(%rcx)
movl %eax, -0xc(%rbp)
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x28(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xfc00
movl -0x4(%rbp), %eax
subl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edi
movl -0x8(%rbp), %eax
subl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq -0x38(%rbp), %rax
leaq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0xeae0
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 0xedb0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: letterbox_image
image letterbox_image(image im, int w, int h)
{
    int new_w = im.w;
    int new_h = im.h;
    if (((float)w/im.w) < ((float)h/im.h)) {
        new_w = w;
        new_h = (im.h * w)/im.w;
    } else {
        new_h = h;
        new_w = (im.w * h)/im.h;
    }
    image resized = resize_image(im, new_w, new_h);
    image boxed = make_image(w, h, im.c);
    fill_image(boxed, .5);
    //int i;
    //for(i = 0; i < boxed.w*boxed.h*boxed.c; ++i) boxed.data[i] = 0;
    embed_image(resized, boxed, (w-new_w)/2, (h-new_h)/2); 
    free_image(resized);
    return boxed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl (%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x4(%rax), %ecx
movl %ecx, -0x10(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm1
cvtsi2ssl (%rax), %xmm0
divss %xmm0, %xmm1
cvtsi2ssl -0x8(%rbp), %xmm0
cvtsi2ssl 0x4(%rax), %xmm2
divss %xmm2, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x12cc2
movq -0x30(%rbp), %rcx
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0x4(%rcx), %eax
imull -0x4(%rbp), %eax
cltd
idivl (%rcx)
movl %eax, -0x10(%rbp)
jmp 0x12cd9
movq -0x30(%rbp), %rcx
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl (%rcx), %eax
imull -0x8(%rbp), %eax
cltd
idivl 0x4(%rcx)
movl %eax, -0xc(%rbp)
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x28(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xfc00
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl 0x8(%rax), %ecx
callq 0xe3e0
movq -0x40(%rbp), %rax
movss 0x5e4c5(%rip), %xmm0    # 0x711ec
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x12370
movl -0x4(%rbp), %eax
subl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edi
movl -0x8(%rbp), %eax
subl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq -0x40(%rbp), %rax
leaq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0xeae0
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 0xedb0
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: resize_max
image resize_max(image im, int max)
{
    int w = im.w;
    int h = im.h;
    if(w > h){
        h = (h * max) / w;
        w = max;
    } else {
        w = (w * max) / h;
        h = max;
    }
    if(w == im.w && h == im.h) return im;
    image resized = resize_image(im, w, h);
    return resized;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl (%rax), %ecx
movl %ecx, -0x8(%rbp)
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x12e24
movl -0xc(%rbp), %eax
imull -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x12e38
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl (%rcx), %eax
jne 0x12e6f
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x12e6f
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x12e9b
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xfc00
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: resize_min
image resize_min(image im, int min)
{
    int w = im.w;
    int h = im.h;
    if(w < h){
        h = (h * min) / w;
        w = min;
    } else {
        w = (w * min) / h;
        h = min;
    }
    if(w == im.w && h == im.h) return im;
    image resized = resize_image(im, w, h);
    return resized;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl (%rax), %ecx
movl %ecx, -0x8(%rbp)
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x12ef4
movl -0xc(%rbp), %eax
imull -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x12f08
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl (%rcx), %eax
jne 0x12f3f
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x12f3f
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x12f6b
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xfc00
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: random_crop_image
image random_crop_image(image im, int w, int h)
{
    int dx = rand_int(0, im.w - w);
    int dy = rand_int(0, im.h - h);
    image crop = crop_image(im, dx, dy, w, h);
    return crop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl (%rax), %esi
subl -0x4(%rbp), %esi
xorl %edi, %edi
callq 0x5d00
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl 0x4(%rax), %esi
subl -0x8(%rbp), %esi
xorl %edi, %edi
callq 0x5d00
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x11ca0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: grayscale_image_3c
void grayscale_image_3c(image im)
{
    assert(im.c == 3);
    int i, j, k;
    float scale[] = {0.299, 0.587, 0.114};
    for(j = 0; j < im.h; ++j){
        for(i = 0; i < im.w; ++i){
            float val = 0;
            for(k = 0; k < 3; ++k){
                val += scale[k]*get_pixel(im, i, j, k);
            }
            im.data[0*im.h*im.w + im.w*j + i] = val;
            im.data[1*im.h*im.w + im.w*j + i] = val;
            im.data[2*im.h*im.w + im.w*j + i] = val;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x3, 0x8(%rax)
jne 0x13f58
jmp 0x13f77
leaq 0x5f21b(%rip), %rdi     # 0x7317a
leaq 0x5f143(%rip), %rsi     # 0x730a9
movl $0x40f, %edx            # imm = 0x40F
leaq 0x5f26e(%rip), %rcx     # 0x731e0
callq 0x3180
movq 0x5d526(%rip), %rax     # 0x714a4
movq %rax, -0x18(%rbp)
movl 0x5d524(%rip), %eax     # 0x714ac
movl %eax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x28(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x140ba
movl $0x0, -0x4(%rbp)
movq -0x28(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl (%rcx), %eax
jge 0x140aa
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x1402c
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss -0x18(%rbp,%rcx,4), %xmm0
movss %xmm0, -0x2c(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe580
movaps %xmm0, %xmm2
movss -0x2c(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13fc7
movq -0x28(%rbp), %rdx
movss -0x1c(%rbp), %xmm0
movq 0x10(%rdx), %rax
imull $0x0, 0x4(%rdx), %ecx
imull (%rdx), %ecx
movl (%rdx), %esi
imull -0x8(%rbp), %esi
addl %esi, %ecx
addl -0x4(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x1c(%rbp), %xmm0
movq 0x10(%rdx), %rax
movl 0x4(%rdx), %ecx
shll $0x0, %ecx
imull (%rdx), %ecx
movl (%rdx), %esi
imull -0x8(%rbp), %esi
addl %esi, %ecx
addl -0x4(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x1c(%rbp), %xmm0
movq 0x10(%rdx), %rax
movl 0x4(%rdx), %ecx
shll %ecx
imull (%rdx), %ecx
movl (%rdx), %edx
imull -0x8(%rbp), %edx
addl %edx, %ecx
addl -0x4(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13fa9
jmp 0x140ac
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x13f92
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: grayscale_image
image grayscale_image(image im)
{
    assert(im.c == 3);
    int i, j, k;
    image gray = make_image(im.w, im.h, 1);
    float scale[] = {0.299, 0.587, 0.114};
    for(k = 0; k < im.c; ++k){
        for(j = 0; j < im.h; ++j){
            for(i = 0; i < im.w; ++i){
                gray.data[i+im.w*j] += scale[k]*get_pixel(im, i, j, k);
            }
        }
    }
    return gray;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, 0x8(%rax)
jne 0x140e0
jmp 0x140ff
leaq 0x5f093(%rip), %rdi     # 0x7317a
leaq 0x5efbb(%rip), %rsi     # 0x730a9
movl $0x421, %edx            # imm = 0x421
leaq 0x5f105(%rip), %rcx     # 0x731ff
callq 0x3180
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
movl $0x1, %ecx
callq 0xe3e0
movq 0x5d393(%rip), %rax     # 0x714b0
movq %rax, -0x18(%rbp)
movl 0x5d391(%rip), %eax     # 0x714b8
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x14206
movl $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x141f6
movl $0x0, -0x4(%rbp)
movq -0x20(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl (%rcx), %eax
jge 0x141e6
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss -0x18(%rbp,%rcx,4), %xmm0
movss %xmm0, -0x34(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe580
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdx
movaps %xmm0, %xmm2
movss -0x34(%rbp), %xmm0
movq 0x10(%rax), %rax
movl -0x4(%rbp), %ecx
movl (%rdx), %edx
imull -0x8(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1415f
jmp 0x141e8
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x14148
jmp 0x141f8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14131
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: blend_image
image blend_image(image fore, image back, float alpha)
{
    assert(fore.w == back.w && fore.h == back.h && fore.c == back.c);
    image blend = make_image(fore.w, fore.h, fore.c);
    int i, j, k;
    for(k = 0; k < fore.c; ++k){
        for(j = 0; j < fore.h; ++j){
            for(i = 0; i < fore.w; ++i){
                float val = alpha * get_pixel(fore, i, j, k) + 
                    (1 - alpha)* get_pixel(back, i, j, k);
                set_pixel(blend, i, j, k, val);
            }
        }
    }
    return blend;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
leaq 0x28(%rbp), %rcx
movq %rcx, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss %xmm0, -0x4(%rbp)
movl (%rax), %eax
cmpl (%rcx), %eax
jne 0x1425d
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl 0x4(%rcx), %eax
jne 0x1425d
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x8(%rcx), %eax
jne 0x1425d
jmp 0x1427c
leaq 0x5efb8(%rip), %rdi     # 0x7321c
leaq 0x5ee3e(%rip), %rsi     # 0x730a9
movl $0x43b, %edx            # imm = 0x43B
leaq 0x5efde(%rip), %rcx     # 0x73255
callq 0x3180
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
movl 0x8(%rax), %ecx
callq 0xe3e0
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x143cd
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x143bd
movl $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl (%rcx), %eax
jge 0x143ad
movq -0x20(%rbp), %rax
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe580
movq -0x28(%rbp), %rax
movss %xmm0, -0x40(%rbp)
movss 0x5ccf1(%rip), %xmm0    # 0x7100c
subss -0x4(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe580
movss -0x44(%rbp), %xmm1
movss -0x40(%rbp), %xmm2
movq -0x38(%rbp), %rax
movaps %xmm0, %xmm3
movss -0x3c(%rbp), %xmm0
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movss -0x14(%rbp), %xmm0
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe6b0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x142c6
jmp 0x143af
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x142af
jmp 0x143bf
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14298
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: scale_image_channel
void scale_image_channel(image im, int c, float v)
{
    int i, j;
    for(j = 0; j < im.h; ++j){
        for(i = 0; i < im.w; ++i){
            float pix = get_pixel(im, i, j, c);
            pix = pix*v;
            set_pixel(im, i, j, c, pix);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x144ae
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1449e
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movl -0x4(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe580
movq -0x20(%rbp), %rax
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movl -0x4(%rbp), %edx
movss -0x14(%rbp), %xmm0
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe6b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14416
jmp 0x144a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x143ff
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: binarize_image
image binarize_image(image im)
{
    image c = copy_image(im);
    int i;
    for(i = 0; i < im.w * im.h * im.c; ++i){
        if(c.data[i] > .5) c.data[i] = 1;
        else c.data[i] = 0;
    }
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xea60
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rdx
movl -0x4(%rbp), %eax
movl (%rdx), %ecx
imull 0x4(%rdx), %ecx
imull 0x8(%rdx), %ecx
cmpl %ecx, %eax
jge 0x14654
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x4(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5e836(%rip), %xmm1    # 0x72e48
ucomisd %xmm1, %xmm0
jbe 0x14633
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x4(%rbp), %rcx
movss 0x5c9e0(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
jmp 0x14647
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x4(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x14649
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x145e0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: saturate_image
void saturate_image(image im, float sat)
{
    rgb_to_hsv(im);
    scale_image_channel(im, 1, sat);
    hsv_to_rgb(im);
    constrain_image(im);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movss %xmm0, -0x4(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x138d0
movq -0x10(%rbp), %rax
movss -0x4(%rbp), %xmm0
movl $0x1, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x143e0
movq -0x10(%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 0x13bb0
movq -0x10(%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 0x10db0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: hue_image
void hue_image(image im, float hue)
{
    rgb_to_hsv(im);
    int i;
    for(i = 0; i < im.w*im.h; ++i){
        im.data[i] = im.data[i] + hue;
        if (im.data[i] > 1) im.data[i] -= 1;
        if (im.data[i] < 0) im.data[i] += 1;
    }
    hsv_to_rgb(im);
    constrain_image(im);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movss %xmm0, -0x4(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x138d0
movl $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rdx
movl -0x8(%rbp), %eax
movl (%rdx), %ecx
imull 0x4(%rdx), %ecx
cmpl %ecx, %eax
jge 0x14801
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x8(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
addss -0x4(%rbp), %xmm0
movq 0x10(%rax), %rcx
movslq -0x8(%rbp), %rdx
movss %xmm0, (%rcx,%rdx,4)
movq 0x10(%rax), %rax
movslq -0x8(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x5c875(%rip), %xmm1    # 0x7100c
ucomiss %xmm1, %xmm0
jbe 0x147be
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x8(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x5c857(%rip), %xmm1    # 0x7100c
subss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x8(%rbp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x147f1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x8(%rbp), %rcx
movss 0x5c825(%rip), %xmm0    # 0x7100c
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x147f3
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1474a
movq -0x10(%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 0x13bb0
movq -0x10(%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 0x10db0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: exposure_image
void exposure_image(image im, float sat)
{
    rgb_to_hsv(im);
    scale_image_channel(im, 2, sat);
    hsv_to_rgb(im);
    constrain_image(im);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movss %xmm0, -0x4(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x138d0
movq -0x10(%rbp), %rax
movss -0x4(%rbp), %xmm0
movl $0x2, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x143e0
movq -0x10(%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 0x13bb0
movq -0x10(%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 0x10db0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: distort_image
void distort_image(image im, float hue, float sat, float val)
{
    rgb_to_hsv(im);
    scale_image_channel(im, 1, sat);
    scale_image_channel(im, 2, val);
    int i;
    for(i = 0; i < im.w*im.h; ++i){
        im.data[i] = im.data[i] + hue;
        if (im.data[i] > 1) im.data[i] -= 1;
        if (im.data[i] < 0) im.data[i] += 1;
    }
    hsv_to_rgb(im);
    constrain_image(im);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x138d0
movq -0x18(%rbp), %rax
movss -0x8(%rbp), %xmm0
movl $0x1, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x143e0
movq -0x18(%rbp), %rax
movss -0xc(%rbp), %xmm0
movl $0x2, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x143e0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdx
movl -0x10(%rbp), %eax
movl (%rdx), %ecx
imull 0x4(%rdx), %ecx
cmpl %ecx, %eax
jge 0x14a53
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x10(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
addss -0x4(%rbp), %xmm0
movq 0x10(%rax), %rcx
movslq -0x10(%rbp), %rdx
movss %xmm0, (%rcx,%rdx,4)
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x5c623(%rip), %xmm1    # 0x7100c
ucomiss %xmm1, %xmm0
jbe 0x14a10
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x5c605(%rip), %xmm1    # 0x7100c
subss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x14a43
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movss 0x5c5d3(%rip), %xmm0    # 0x7100c
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x14a45
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1499c
movq -0x18(%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 0x13bb0
movq -0x18(%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 0x10db0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: random_distort_image
void random_distort_image(image im, float hue, float saturation, float exposure)
{
    float dhue = rand_uniform(-hue, hue);
    float dsat = rand_scale(saturation);
    float dexp = rand_scale(exposure);
    distort_image(im, dhue, dsat, dexp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss -0x4(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss -0x4(%rbp), %xmm1
callq 0x5b30
movss %xmm0, -0x10(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x5f80
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
callq 0x5f80
movq -0x20(%rbp), %rax
movss %xmm0, -0x18(%rbp)
movss -0x10(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
movss -0x18(%rbp), %xmm2
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x14900
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: saturate_exposure_image
void saturate_exposure_image(image im, float sat, float exposure)
{
    rgb_to_hsv(im);
    scale_image_channel(im, 1, sat);
    scale_image_channel(im, 2, exposure);
    hsv_to_rgb(im);
    constrain_image(im);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x138d0
movq -0x10(%rbp), %rax
movss -0x4(%rbp), %xmm0
movl $0x1, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x143e0
movq -0x10(%rbp), %rax
movss -0x8(%rbp), %xmm0
movl $0x2, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x143e0
movq -0x10(%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 0x13bb0
movq -0x10(%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 0x10db0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: load_image_stb
image load_image_stb(char *filename, int channels)
{
    int w, h, c;
    unsigned char *data = stbi_load(filename, &w, &h, &c, channels);
    if (!data) {
        fprintf(stderr, "Cannot load image \"%s\"\nSTB Reason: %s\n", filename, stbi_failure_reason());
        exit(0);
    }
    if(channels) c = channels;
    int i,j,k;
    image im = make_image(w, h, c);
    for(k = 0; k < c; ++k){
        for(j = 0; j < h; ++j){
            for(i = 0; i < w; ++i){
                int dst_index = i + w*j + w*h*k;
                int src_index = k + c*i + c*w*j;
                im.data[dst_index] = (float)data[src_index]/255.;
            }
        }
    }
    free(data);
    return im;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %r8d
leaq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x90e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15066
movq 0x6dfc6(%rip), %rax     # 0x82ff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x9090
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x5e24b(%rip), %rsi     # 0x732a3
movb $0x0, %al
callq 0x3240
xorl %edi, %edi
callq 0x3400
cmpl $0x0, -0xc(%rbp)
je 0x15072
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0xe3e0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x15162
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15152
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x15142
movq -0x48(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x10(%rbp), %edx
movl -0x28(%rbp), %edi
movl %edx, %esi
imull %edi, %esi
addl %esi, %ecx
movl -0x14(%rbp), %esi
imull %esi, %edx
movl -0x2c(%rbp), %esi
imull %esi, %edx
addl %edx, %ecx
movl %ecx, -0x30(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x18(%rbp), %edx
movl -0x24(%rbp), %edi
movl %edx, %esi
imull %edi, %esi
addl %esi, %ecx
movl -0x10(%rbp), %esi
imull %esi, %edx
movl -0x28(%rbp), %esi
imull %esi, %edx
addl %edx, %ecx
movl %ecx, -0x34(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cvtsi2ss %ecx, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5ddb1(%rip), %xmm1    # 0x72ed0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x10(%rax), %rax
movslq -0x30(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x150b1
jmp 0x15144
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1509e
jmp 0x15154
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1508b
movq -0x20(%rbp), %rdi
callq 0x3030
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: print_image
void print_image(image m)
{
    int i, j, k;
    for(i =0 ; i < m.c; ++i){
        for(j =0 ; j < m.h; ++j){
            for(k = 0; k < m.w; ++k){
                printf("%.2lf, ", m.data[i*m.h*m.w + j*m.w + k]);
                if(k > 30) break;
            }
            printf("\n");
            if(j > 30) break;
        }
        printf("\n");
    }
    printf("\n");
}

// 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 0x8(%rcx), %eax
jge 0x1525e
movl $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x15242
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1521c
movq -0x18(%rbp), %rsi
movq 0x10(%rsi), %rax
movl -0x4(%rbp), %ecx
imull 0x4(%rsi), %ecx
imull (%rsi), %ecx
movl -0x8(%rbp), %edx
imull (%rsi), %edx
addl %edx, %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x5e0ca(%rip), %rdi     # 0x732ca
movb $0x1, %al
callq 0x3130
cmpl $0x1e, -0xc(%rbp)
jle 0x1520f
jmp 0x1521c
jmp 0x15211
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x151c5
leaq 0x60b8b(%rip), %rdi     # 0x75dae
movb $0x0, %al
callq 0x3130
cmpl $0x1e, -0x8(%rbp)
jle 0x15232
jmp 0x15242
jmp 0x15234
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x151ae
leaq 0x60b65(%rip), %rdi     # 0x75dae
movb $0x0, %al
callq 0x3130
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x15197
leaq 0x60b49(%rip), %rdi     # 0x75dae
movb $0x0, %al
callq 0x3130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/image.c
// Function: show_image_normalized
void show_image_normalized(image im, const char *name)
{
    image c = copy_image(im);
    normalize_image(c);
    show_image(c, name, 1);
    free_image(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xea60
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 0x10e50
movq -0x8(%rbp), %rdi
leaq -0x20(%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 -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 0xedb0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)