LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: exclusive_image
void exclusive_image(image src)
{
    int k, j, i;
    int s = src.w*src.h;
    for(k = 0; k < src.c-1; ++k){
        for(i = 0; i < s; ++i){
            if (src.data[k*s + i]){
                for(j = k+1; j < src.c; ++j){
                    src.data[j*s + i] = 0;
                }
            }
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x2c(%rsp), %ecx
imull 0x28(%rsp), %ecx
movl 0x30(%rsp), %eax
decl %eax
movslq %ecx, %rcx
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
testl %eax, %eax
movl $0x0, %edi
cmovgl %eax, %edi
movq 0x38(%rsp), %r8
leaq (,%rcx,4), %r9
leaq (%r8,%rcx,4), %r10
xorps %xmm0, %xmm0
cmpq %rdi, %rdx
je 0x1d5b1
movq %rdx, %r11
imulq %rcx, %r11
leaq (%r8,%r11,4), %r11
movq %r10, %rbx
xorl %r14d, %r14d
cmpq %rsi, %r14
je 0x1d5a6
movss (%r11,%r14,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x1d588
jnp 0x1d59d
movq %rbx, %r15
movq %rax, %r12
subq $0x1, %r12
jb 0x1d59d
andl $0x0, (%r15)
addq %r9, %r15
jmp 0x1d58e
incq %r14
addq $0x4, %rbx
jmp 0x1d576
incq %rdx
decq %rax
addq %r9, %r10
jmp 0x1d560
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: bound_image
box bound_image(image im)
{
    int x,y;
    int minx = im.w;
    int miny = im.h;
    int maxx = 0;
    int maxy = 0;
    for(y = 0; y < im.h; ++y){
        for(x = 0; x < im.w; ++x){
            if(im.data[y*im.w + x]){
                minx = (x < minx) ? x : minx;
                miny = (y < miny) ? y : miny;
                maxx = (x > maxx) ? x : maxx;
                maxy = (y > maxy) ? y : maxy;
            }
        }
    }
    box b = {minx, miny, maxx-minx + 1, maxy-miny + 1};
    //printf("%f %f %f %f\n", b.x, b.y, b.w, b.h);
    return b;
}

// Assembly:
pushq %rbx
movslq 0x10(%rsp), %rcx
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rdx
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %edi
cmovgl %ecx, %edi
testl %eax, %eax
movl $0x0, %r9d
cmovgl %eax, %r9d
movq %rcx, %r11
shlq $0x2, %r11
xorps %xmm0, %xmm0
xorl %r10d, %r10d
xorl %r8d, %r8d
cmpq %r9, %rsi
je 0x1d62d
xorl %ebx, %ebx
cmpq %rbx, %rdi
je 0x1d625
movss (%rdx,%rbx,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x1d608
jnp 0x1d620
cmpl %ecx, %ebx
cmovll %ebx, %ecx
cmpl %eax, %esi
cmovll %esi, %eax
cmpl %r10d, %ebx
cmovgl %ebx, %r10d
cmpl %r8d, %esi
cmovgl %esi, %r8d
incq %rbx
jmp 0x1d5f7
incq %rsi
addq %r11, %rdx
jmp 0x1d5f0
cvtsi2ss %ecx, %xmm0
cvtsi2ss %eax, %xmm2
subl %ecx, %r10d
incl %r10d
cvtsi2ss %r10d, %xmm1
subl %eax, %r8d
incl %r8d
cvtsi2ss %r8d, %xmm3
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: print_letters
void print_letters(float *pred, int n)
{
    int i;
    for(i = 0; i < n; ++i){
        int index = max_index(pred+i*NUMCHARS, NUMCHARS);
        printf("%c", int_to_alphanum(index));
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
testl %esi, %esi
cmovgl %esi, %r14d
pushq $0x25
popq %rbp
subq $0x1, %r14
jb 0x1df85
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4c73
movl %eax, %edi
callq 0x4246
movsbl %al, %edi
callq 0x3060
addq $0x94, %rbx
jmp 0x1df5d
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: fill_truth_captcha
void fill_truth_captcha(char *path, int n, float *truth)
{
    char *begin = strrchr(path, '/');
    ++begin;
    int i;
    for(i = 0; i < strlen(begin) && i < n && begin[i] != '.'; ++i){
        int index = alphanum_to_int(begin[i]);
        if(index > 35) printf("Bad %c\n", begin[i]);
        truth[i*NUMCHARS+index] = 1;
    }
    for(;i < n; ++i){
        truth[i*NUMCHARS + NUMCHARS-1] = 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebx
pushq $0x2f
popq %rsi
callq 0x3190
movq %rax, %r15
incq %r15
movslq %ebx, %rax
movq %rax, 0x10(%rsp)
movq %r14, 0x8(%rsp)
leaq 0x90(%r14), %r13
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x3140
cmpq 0x10(%rsp), %r12
jge 0x1e02c
cmpq %r12, %rax
jbe 0x1e02c
movb (%r15,%r12), %al
cmpb $0x2e, %al
je 0x1e02c
movsbl %al, %edi
callq 0x4238
movl %eax, %ebp
cmpl $0x24, %eax
jl 0x1e00a
movsbl (%r15,%r12), %esi
leaq 0x319cf(%rip), %rdi     # 0x4f9d2
xorl %eax, %eax
callq 0x3160
addl %r14d, %ebp
movslq %ebp, %rax
movq 0x8(%rsp), %rcx
movl $0x3f800000, (%rcx,%rax,4) # imm = 0x3F800000
incq %r12
addq $0x94, %r13
addl $0x25, %r14d
jmp 0x1dfcc
cmpl %r12d, %ebx
cmovlel %r12d, %ebx
cmpq %rbx, %r12
je 0x1e04c
movl $0x3f800000, (%r13)     # imm = 0x3F800000
addq $0x94, %r13
decq %rbx
jmp 0x1e033
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_captcha
data load_data_captcha(char **paths, int n, int m, int k, int w, int h)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;
    d.X = load_image_paths(paths, n, w, h);
    d.y = make_matrix(n, k*NUMCHARS);
    int i;
    for(i = 0; i < n; ++i){
        fill_truth_captcha(paths[i], k, d.y.vals[i]);
    }
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movl %r8d, %r14d
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x40(%rsp), %ebp
testl %ecx, %ecx
movl %ecx, 0x4(%rsp)
je 0x1e091
movq %r15, %rdi
movl %r12d, %esi
movl %ecx, %edx
callq 0x1c922
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %ebp, %ecx
callq 0x1cadf
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
imull $0x25, %r14d, %esi
movl %r12d, %edi
callq 0x221e3
movq %rdx, %r13
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
cmpq %rbp, %r12
je 0x1e0f6
movq (%r15,%rbp,8), %rdi
movq (%r13,%rbp,8), %rdx
movl %r14d, %esi
callq 0x1df91
incq %rbp
jmp 0x1e0db
cmpl $0x0, 0x4(%rsp)
je 0x1e105
movq %r15, %rdi
callq 0x3040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_captcha_encode
data load_data_captcha_encode(char **paths, int n, int m, int w, int h)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;
    d.X = load_image_paths(paths, n, w, h);
    d.X.cols = 17100;
    d.y = d.X;
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
testl %ecx, %ecx
je 0x1e147
movq %r14, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x1c922
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x1cadf
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movl $0x42cc, 0xc(%rbx)      # imm = 0x42CC
movl 0x8(%rbx), %eax
movl %eax, 0x18(%rbx)
movl 0xc(%rbx), %eax
movl %eax, 0x1c(%rbx)
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rbx)
testl %ebp, %ebp
je 0x1e199
movq %r14, %rdi
callq 0x3040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: fill_truth
void fill_truth(char *path, char **labels, int k, float *truth)
{
    int i;
    memset(truth, 0, k*sizeof(float));
    int count = 0;
    for(i = 0; i < k; ++i){
        if(strstr(path, labels[i])){
            truth[i] = 1;
            ++count;
            //printf("%s %s %d\n", path, labels[i], i);
        }
    }
    if(count != 1 && (k != 1 || count != 0)) printf("Too many or too few labels: %d, %s\n", count, path);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movslq %edx, %rbp
leaq (,%rbp,4), %rdx
xorl %r13d, %r13d
movq %rcx, %rdi
xorl %esi, %esi
callq 0x31c0
testl %ebp, %ebp
movl $0x0, %ebp
movl %r12d, 0x4(%rsp)
cmovgl %r12d, %ebp
xorl %r12d, %r12d
cmpq %r13, %rbp
je 0x1e213
movq (%r15,%r13,8), %rsi
movq %rbx, %rdi
callq 0x34b0
testq %rax, %rax
je 0x1e20e
movl $0x3f800000, (%r14,%r13,4) # imm = 0x3F800000
incl %r12d
incq %r13
jmp 0x1e1ed
cmpl $0x1, %r12d
je 0x1e247
movl 0x4(%rsp), %eax
xorl $0x1, %eax
orl %r12d, %eax
je 0x1e247
leaq 0x317ae(%rip), %rdi     # 0x4f9da
movl %r12d, %esi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3160
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: fill_hierarchy
void fill_hierarchy(float *truth, int k, tree *hierarchy)
{
    int j;
    for(j = 0; j < k; ++j){
        if(truth[j]){
            int parent = hierarchy->parent[j];
            while(parent >= 0){
                truth[parent] = 1;
                parent = hierarchy->parent[parent];
            }
        }
    }
    int i;
    int count = 0;
    for(j = 0; j < hierarchy->groups; ++j){
        //printf("%d\n", count);
        int mask = 1;
        for(i = 0; i < hierarchy->group_size[j]; ++i){
            if(truth[count + i]){
                mask = 0;
                break;
            }
        }
        if (mask) {
            for(i = 0; i < hierarchy->group_size[j]; ++i){
                truth[count + i] = SECRET_NUM;
            }
        }
        count += hierarchy->group_size[j];
    }
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorps %xmm0, %xmm0
cmpq %rsi, %rax
je 0x1e290
movss (%rdi,%rax,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x1e271
jnp 0x1e28b
movq 0x10(%rdx), %rcx
movq %rax, %r8
movslq (%rcx,%r8,4), %r8
testq %r8, %r8
js 0x1e28b
movl $0x3f800000, (%rdi,%r8,4) # imm = 0x3F800000
jmp 0x1e278
incq %rax
jmp 0x1e260
movl 0x30(%rdx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorps %xmm0, %xmm0
xorl %esi, %esi
cmpq %rax, %rcx
je 0x1e2f5
movq 0x38(%rdx), %r8
movl (%r8,%rcx,4), %r8d
movslq %esi, %r10
testl %r8d, %r8d
movl $0x0, %r9d
cmovgl %r8d, %r9d
leaq (%rdi,%r10,4), %r10
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x1e2e0
movss (%r10,%r11,4), %xmm1
incq %r11
ucomiss %xmm0, %xmm1
jne 0x1e2d8
jnp 0x1e2c3
addl %r8d, %esi
incq %rcx
jmp 0x1e29f
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x1e2d8
movl $0xc49a4000, (%r10,%r11,4) # imm = 0xC49A4000
incq %r11
jmp 0x1e2e3
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_labels_paths
matrix load_labels_paths(char **paths, int n, char **labels, int k, tree *hierarchy)
{
    matrix y = make_matrix(n, k);
    int i;
    for(i = 0; i < n && labels; ++i){
        fill_truth(paths[i], labels, k, y.vals[i]);
        if(hierarchy){
            fill_hierarchy(y.vals[i], k, hierarchy);
        }
    }
    return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, 0x10(%rsp)
movl %esi, %edi
movl %ecx, %esi
callq 0x221e3
movq %rax, 0x8(%rsp)
movq %rdx, %r13
testq %r14, %r14
je 0x1e55f
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x1e55f
movq 0x10(%rsp), %rax
movq (%rax,%r12,8), %rdi
movq (%r13,%r12,8), %rcx
movq %r14, %rsi
movl %ebp, %edx
callq 0x1e1ab
testq %rbx, %rbx
je 0x1e55a
movq (%r13,%r12,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1e256
incq %r12
jmp 0x1e529
movq 0x8(%rsp), %rax
movq %r13, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_tags_paths
matrix load_tags_paths(char **paths, int n, int k)
{
    matrix y = make_matrix(n, k);
    int i;
    //int count = 0;
    for(i = 0; i < n; ++i){
        char label[4096];
        find_replace(paths[i], "images", "labels", label);
        find_replace(label, ".jpg", ".txt", label);
        FILE *file = fopen(label, "r");
        if (!file) continue;
        //++count;
        int tag;
        while(fscanf(file, "%d", &tag) == 1){
            if(tag < k){
                y.vals[i][tag] = 1;
            }
        }
        fclose(file);
    }
    //printf("%d/%d\n", count, n);
    return y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, 0x10(%rsp)
movl %esi, %edi
movl %edx, %esi
callq 0x221e3
movq %rax, 0x8(%rsp)
movq %rdx, %r13
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
movq %r14, 0x18(%rsp)
leaq 0x3368c(%rip), %r12     # 0x51c43
leaq 0x4(%rsp), %r15
xorl %ebp, %ebp
cmpq 0x18(%rsp), %rbp
je 0x1e659
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rdi
leaq 0x313c6(%rip), %rsi     # 0x4f99f
leaq 0x313c6(%rip), %rdx     # 0x4f9a6
leaq 0x20(%rsp), %r14
movq %r14, %rcx
callq 0x42ea
movq %r14, %rdi
leaq 0x30155(%rip), %rsi     # 0x4e74c
leaq 0x331cb(%rip), %rdx     # 0x517c9
movq %r14, %rcx
callq 0x42ea
movq %r14, %rdi
leaq 0x336d9(%rip), %rsi     # 0x51ce9
callq 0x3390
testq %rax, %rax
je 0x1e651
movq %rax, %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x30a0
cmpl $0x1, %eax
jne 0x1e649
movslq 0x4(%rsp), %rax
cmpl %ebx, %eax
jge 0x1e61d
movq (%r13,%rbp,8), %rcx
movl $0x3f800000, (%rcx,%rax,4) # imm = 0x3F800000
jmp 0x1e61d
movq %r14, %rdi
callq 0x3130
incq %rbp
jmp 0x1e5be
movq 0x8(%rsp), %rax
movq %r13, %rdx
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_labels
char **get_labels(char *filename)
{
    list *plist = get_paths(filename);
    char **labels = (char **)list_to_array(plist);
    free_list(plist);
    return labels;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1c8c8
movq %rax, %rbx
movq %rax, %rdi
callq 0x72f5
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: free_data
void free_data(data d)
{
    if(!d.shallow){
        free_matrix(d.X);
        free_matrix(d.y);
    }else{
        free(d.X.vals);
        free(d.y.vals);
    }
}

// Assembly:
pushq %rbx
leaq 0x10(%rsp), %rbx
cmpl $0x0, 0x28(%rbx)
je 0x1e6bc
movq 0x10(%rbx), %rdi
callq 0x3040
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x3040
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x21edc
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
popq %rbx
jmp 0x21edc
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_segmentation_image
image get_segmentation_image(char *path, int w, int h, int classes)
{
    char labelpath[4096];
    find_replace(path, "images", "mask", labelpath);
    find_replace(labelpath, "JPEGImages", "mask", labelpath);
    find_replace(labelpath, ".jpg", ".txt", labelpath);
    find_replace(labelpath, ".JPG", ".txt", labelpath);
    find_replace(labelpath, ".JPEG", ".txt", labelpath);
    image mask = make_image(w, h, classes);
    FILE *file = fopen(labelpath, "r");
    if(!file) file_error(labelpath);
    char buff[32788];
    int id;
    image part = make_image(w, h, 1);
    while(fscanf(file, "%d %s", &id, buff) == 2){
        int n = 0;
        int *rle = read_intlist(buff, &n, 0);
        load_rle(part, rle, n);
        or_image(part, mask, id);
        free(rle);
    }
    //exclusive_image(mask);
    fclose(file);
    free_image(part);
    return mask;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9068, %rsp           # imm = 0x9068
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x312a2(%rip), %rsi     # 0x4f99f
leaq 0x312bf(%rip), %r13     # 0x4f9c3
leaq 0x50(%rsp), %r12
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x42ea
leaq 0x3128f(%rip), %rsi     # 0x4f9ad
movq %r12, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x42ea
leaq 0x30019(%rip), %rsi     # 0x4e74c
leaq 0x3308f(%rip), %r13     # 0x517c9
movq %r12, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x42ea
leaq 0x31269(%rip), %rsi     # 0x4f9b8
movq %r12, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x42ea
leaq 0x31259(%rip), %rsi     # 0x4f9bd
movq %r12, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x42ea
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl %r14d, %ecx
callq 0xb45a
leaq 0x33560(%rip), %rsi     # 0x51ce9
movq %r12, %rdi
callq 0x3390
movq %rax, %r14
testq %rax, %rax
jne 0x1e7a3
leaq 0x50(%rsp), %rdi
callq 0x3d0f
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rcx
movl %r15d, %esi
movl %ebp, %edx
callq 0xb45a
leaq 0x34(%rsp), %r12
leaq 0x1050(%rsp), %r13
leaq 0x30(%rsp), %rbp
movq %r14, %rdi
leaq 0x311f7(%rip), %rsi     # 0x4f9c8
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x30a0
cmpl $0x2, %eax
jne 0x1e851
andl $0x0, 0x30(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x3bfb
movq %rax, %r15
movl 0x30(%rsp), %esi
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x1d445
movl 0x34(%rsp), %edi
movq 0x10(%rbx), %rax
movq %rax, 0x28(%rsp)
movups (%rbx), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x1d4d1
movq %r15, %rdi
callq 0x3040
jmp 0x1e7c7
movq %r14, %rdi
callq 0x3130
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xba88
movq %rbx, %rax
addq $0x9068, %rsp           # imm = 0x9068
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_old
data load_data_old(char **paths, int n, int m, char **labels, int k, int w, int h)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;
    d.X = load_image_paths(paths, n, w, h);
    d.y = load_labels_paths(paths, n, labels, k, 0);
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x48(%rsp), %ecx
movl 0x40(%rsp), %edx
testl %ebp, %ebp
je 0x2055b
movq %r14, %rdi
movl %r13d, %esi
movl %ebp, %edx
movl %ecx, %r14d
callq 0x1c922
movl 0x40(%rsp), %edx
movl %r14d, %ecx
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r14, %rdi
movl %r13d, %esi
callq 0x1cadf
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %r14, %rdi
movl %r13d, %esi
movq %r12, %rdx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x1e4eb
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
testl %ebp, %ebp
je 0x205a8
movq %r14, %rdi
callq 0x3040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_regression
data load_data_regression(char **paths, int n, int m, int k, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;
    d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure, 0);
    d.y = load_regression_labels_paths(paths, n, k);
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r13d
movl %r8d, %r15d
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x58(%rsp), %r8d
movl 0x50(%rsp), %ecx
testl %ebp, %ebp
je 0x2063c
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
movss %xmm4, 0x14(%rsp)
movss %xmm3, 0x10(%rsp)
movss %xmm2, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm0, 0x4(%rsp)
movl %r8d, %r14d
callq 0x1c922
movl 0x50(%rsp), %ecx
movl %r14d, %r8d
movss 0x4(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
movss 0x10(%rsp), %xmm3
movss 0x14(%rsp), %xmm4
movq %rax, %r14
xorps %xmm5, %xmm5
movups %xmm5, 0x30(%rbx)
movups %xmm5, 0x20(%rbx)
movups %xmm5, 0x10(%rbx)
movups %xmm5, (%rbx)
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
xorl %r9d, %r9d
callq 0x1cb6e
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x1e2f6
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
testl %ebp, %ebp
je 0x20689
movq %r14, %rdi
callq 0x3040
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_augment
data load_data_augment(char **paths, int n, int m, char **labels, int k, tree *hierarchy, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure, int center)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;
    d.w=size;
    d.h=size;
    d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure, center);
    d.y = load_labels_paths(paths, n, labels, k, hierarchy);
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x70(%rsp), %r9d
movl 0x68(%rsp), %r15d
movl 0x60(%rsp), %ecx
movl 0x58(%rsp), %edx
testl %ebp, %ebp
je 0x2072a
movq %r14, %rdi
movl %r13d, %esi
movl %ebp, %edx
movss %xmm4, 0x10(%rsp)
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movl %r9d, %r14d
callq 0x1c922
movl 0x58(%rsp), %edx
movl 0x60(%rsp), %ecx
movl %r14d, %r9d
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movss 0x8(%rsp), %xmm2
movss 0xc(%rsp), %xmm3
movss 0x10(%rsp), %xmm4
movq %rax, %r14
andq $0x0, 0x38(%rbx)
xorps %xmm5, %xmm5
movups %xmm5, 0x28(%rbx)
movl %r15d, (%rbx)
movl %r15d, 0x4(%rbx)
movq %r14, %rdi
movl %r13d, %esi
movl %r15d, %r8d
callq 0x1cb6e
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %r14, %rdi
movl %r13d, %esi
movq %r12, %rdx
movl 0x14(%rsp), %ecx
movq 0x50(%rsp), %r8
callq 0x1e4eb
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
testl %ebp, %ebp
je 0x2077e
movq %r14, %rdi
callq 0x3040
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_super
data load_data_super(char **paths, int n, int m, int w, int h, int scale)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.shallow = 0;

    int i;
    d.X.rows = n;
    d.X.vals = calloc(n, sizeof(float*));
    d.X.cols = w*h*3;

    d.y.rows = n;
    d.y.vals = calloc(n, sizeof(float*));
    d.y.cols = w*scale * h*scale * 3;

    for(i = 0; i < n; ++i){
        image im = load_image_color(paths[i], 0, 0);
        image crop = random_crop_image(im, w*scale, h*scale);
        int flip = rand()%2;
        if (flip) flip_image(crop);
        image resize = resize_image(crop, w, h);
        d.X.vals[i] = resize.data;
        d.y.vals[i] = crop.data;
        free_image(im);
    }

    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, 0x28(%rsp)
movl %r8d, 0x1c(%rsp)
movl %edx, %r13d
movq %rdi, 0x38(%rsp)
movl 0xc0(%rsp), %r15d
testl %ecx, %ecx
movl %ecx, 0x34(%rsp)
je 0x207d7
movq %rsi, %rdi
movl %r13d, %esi
movl %ecx, %edx
callq 0x1c922
movq %rax, 0x20(%rsp)
jmp 0x207dc
movq %rsi, 0x20(%rsp)
xorps %xmm0, %xmm0
movq 0x38(%rsp), %rbp
movups %xmm0, (%rbp)
movups %xmm0, 0x30(%rbp)
movups %xmm0, 0x20(%rbp)
movups %xmm0, 0x10(%rbp)
movl %r13d, 0x8(%rbp)
movslq %r13d, %r14
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x3250
movq %rax, %rbx
movq %rax, 0x10(%rbp)
movq 0x28(%rsp), %rax
leal (%rax,%rax,2), %eax
movl %eax, 0x30(%rsp)
movl 0x1c(%rsp), %r12d
imull %r12d, %eax
movl %eax, 0xc(%rbp)
movl %r13d, 0x18(%rbp)
movq %r14, %rdi
pushq $0x8
popq %rsi
callq 0x3250
movq %rax, %r14
movq %rbp, %rcx
movq %rax, 0x20(%rbp)
movl %r15d, %ebp
imull %r12d, %ebp
movl 0x30(%rsp), %eax
imull %r15d, %eax
imull %ebp, %eax
imull 0x28(%rsp), %r15d
xorl %r12d, %r12d
testl %r13d, %r13d
cmovlel %r12d, %r13d
movl %eax, 0x1c(%rcx)
cmpq %r12, %r13
je 0x20921
movq 0x20(%rsp), %rax
movq (%rax,%r12,8), %rsi
leaq 0x58(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xbf36
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x58(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0xe9e1
callq 0x34e0
testb $0x1, %al
je 0x208c6
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xcb93
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0xc3ee
movq 0x80(%rsp), %rax
movq %rax, (%rbx,%r12,8)
movq 0x50(%rsp), %rax
movq %rax, (%r14,%r12,8)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x58(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xba88
incq %r12
jmp 0x20863
cmpl $0x0, 0x34(%rsp)
je 0x20932
movq 0x20(%rsp), %rdi
callq 0x3040
movq 0x38(%rsp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_writing
data load_data_writing(char **paths, int n, int m, int w, int h, int out_w, int out_h)
{
    if(m) paths = get_random_paths(paths, n, m);
    char **replace_paths = find_replace_paths(paths, n, ".png", "-label.png");
    data d = {0};
    d.shallow = 0;
    d.X = load_image_paths(paths, n, w, h);
    d.y = load_image_paths_gray(replace_paths, n, out_w, out_h);
    if(m) free(paths);
    int i;
    for(i = 0; i < n; ++i) free(replace_paths[i]);
    free(replace_paths);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %r13d
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
testl %ecx, %ecx
je 0x2097b
movq %r12, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x1c922
movq %rax, %r12
leaq 0x2dd1c(%rip), %rdx     # 0x4e69e
leaq 0x2f0bd(%rip), %rcx     # 0x4fa46
movq %r12, %rdi
movl %r14d, %esi
callq 0x1c98d
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movq %r12, %rdi
movl %r14d, %esi
movl %r13d, %edx
movl 0x4(%rsp), %ecx
callq 0x1cadf
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %r15, %rdi
movl %r14d, %esi
movl 0x40(%rsp), %edx
movl 0x48(%rsp), %ecx
callq 0x1ca08
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
testl %ebp, %ebp
je 0x209ea
movq %r12, %rdi
callq 0x3040
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
cmpq %r12, %r14
je 0x20a07
movq (%r15,%r12,8), %rdi
callq 0x3040
incq %r12
jmp 0x209f4
movq %r15, %rdi
callq 0x3040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_tag
data load_data_tag(char **paths, int n, int m, int k, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d = {0};
    d.w = size;
    d.h = size;
    d.shallow = 0;
    d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure, 0);
    d.y = load_tags_paths(paths, n, k);
    if(m) free(paths);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r13d
movl %r8d, 0x14(%rsp)
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x58(%rsp), %r15d
movl 0x50(%rsp), %ecx
testl %ebp, %ebp
je 0x20a9f
movq %r14, %rdi
movl %r12d, %esi
movl %ebp, %edx
movss %xmm4, 0x10(%rsp)
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movl %ecx, %r14d
callq 0x1c922
movl %r14d, %ecx
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movss 0x8(%rsp), %xmm2
movss 0xc(%rsp), %xmm3
movss 0x10(%rsp), %xmm4
movq %rax, %r14
andq $0x0, 0x38(%rbx)
xorps %xmm5, %xmm5
movups %xmm5, 0x28(%rbx)
movl %r15d, (%rbx)
movl %r15d, 0x4(%rbx)
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %r15d, %r8d
xorl %r9d, %r9d
callq 0x1cb6e
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %r14, %rdi
movl %r12d, %esi
movl 0x14(%rsp), %edx
callq 0x1e576
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
testl %ebp, %ebp
je 0x20af1
movq %r14, %rdi
callq 0x3040
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data_in_thread
pthread_t load_data_in_thread(load_args args)
{
    pthread_t thread;
    struct load_args *ptr = calloc(1, sizeof(struct load_args));
    *ptr = args;
    if(pthread_create(&thread, 0, load_thread, ptr)) error("Thread creation failed");
    return thread;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rdi
movl $0xa8, %esi
callq 0x3250
movq %rax, %rbx
leaq 0x20(%rsp), %rsi
movl $0xa8, %edx
movq %rax, %rdi
callq 0x32b0
leaq -0xa59(%rip), %rdx      # 0x200d8
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x3360
testl %eax, %eax
je 0x20b50
leaq 0x2eee4(%rip), %rdi     # 0x4fa2f
callq 0x43df
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_threads
void *load_threads(void *ptr)
{
    int i;
    load_args args = *(load_args *)ptr;
    if (args.threads == 0) args.threads = 1;
    data *out = args.d;
    int total = args.n;
    free(ptr);
    data *buffers = calloc(args.threads, sizeof(data));
    pthread_t *threads = calloc(args.threads, sizeof(pthread_t));
    for(i = 0; i < args.threads; ++i){
        args.d = buffers + i;
        args.n = (i+1) * total/args.threads - i * total/args.threads;
        threads[i] = load_data_in_thread(args);
    }
    for(i = 0; i < args.threads; ++i){
        pthread_join(threads[i], 0);
    }
    *out = concat_datas(buffers, args.threads);
    out->shallow = 0;
    for(i = 0; i < args.threads; ++i){
        buffers[i].shallow = 1;
        free_data(buffers[i]);
    }
    free(buffers);
    free(threads);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0xd0(%rsp), %r14
movl $0xa8, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32b0
movl (%r14), %ebp
movl 0x18(%r14), %eax
movq %rax, 0xc8(%rsp)
cmpl $0x1, %ebp
adcl $0x0, %ebp
movl %ebp, (%r14)
movq 0x80(%r14), %rax
movq %rax, 0xc0(%rsp)
movq %rbx, %rdi
callq 0x3040
movslq %ebp, %r14
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x3250
movq %rax, %r12
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x3250
xorl %ecx, %ecx
testl %r14d, %r14d
movl $0x0, %r15d
movl %ebp, 0xb4(%rsp)
cmovgl %ebp, %r15d
movq %rax, 0xb8(%rsp)
movq %r12, %rbx
xorl %r14d, %r14d
cmpq %r14, %r15
je 0x20c5e
movq %rbx, 0x150(%rsp)
leaq 0x1(%r14), %rbp
movq 0xc8(%rsp), %rax
leal (%rax,%rcx), %r13d
movl %r13d, %eax
cltd
movl 0xb4(%rsp), %edi
idivl %edi
movl %eax, %esi
movl %ecx, %eax
cltd
idivl %edi
subl %eax, %esi
movl %esi, 0xe8(%rsp)
pushq $0x15
popq %rcx
movq %rsp, %rdi
leaq 0xd0(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x20b03
movq 0xb8(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
addq $0x40, %rbx
movl %r13d, %ecx
movq %rbp, %r14
jmp 0x20bf6
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x20c7d
movq 0xb8(%rsp), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
callq 0x3470
incq %rbx
jmp 0x20c60
leaq 0x178(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movl 0xb4(%rsp), %edx
callq 0x20d33
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movq 0xc0(%rsp), %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
andl $0x0, 0x28(%rax)
shlq $0x6, %r15
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x20d0a
movl $0x1, 0x28(%r12,%rbx)
movups (%r12,%rbx), %xmm0
movups 0x10(%r12,%rbx), %xmm1
movups 0x20(%r12,%rbx), %xmm2
movups 0x30(%r12,%rbx), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1e69d
addq $0x40, %rbx
jmp 0x20cc7
movq %r12, %rdi
callq 0x3040
movq 0xb8(%rsp), %rdi
callq 0x3040
xorl %eax, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: concat_datas
data concat_datas(data *d, int n)
{
    int i;
    data out = {0};
    for(i = 0; i < n; ++i){
        data new = concat_data(d[i], out);
        free_data(out);
        out = new;
    }
    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x48(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x2c(%rdi), %rax
movq %rax, 0x50(%rsp)
xorl %ebp, %ebp
testl %edx, %edx
cmovlel %ebp, %edx
shlq $0x6, %rdx
movq %rdx, 0x58(%rsp)
xorl %r15d, %r15d
xorl %ebx, %ebx
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rbp, 0x58(%rsp)
je 0x20e3d
movq 0x48(%rsp), %rax
movq (%rax,%rbp), %rsi
movq %rsi, 0x70(%rsp)
movq 0x8(%rax,%rbp), %rdi
movq 0x10(%rax,%rbp), %rsi
movq 0x18(%rax,%rbp), %r12
movq 0x20(%rax,%rbp), %r13
callq 0x212ca
movq %rax, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x212ca
movq %rax, %rbx
movq %rdx, %r15
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1e69d
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq %rcx, 0x10(%r14)
movq %rbx, 0x18(%r14)
movq %r15, 0x20(%r14)
movl $0x1, 0x28(%r14)
xorps %xmm0, %xmm0
movq 0x50(%rsp), %rax
movups %xmm0, (%rax)
andl $0x0, 0x10(%rax)
addq $0x40, %rbp
jmp 0x20d7d
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_data
pthread_t load_data(load_args args)
{
    pthread_t thread;
    struct load_args *ptr = calloc(1, sizeof(struct load_args));
    *ptr = args;
    if(pthread_create(&thread, 0, load_threads, ptr)) error("Thread creation failed");
    return thread;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rdi
movl $0xa8, %esi
callq 0x3250
movq %rax, %rbx
leaq 0x20(%rsp), %rsi
movl $0xa8, %edx
movq %rax, %rdi
callq 0x32b0
leaq -0x34e(%rip), %rdx      # 0x20b5b
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x3360
testl %eax, %eax
je 0x20ec8
leaq 0x2eb6c(%rip), %rdi     # 0x4fa2f
callq 0x43df
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: select_data
data select_data(data *orig, int *inds)
{
    data d = {0};
    d.shallow = 1;
    d.w = orig[0].w;
    d.h = orig[0].h;

    d.X.rows = orig[0].X.rows;
    d.y.rows = orig[0].X.rows;

    d.X.cols = orig[0].X.cols;
    d.y.cols = orig[0].y.cols;

    d.X.vals = calloc(orig[0].X.rows, sizeof(float *));
    d.y.vals = calloc(orig[0].y.rows, sizeof(float *));
    int i;
    for(i = 0; i < d.X.rows; ++i){
        d.X.vals[i] = orig[inds[i]].X.vals[i];
        d.y.vals[i] = orig[inds[i]].y.vals[i];
    }
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
andq $0x0, 0x38(%rdi)
movl $0x1, 0x28(%rdi)
movdqu (%rsi), %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
movd %xmm1, %eax
movd %xmm1, 0x18(%rdi)
movdqu %xmm0, (%rdi)
movl 0x1c(%rsi), %ecx
movl %ecx, 0x1c(%rdi)
movslq %eax, %r12
pushq $0x8
popq %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3250
movq %rax, %r13
movq %rax, 0x10(%r14)
movslq 0x18(%r15), %rdi
movq %rbp, %rsi
callq 0x3250
movq %rax, 0x20(%r14)
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
cmpq %rcx, %r12
je 0x20f74
movslq (%rbx,%rcx,4), %rdx
shlq $0x6, %rdx
movq 0x10(%r15,%rdx), %rsi
movq (%rsi,%rcx,8), %rsi
movq %rsi, (%r13,%rcx,8)
movq 0x20(%r15,%rdx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
jmp 0x20f47
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: resize_data
data resize_data(data orig, int w, int h)
{
    data d = {0};
    d.shallow = 0;
    d.w = w;
    d.h = h;
    int i;
    d.X.rows = orig.X.rows;
    d.X.cols = w*h*3;
    d.X.vals = calloc(d.X.rows, sizeof(float*));

    d.y = copy_matrix(orig.y);
#pragma omp parallel for
    for(i = 0; i < orig.X.rows; ++i){
        image im = float_to_image(orig.w, orig.h, 3, orig.X.vals[i]);
        d.X.vals[i] = resize_image(im, w, h).data;
    }
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
andq $0x0, 0x38(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movslq 0x98(%rsp), %rbp
movl %ebp, 0x8(%rdi)
movl %esi, 0x18(%rsp)
movl %esi, %eax
movl %edx, 0x1c(%rsp)
imull %edx, %eax
leal (%rax,%rax,2), %eax
movl %eax, 0xc(%rdi)
pushq $0x8
popq %rsi
movq %rbp, %rdi
callq 0x3250
movq %rax, %r15
movq %rax, 0x10(%rbx)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x22155
movq %rax, 0x18(%rbx)
movq %rbx, 0x20(%rsp)
movq %rdx, 0x20(%rbx)
movl 0x90(%rsp), %r12d
movl 0x94(%rsp), %r13d
xorl %r14d, %r14d
testl %ebp, %ebp
movl $0x0, %ebx
cmovgl %ebp, %ebx
movq 0xa0(%rsp), %rbp
cmpq %r14, %rbx
je 0x212b6
movq (%rbp,%r14,8), %r8
leaq 0x28(%rsp), %rdi
movl %r12d, %esi
movl %r13d, %edx
pushq $0x3
popq %rcx
callq 0xc3de
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x1c(%rsp), %edx
callq 0xc3ee
movq 0x50(%rsp), %rax
movq %rax, (%r15,%r14,8)
incq %r14
jmp 0x21266
movq 0x20(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: concat_matrix
matrix concat_matrix(matrix m1, matrix m2)
{
    int i, count = 0;
    matrix m;
    m.cols = m1.cols;
    m.rows = m1.rows+m2.rows;
    m.vals = calloc(m1.rows + m2.rows, sizeof(float*));
    for(i = 0; i < m1.rows; ++i){
        m.vals[count++] = m1.vals[i];
    }
    for(i = 0; i < m2.rows; ++i){
        m.vals[count++] = m2.vals[i];
    }
    return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leal (%rdx,%rdi), %ebp
movslq %ebp, %rdi
pushq $0x8
popq %rsi
callq 0x3250
movq %rax, %rdx
xorl %ecx, %ecx
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
cmpq %rcx, %rax
je 0x2130d
movq (%r12,%rcx,8), %rsi
movq %rsi, (%rdx,%rcx,8)
incq %rcx
jmp 0x212fb
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
leaq (%rdx,%rax,8), %rax
cmpq %rcx, %r15
je 0x2132c
movq (%r14,%rcx,8), %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
jmp 0x2131a
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %rbx
movl %ebp, %eax
orq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: concat_data
data concat_data(data d1, data d2)
{
    data d = {0};
    d.shallow = 1;
    d.X = concat_matrix(d1.X, d2.X);
    d.y = concat_matrix(d1.y, d2.y);
    d.w = d1.w;
    d.h = d1.h;
    return d;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
andq $0x0, 0x38(%rdi)
movl $0x1, 0x28(%rdi)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %rcx
callq 0x212ca
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x70(%rsp), %rcx
callq 0x212ca
movq %rax, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_categorical_data_csv
data load_categorical_data_csv(char *filename, int target, int k)
{
    data d = {0};
    d.shallow = 0;
    matrix X = csv_to_matrix(filename);
    float *truth_1d = pop_column(&X, target);
    float **truth = one_hot_encode(truth_1d, X.rows, k);
    matrix y;
    y.rows = X.rows;
    y.cols = k;
    y.vals = truth;
    d.X = X;
    d.y = y;
    free(truth_1d);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, %rdi
callq 0x22350
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r15, %rdi
movl %r14d, %esi
callq 0x222e3
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
movl %ebp, %edx
callq 0x4e89
movl (%r15), %ecx
movups (%r15), %xmm0
movups %xmm0, 0x8(%rbx)
movl %ecx, 0x18(%rbx)
movl %ebp, 0x1c(%rbx)
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x3040
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: load_cifar10_data
data load_cifar10_data(char *filename)
{
    data d = {0};
    d.shallow = 0;
    long i,j;
    matrix X = make_matrix(10000, 3072);
    matrix y = make_matrix(10000, 10);
    d.X = X;
    d.y = y;

    FILE *fp = fopen(filename, "rb");
    if(!fp) file_error(filename);
    for(i = 0; i < 10000; ++i){
        unsigned char bytes[3073];
        fread(bytes, 1, 3073, fp);
        int class = bytes[0];
        y.vals[i][class] = 1;
        for(j = 0; j < X.cols; ++j){
            X.vals[i][j] = (double)bytes[j+1];
        }
    }
    scale_data_rows(d, 1./255);
    //normalize_data_rows(d);
    fclose(fp);
    return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x2710, %edi           # imm = 0x2710
movl $0xc00, %esi            # imm = 0xC00
callq 0x221e3
movq %rax, %r13
movq %rdx, %r14
pushq $0xa
popq %rsi
movl $0x2710, %edi           # imm = 0x2710
callq 0x221e3
movq %rdx, %rbp
movq %r13, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %r15, 0x8(%rsp)
movq %rdx, 0x20(%r15)
leaq 0x2ac1b(%rip), %rsi     # 0x4c0b0
movq %rbx, %rdi
callq 0x3390
movq %rax, %r15
movq %r13, %r12
shrq $0x20, %r12
testq %rax, %rax
jne 0x214b4
movq %rbx, %rdi
callq 0x3d0f
movq %r13, (%rsp)
sarq $0x20, %r13
xorl %ebx, %ebx
cmpq $0x2710, %rbx           # imm = 0x2710
je 0x21510
movl $0xc01, %edx            # imm = 0xC01
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rsi
movq %r15, %rcx
callq 0x30d0
movzbl 0x10(%rsp), %eax
movq (%rbp,%rbx,8), %rcx
movl $0x3f800000, (%rcx,%rax,4) # imm = 0x3F800000
xorl %eax, %eax
cmpq %r13, %rax
jge 0x2150b
movzbl 0x11(%rsp,%rax), %ecx
cvtsi2ss %ecx, %xmm0
movq (%r14,%rbx,8), %rcx
movss %xmm0, (%rcx,%rax,4)
incq %rax
jmp 0x214ef
incq %rbx
jmp 0x214be
movslq (%rsp), %rbx
xorl %r13d, %r13d
testq %rbx, %rbx
cmovleq %r13, %rbx
cmpq %r13, %rbx
je 0x2153c
movq (%r14,%r13,8), %rdi
movl %r12d, %esi
movss 0x2e3c6(%rip), %xmm0    # 0x4f8f8
callq 0x4b7e
incq %r13
jmp 0x2151e
movq %r15, %rdi
callq 0x3130
movq 0x8(%rsp), %rax
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_random_batch
void get_random_batch(data d, int n, float *X, float *y)
{
    int j;
    for(j = 0; j < n; ++j){
        int index = rand()%d.X.rows;
        memcpy(X+j*d.X.cols, d.X.vals[index], d.X.cols*sizeof(float));
        memcpy(y+j*d.y.cols, d.y.vals[index], d.y.cols*sizeof(float));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl 0x58(%rsp), %eax
movl %eax, 0x4(%rsp)
movslq 0x5c(%rsp), %r15
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
shlq $0x2, %r15
movslq 0x6c(%rsp), %r12
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
shlq $0x2, %r12
xorl %r13d, %r13d
testl %edi, %edi
cmovgl %edi, %r13d
subq $0x1, %r13
jb 0x2162f
callq 0x34e0
cltd
idivl 0x4(%rsp)
movslq %edx, %rbp
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x32b0
movq 0x8(%rsp), %rax
movq (%rax,%rbp,8), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x32b0
addq %r15, %r14
addq %r12, %rbx
jmp 0x215ec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: get_next_batch
void get_next_batch(data d, int n, int offset, float *X, float *y)
{
    int j;
    for(j = 0; j < n; ++j){
        int index = offset + j;
        memcpy(X+j*d.X.cols, d.X.vals[index], d.X.cols*sizeof(float));
        if(y) memcpy(y+j*d.y.cols, d.y.vals[index], d.y.cols*sizeof(float));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbp
movq %rdx, %r14
movslq 0x5c(%rsp), %r12
shlq $0x2, %r12
movslq 0x6c(%rsp), %r13
shlq $0x2, %r13
movslq %esi, %rax
xorl %ebx, %ebx
testl %edi, %edi
cmovlel %ebx, %edi
movq %rdi, 0x10(%rsp)
shlq $0x3, %rax
movq 0x60(%rsp), %rdx
addq %rax, %rdx
movq %rdx, 0x8(%rsp)
addq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq %rcx, %r15
cmpq %rbx, 0x10(%rsp)
je 0x216ce
movq 0x8(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x32b0
testq %r15, %r15
je 0x216c3
movq (%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x32b0
incq %rbx
addq %r12, %r14
addq %r13, %rbp
jmp 0x21690
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/data.c
// Function: smooth_data
void smooth_data(data d)
{
    int i, j;
    float scale = 1. / d.y.cols;
    float eps = .1;
    for(i = 0; i < d.y.rows; ++i){
        for(j = 0; j < d.y.cols; ++j){
            d.y.vals[i][j] = eps * scale + (1-eps) * d.y.vals[i][j];
        }
    }
}

// Assembly:
movl 0x24(%rsp), %eax
cvtsi2sd %eax, %xmm0
movsd 0x2aa3b(%rip), %xmm1    # 0x4c128
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movl 0x20(%rsp), %edx
testl %edx, %edx
cmovlel %ecx, %edx
movq 0x28(%rsp), %rsi
movss 0x2e1ea(%rip), %xmm1    # 0x4f8fc
mulss 0x2ab4e(%rip), %xmm0    # 0x4c268
cmpq %rdx, %rcx
je 0x21748
xorl %edi, %edi
cmpq %rdi, %rax
je 0x21743
movq (%rsi,%rcx,8), %r8
movss (%r8,%rdi,4), %xmm2
mulss %xmm1, %xmm2
addss %xmm0, %xmm2
movss %xmm2, (%r8,%rdi,4)
incq %rdi
jmp 0x21721
incq %rcx
jmp 0x2171a
retq