LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/gemm.c
// Function: time_random_matrix
void time_random_matrix(int TA, int TB, int m, int k, int n)
{
    float *a;
    if(!TA) a = random_matrix(m,k);
    else a = random_matrix(k,m);
    int lda = (!TA)?k:m;
    float *b;
    if(!TB) b = random_matrix(k,n);
    else b = random_matrix(n,k);
    int ldb = (!TB)?n:k;

    float *c = random_matrix(m,n);
    int i;
    clock_t start = clock(), end;
    for(i = 0; i<10; ++i){
        gemm_cpu(TA,TB,m,n,k,1,a,lda,b,ldb,1,c,n);
    }
    end = clock();
    printf("Matrix Multiplication %dx%d * %dx%d, TA=%d, TB=%d: %lf ms\n",m,k,k,n, TA, TB, (float)(end-start)/CLOCKS_PER_SEC);
    free(a);
    free(b);
    free(c);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %ebx
movl %edi, %r15d
testl %edi, %edi
je 0xdb22
movl %ebp, %edi
movl %r12d, %esi
callq 0xda9a
movl %r12d, %ecx
jmp 0xdb2e
movl %r12d, %edi
movl %ebp, %esi
callq 0xda9a
movl %ebp, %ecx
movq %rcx, 0x30(%rsp)
movq %rax, 0x18(%rsp)
movl %r12d, 0x4(%rsp)
movq %rbx, 0x20(%rsp)
testl %ebx, %ebx
je 0xdb5c
movl %r14d, %edi
movl %ebp, %esi
callq 0xda9a
movq %rax, 0x8(%rsp)
movl %ebp, %r13d
movl %ebp, %ebx
jmp 0xdb71
movl %ebp, %r13d
movl %ebp, %edi
movl %r14d, %esi
callq 0xda9a
movq %rax, 0x8(%rsp)
movl %r14d, %ebx
movl 0x4(%rsp), %edi
movl %r14d, %esi
callq 0xda9a
movq %rax, 0x10(%rsp)
movl $0xa, %ebp
callq 0x3130
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %r12
subq $0x8, %rsp
movl %r15d, %edi
movq 0x28(%rsp), %rsi
movl 0xc(%rsp), %edx
movl %r14d, %ecx
movl %r13d, %r8d
movss 0x45454(%rip), %xmm0    # 0x53008
movq 0x20(%rsp), %r9
movaps %xmm0, %xmm1
pushq %r14
pushq 0x20(%rsp)
pushq %rbx
pushq 0x28(%rsp)
pushq %r12
callq 0xdc4a
addq $0x30, %rsp
decl %ebp
jne 0xdb96
callq 0x3130
subq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss 0x4541c(%rip), %xmm0    # 0x5300c
cvtss2sd %xmm0, %xmm0
subq $0x8, %rsp
leaq 0x45411(%rip), %rdi     # 0x53010
movl 0xc(%rsp), %esi
movl %r13d, %edx
movl %r13d, %ecx
movl %r14d, %r8d
movl %r15d, %r9d
movb $0x1, %al
pushq 0x28(%rsp)
callq 0x3170
addq $0x10, %rsp
movq 0x18(%rsp), %rdi
callq 0x3040
movq 0x8(%rsp), %rdi
callq 0x3040
movq 0x10(%rsp), %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/gemm.c
// Function: gemm_cpu
void gemm_cpu(int TA, int TB, int M, int N, int K, float ALPHA, 
        float *A, int lda, 
        float *B, int ldb,
        float BETA,
        float *C, int ldc)
{
    //printf("cpu: %d %d %d %d %d %f %d %d %f %d\n",TA, TB, M, N, K, ALPHA, lda, ldb, BETA, ldc);
    int i, j;
    for(i = 0; i < M; ++i){
        for(j = 0; j < N; ++j){
            C[i*ldc + j] *= BETA;
        }
    }
    if(!TA && !TB)
        gemm_nn(M, N, K, ALPHA,A,lda, B, ldb,C,ldc);
    else if(TA && !TB)
        gemm_tn(M, N, K, ALPHA,A,lda, B, ldb,C,ldc);
    else if(!TA && TB)
        gemm_nt(M, N, K, ALPHA,A,lda, B, ldb,C,ldc);
    else
        gemm_tt(M, N, K, ALPHA,A,lda, B, ldb,C,ldc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movl %r8d, %r10d
movl 0x60(%rsp), %ebx
movq 0x58(%rsp), %r11
testl %edx, %edx
jle 0xdca5
movslq %ebx, %r8
movl %edx, %r9d
movl %ecx, %r14d
shlq $0x2, %r8
xorl %r15d, %r15d
movq %r11, %r12
testl %ecx, %ecx
jle 0xdc9a
xorl %r13d, %r13d
movss (%r12,%r13,4), %xmm2
mulss %xmm1, %xmm2
movss %xmm2, (%r12,%r13,4)
incq %r13
cmpq %r13, %r14
jne 0xdc82
incq %r15
addq %r8, %r12
cmpq %r9, %r15
jne 0xdc7b
movl 0x50(%rsp), %r14d
movq 0x48(%rsp), %r9
movl 0x40(%rsp), %r8d
movl %esi, %ebp
orl %edi, %ebp
je 0xdcf6
testl %esi, %esi
setne %bpl
testl %edi, %edi
sete %r15b
orb %bpl, %r15b
je 0xdd10
testl %edi, %edi
setne %dil
testl %esi, %esi
sete %sil
subq $0x8, %rsp
orb %dil, %sil
jne 0xdd2a
movl %edx, %edi
movl %ecx, %esi
movl %r10d, %edx
movq %rax, %rcx
pushq %rbx
pushq %r11
pushq %r14
callq 0xddf4
jmp 0xdd3e
subq $0x8, %rsp
movl %edx, %edi
movl %ecx, %esi
movl %r10d, %edx
movq %rax, %rcx
pushq %rbx
pushq %r11
pushq %r14
callq 0xdd52
jmp 0xdd3e
subq $0x8, %rsp
movl %edx, %edi
movl %ecx, %esi
movl %r10d, %edx
movq %rax, %rcx
pushq %rbx
pushq %r11
pushq %r14
callq 0xde90
jmp 0xdd3e
movl %edx, %edi
movl %ecx, %esi
movl %r10d, %edx
movq %rax, %rcx
pushq %rbx
pushq %r11
pushq %r14
callq 0xdf2c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/gemm.c
// Function: gemm_nn
void gemm_nn(int M, int N, int K, float ALPHA, 
        float *A, int lda, 
        float *B, int ldb,
        float *C, int ldc)
{
    int i,j,k;
    #pragma omp parallel for
    for(i = 0; i < M; ++i){
        for(k = 0; k < K; ++k){
            register float A_PART = ALPHA*A[i*lda+k];
            for(j = 0; j < N; ++j){
                C[i*ldc+j] += A_PART*B[k*ldb+j];
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x8(%rsp)
testl %edi, %edi
jle 0xdde9
movq 0x40(%rsp), %rax
movslq 0x38(%rsp), %r10
movslq %r8d, %r9
movslq 0x48(%rsp), %r11
movl %edi, %edi
movl %edx, %ebx
movl %esi, %r14d
shlq $0x2, %r11
shlq $0x2, %r10
xorl %r15d, %r15d
testl %edx, %edx
jle 0xddde
movq %r15, %r8
imulq %r9, %r8
leaq (%rcx,%r8,4), %r12
movq -0x8(%rsp), %r13
xorl %ebp, %ebp
testl %esi, %esi
jle 0xddd3
movss (%r12,%rbp,4), %xmm1
mulss %xmm0, %xmm1
xorl %r8d, %r8d
movss (%r13,%r8,4), %xmm2
mulss %xmm1, %xmm2
addss (%rax,%r8,4), %xmm2
movss %xmm2, (%rax,%r8,4)
incq %r8
cmpq %r8, %r14
jne 0xddb4
incq %rbp
addq %r10, %r13
cmpq %rbx, %rbp
jne 0xdda3
incq %r15
addq %r11, %rax
cmpq %rdi, %r15
jne 0xdd8d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/gemm.c
// Function: gemm_nt
void gemm_nt(int M, int N, int K, float ALPHA, 
        float *A, int lda, 
        float *B, int ldb,
        float *C, int ldc)
{
    int i,j,k;
    #pragma omp parallel for
    for(i = 0; i < M; ++i){
        for(j = 0; j < N; ++j){
            register float sum = 0;
            for(k = 0; k < K; ++k){
                sum += ALPHA*A[i*lda+k]*B[j*ldb + k];
            }
            C[i*ldc+j] += sum;
        }
    }
}

// Assembly:
testl %edi, %edi
jle 0xde8f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x38(%rsp), %r10
movslq %r8d, %r8
movslq 0x48(%rsp), %r11
movl %edi, %edi
movl %esi, %ebx
movl %edx, %r14d
shlq $0x2, %r10
shlq $0x2, %r8
xorl %r15d, %r15d
testl %esi, %esi
jle 0xde7a
movq %r15, %rax
imulq %r11, %rax
movq 0x40(%rsp), %r12
leaq (%r12,%rax,4), %r12
movq %r9, %r13
xorl %ebp, %ebp
xorps %xmm1, %xmm1
testl %edx, %edx
jle 0xde63
xorl %eax, %eax
movss (%rcx,%rax,4), %xmm2
mulss %xmm0, %xmm2
mulss (%r13,%rax,4), %xmm2
addss %xmm2, %xmm1
incq %rax
cmpq %rax, %r14
jne 0xde47
addss (%r12,%rbp,4), %xmm1
movss %xmm1, (%r12,%rbp,4)
incq %rbp
addq %r10, %r13
cmpq %rbx, %rbp
jne 0xde3e
incq %r15
addq %r8, %rcx
cmpq %rdi, %r15
jne 0xde25
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/gemm.c
// Function: gemm_tt
void gemm_tt(int M, int N, int K, float ALPHA, 
        float *A, int lda, 
        float *B, int ldb,
        float *C, int ldc)
{
    int i,j,k;
    #pragma omp parallel for
    for(i = 0; i < M; ++i){
        for(j = 0; j < N; ++j){
            register float sum = 0;
            for(k = 0; k < K; ++k){
                sum += ALPHA*A[i+k*lda]*B[k+j*ldb];
            }
            C[i*ldc+j] += sum;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x8(%rsp)
testl %edi, %edi
jle 0xdfce
movq %rcx, %rax
movslq %r8d, %r8
movslq 0x38(%rsp), %r10
movslq 0x48(%rsp), %r9
movl %edi, %edi
movl %esi, %ebx
movl %edx, %r14d
shlq $0x2, %r10
shlq $0x2, %r8
xorl %r15d, %r15d
testl %esi, %esi
jle 0xdfc2
movq %r15, %rcx
imulq %r9, %rcx
movq 0x40(%rsp), %r11
leaq (%r11,%rcx,4), %r12
movq -0x8(%rsp), %r13
xorl %ebp, %ebp
xorps %xmm1, %xmm1
testl %edx, %edx
jle 0xdfab
movq %rax, %rcx
xorl %r11d, %r11d
movss (%rcx), %xmm2
mulss %xmm0, %xmm2
mulss (%r13,%r11,4), %xmm2
addss %xmm2, %xmm1
incq %r11
addq %r8, %rcx
cmpq %r11, %r14
jne 0xdf8d
addss (%r12,%rbp,4), %xmm1
movss %xmm1, (%r12,%rbp,4)
incq %rbp
addq %r10, %r13
cmpq %rbx, %rbp
jne 0xdf80
incq %r15
addq $0x4, %rax
cmpq %rdi, %r15
jne 0xdf65
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: read_intlist
int *read_intlist(char *gpu_list, int *ngpus, int d)
{
    int *gpus = 0;
    if(gpu_list){
        int len = strlen(gpu_list);
        *ngpus = 1;
        int i;
        for(i = 0; i < len; ++i){
            if (gpu_list[i] == ',') ++*ngpus;
        }
        gpus = calloc(*ngpus, sizeof(int));
        for(i = 0; i < *ngpus; ++i){
            gpus[i] = atoi(gpu_list);
            gpu_list = strchr(gpu_list, ',')+1;
        }
    } else {
        gpus = calloc(1, sizeof(float));
        *gpus = d;
        *ngpus = 1;
    }
    return gpus;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0xe096
movq %rdi, %rbx
callq 0x3150
movl $0x1, (%r14)
testl %eax, %eax
jle 0xe052
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb $0x2c, (%rbx,%rcx)
jne 0xe04a
incl (%r14)
incq %rcx
cmpq %rcx, %rax
jne 0xe041
movslq (%r14), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x3260
movq %rax, %r15
testq %r14, %r14
jle 0xe0b3
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x3410
movl %eax, (%r15,%r12,4)
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x3160
movq %rax, %rbx
incq %rbx
incq %r12
cmpq %r12, %r14
jne 0xe06d
jmp 0xe0b3
movl %edx, %ebp
movl $0x1, %edi
movl $0x4, %esi
callq 0x3260
movq %rax, %r15
movl %ebp, (%rax)
movl $0x1, (%r14)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: read_map
int *read_map(char *filename)
{
    int n = 0;
    int *map = 0;
    char *str;
    FILE *file = fopen(filename, "r");
    if(!file) file_error(filename);
    while((str=fgetl(file))){
        ++n;
        map = realloc(map, n*sizeof(int));
        map[n-1] = atoi(str);
    }
    return map;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4ac00(%rip), %rsi     # 0x58cd1
callq 0x33a0
testq %rax, %rax
je 0xe13a
movq %rax, %rbx
movq %rax, %rdi
callq 0xe165
testq %rax, %rax
je 0xe128
movq %rax, %r12
movl $0x4, %r15d
xorl %r14d, %r14d
movq %r14, %rdi
movq %r15, %rsi
callq 0x3360
movq %rax, %r14
movq %r12, %rdi
callq 0x3410
movl %eax, -0x4(%r14,%r15)
movq %rbx, %rdi
callq 0xe165
movq %rax, %r12
addq $0x4, %r15
testq %rax, %rax
jne 0xe0f7
jmp 0xe12b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x3510
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: fgetl
char *fgetl(FILE *fp)
{
    if(feof(fp)) return 0;
    size_t size = 512;
    char *line = malloc(size*sizeof(char));
    if(!fgets(line, size, fp)){
        free(line);
        return 0;
    }

    size_t curr = strlen(line);

    while((line[curr-1] != '\n') && !feof(fp)){
        if(curr == size-1){
            size *= 2;
            line = realloc(line, size*sizeof(char));
            if(!line) {
                printf("%ld\n", size);
                malloc_error();
            }
        }
        size_t readsize = size-curr;
        if(readsize > INT_MAX) readsize = INT_MAX-1;
        fgets(&line[curr], readsize, fp);
        curr = strlen(line);
    }
    if(line[curr-1] == '\n') line[curr-1] = '\0';

    return line;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x32a0
testl %eax, %eax
je 0xe190
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x200, %edi            # imm = 0x200
callq 0x3310
movq %rax, %rbx
movq %rax, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdx
callq 0x3240
testq %rax, %rax
je 0xe258
movq %rbx, %rdi
callq 0x3150
leaq -0x1(%rax), %r13
cmpb $0xa, -0x1(%rbx,%rax)
je 0xe243
movq %rax, %r15
movq %r14, %rdi
callq 0x32a0
testl %eax, %eax
jne 0xe243
movl $0x200, %r12d           # imm = 0x200
movl $0x7ffffffe, %ebp       # imm = 0x7FFFFFFE
leaq -0x1(%r12), %rax
cmpq %rax, %r15
jne 0xe203
addq %r12, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3360
testq %rax, %rax
je 0xe265
movq %rax, %rbx
movq %r12, %rsi
subq %r15, %rsi
addq %rbx, %r15
cmpq $0x7fffffff, %rsi       # imm = 0x7FFFFFFF
cmoval %ebp, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0x3240
movq %rbx, %rdi
callq 0x3150
leaq -0x1(%rax), %r13
cmpb $0xa, -0x1(%rbx,%rax)
je 0xe243
movq %rax, %r15
movq %r14, %rdi
callq 0x32a0
testl %eax, %eax
je 0xe1e3
cmpb $0xa, (%rbx,%r13)
jne 0xe17e
movb $0x0, (%rbx,%r13)
jmp 0xe17e
movq %rbx, %rdi
callq 0x3040
jmp 0xe17c
movq %r12, %rdi
callq 0x3533
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: sorta_shuffle
void sorta_shuffle(void *arr, size_t n, size_t size, size_t sections)
{
    size_t i;
    for(i = 0; i < sections; ++i){
        size_t start = n*i/sections;
        size_t end = n*(i+1)/sections;
        size_t num = end-start;
        shuffle(arr+(start*size), num, size);
    }
}

// Assembly:
testq %rcx, %rcx
je 0xe2cd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq %rcx, %rbp
movq %r13, %rax
xorl %edx, %edx
divq %rbx
movq %rax, %rdi
addq %r15, %r13
movq %r13, %rax
xorl %edx, %edx
divq %rbx
subq %rdi, %rax
imulq %r14, %rdi
addq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xe2ce
decq %rbp
jne 0xe28f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: shuffle
void shuffle(void *arr, size_t n, size_t size)
{
    size_t i;
    void *swp = calloc(1, size);
    for(i = 0; i < n-1; ++i){
        size_t j = i + rand()/(RAND_MAX / (n-i)+1);
        memcpy(swp,          arr+(j*size), size);
        memcpy(arr+(j*size), arr+(i*size), size);
        memcpy(arr+(i*size), swp,          size);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
movl $0x1, %edi
movq %rdx, %rsi
callq 0x3260
cmpq $0x1, %r14
je 0xe365
movq %rax, %r12
xorl %r15d, %r15d
movq (%rsp), %r13
callq 0x34f0
movslq %eax, %rcx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %r14
movq %rax, %rsi
incq %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
leaq (%rax,%r15), %rbp
imulq %rbx, %rbp
addq (%rsp), %rbp
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x32c0
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x32c0
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x32c0
incq %r15
decq %r14
addq %rbx, %r13
cmpq $0x1, %r14
jne 0xe300
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: random_index_order
int *random_index_order(int min, int max)
{
    int *inds = calloc(max-min, sizeof(int));
    int i;
    for(i = min; i < max; ++i){
        inds[i] = i;
    }
    for(i = min; i < max-1; ++i){
        int swap = inds[i];
        int index = i + rand()%(max-i);
        inds[i] = inds[index];
        inds[index] = swap;
    }
    return inds;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %r14d
movl %esi, %eax
subl %edi, %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3260
movq %rax, %rbx
movl %ebp, %r15d
movslq %r14d, %rax
subl %r14d, %r15d
jle 0xe3bd
movslq %ebp, %rcx
movl %eax, %edx
leaq (%rbx,%rax,4), %rsi
subq %rax, %rcx
xorl %edi, %edi
leal (%rdx,%rdi), %r8d
movl %r8d, (%rsi,%rdi,4)
incq %rdi
cmpq %rdi, %rcx
jne 0xe3ad
decl %ebp
cmpl %r14d, %ebp
jle 0xe3ef
leaq (%rbx,%rax,4), %r14
movl (%r14), %ebp
callq 0x34f0
cltd
idivl %r15d
movslq %edx, %rax
movl (%r14,%rax,4), %ecx
movl %ecx, (%r14)
movl %ebp, (%r14,%rax,4)
addq $0x4, %r14
decl %r15d
cmpl $0x1, %r15d
jne 0xe3c8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: find_arg
int find_arg(int argc, char* argv[], char *arg)
{
    int i;
    for(i = 0; i < argc; ++i) {
        if(!argv[i]) continue;
        if(0==strcmp(argv[i], arg)) {
            del_arg(argc, argv, i);
            return 1;
        }
    }
    return 0;
}

// Assembly:
testl %edi, %edi
jle 0xe474
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, %r12d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0xe468
movq %r14, %rsi
callq 0x3270
testl %eax, %eax
je 0xe477
incq %r15
cmpq %r15, %r12
jne 0xe453
xorl %eax, %eax
jmp 0xe4aa
xorl %eax, %eax
retq
decl %ebp
cmpl %r15d, %ebp
jle 0xe498
movslq %ebp, %rcx
leaq 0x1(%r15), %rax
movq 0x8(%rbx,%r15,8), %rdx
movq %rdx, (%rbx,%r15,8)
movq %rax, %r15
cmpq %rax, %rcx
jne 0xe481
jmp 0xe49b
movq %r15, %rax
cltq
movq $0x0, (%rbx,%rax,8)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: find_int_arg
int find_int_arg(int argc, char **argv, char *arg, int def)
{
    int i;
    for(i = 0; i < argc-1; ++i){
        if(!argv[i]) continue;
        if(0==strcmp(argv[i], arg)){
            def = atoi(argv[i+1]);
            del_arg(argc, argv, i);
            del_arg(argc, argv, i);
            break;
        }
    }
    return def;
}

// Assembly:
movl %ecx, %eax
cmpl $0x2, %edi
jl 0xe579
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %eax, 0x4(%rsp)
decl %edi
movabsq $0x100000000, %r13      # imm = 0x100000000
movl %edi, (%rsp)
movl %edi, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0xe4fe
movq %r15, %rsi
callq 0x3270
testl %eax, %eax
je 0xe50f
incq %rbx
addq %r13, %r12
cmpq %rbx, %rbp
jne 0xe4e9
movl 0x4(%rsp), %eax
jmp 0xe56b
movq 0x8(%r14,%rbx,8), %rdi
callq 0x3410
movslq (%rsp), %rdi
movq %r12, %rcx
movq %rbx, %rdx
movq 0x8(%r14,%rdx,8), %rsi
movq %rsi, (%r14,%rdx,8)
leaq 0x1(%rdx), %rsi
addq %r13, %rcx
movq %rsi, %rdx
cmpq %rsi, %rdi
jne 0xe523
sarq $0x1d, %rcx
movq $0x0, (%r14,%rcx)
movq 0x8(%r14,%rbx,8), %rcx
movq %rcx, (%r14,%rbx,8)
leaq 0x1(%rbx), %rcx
addq %r13, %r12
movq %rcx, %rbx
cmpq %rcx, %rdi
jne 0xe547
sarq $0x1d, %r12
movq $0x0, (%r14,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: find_float_arg
float find_float_arg(int argc, char **argv, char *arg, float def)
{
    int i;
    for(i = 0; i < argc-1; ++i){
        if(!argv[i]) continue;
        if(0==strcmp(argv[i], arg)){
            def = atof(argv[i+1]);
            del_arg(argc, argv, i);
            del_arg(argc, argv, i);
            break;
        }
    }
    return def;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm0, (%rsp)
cmpl $0x2, %edi
jl 0xe639
movq %rdx, %r14
movq %rsi, %rbx
decl %edi
movabsq $0x100000000, %r12      # imm = 0x100000000
movl %edi, 0x4(%rsp)
movl %edi, %ebp
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rdi
testq %rdi, %rdi
je 0xe5c6
movq %r14, %rsi
callq 0x3270
testl %eax, %eax
je 0xe5d3
incq %r13
addq %r12, %r15
cmpq %r13, %rbp
jne 0xe5b1
jmp 0xe639
movq 0x8(%rbx,%r13,8), %rdi
callq 0x3100
movslq 0x4(%rsp), %rax
movq %r15, %rcx
movq %r13, %rdx
movq 0x8(%rbx,%rdx,8), %rsi
movq %rsi, (%rbx,%rdx,8)
leaq 0x1(%rdx), %rsi
addq %r12, %rcx
movq %rsi, %rdx
cmpq %rsi, %rax
jne 0xe5e8
sarq $0x1d, %rcx
movq $0x0, (%rbx,%rcx)
movq 0x8(%rbx,%r13,8), %rcx
movq %rcx, (%rbx,%r13,8)
leaq 0x1(%r13), %rcx
addq %r12, %r15
movq %rcx, %r13
cmpq %rcx, %rax
jne 0xe60c
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
sarq $0x1d, %r15
movq $0x0, (%rbx,%r15)
movss (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: find_char_arg
char *find_char_arg(int argc, char **argv, char *arg, char *def)
{
    int i;
    for(i = 0; i < argc-1; ++i){
        if(!argv[i]) continue;
        if(0==strcmp(argv[i], arg)){
            def = argv[i+1];
            del_arg(argc, argv, i);
            del_arg(argc, argv, i);
            break;
        }
    }
    return def;
}

// Assembly:
movq %rcx, %rax
cmpl $0x2, %edi
jl 0xe716
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rax, 0x10(%rsp)
decl %edi
movabsq $0x100000000, %r13      # imm = 0x100000000
movl %edi, 0xc(%rsp)
movl %edi, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0xe69e
movq %r15, %rsi
callq 0x3270
testl %eax, %eax
je 0xe6b0
incq %rbx
addq %r13, %r12
cmpq %rbx, %rbp
jne 0xe689
movq 0x10(%rsp), %rax
jmp 0xe708
movq 0x8(%r14,%rbx,8), %rax
movslq 0xc(%rsp), %rdi
movq %r12, %rcx
movq %rbx, %rdx
movq 0x8(%r14,%rdx,8), %rsi
movq %rsi, (%r14,%rdx,8)
leaq 0x1(%rdx), %rsi
addq %r13, %rcx
movq %rsi, %rdx
cmpq %rsi, %rdi
jne 0xe6c0
sarq $0x1d, %rcx
movq $0x0, (%r14,%rcx)
movq 0x8(%r14,%rbx,8), %rcx
movq %rcx, (%r14,%rbx,8)
leaq 0x1(%rbx), %rcx
addq %r13, %r12
movq %rcx, %rbx
cmpq %rcx, %rdi
jne 0xe6e4
sarq $0x1d, %r12
movq $0x0, (%r14,%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: basecfg
char *basecfg(char *cfgfile)
{
    char *c = cfgfile;
    char *next;
    while((next = strchr(c, '/')))
    {
        c = next+1;
    }
    c = copy_string(c);
    next = strchr(c, '.');
    if (next) *next = 0;
    return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x3160
leaq 0x1(%rax), %rdi
testq %rax, %rax
jne 0xe718
movq %rbx, %rdi
callq 0xe753
movq %rax, %rbx
movq %rax, %rdi
movl $0x2e, %esi
callq 0x3160
testq %rax, %rax
je 0xe74e
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: pm
void pm(int M, int N, float *A)
{
    int i,j;
    for(i =0 ; i < M; ++i){
        printf("%d ", i+1);
        for(j = 0; j < N; ++j){
            printf("%2.4f, ", A[i*N+j]);
        }
        printf("\n");
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
testl %edi, %edi
jle 0xe82a
movq %rdx, %rbx
movl 0xc(%rsp), %r13d
movl %edi, %eax
movq %rax, 0x10(%rsp)
leaq (,%r13,4), %rbp
leaq 0x448a6(%rip), %r15     # 0x53080
xorl %r12d, %r12d
incq %r12
leaq 0x44895(%rip), %rdi     # 0x5307c
movl %r12d, %esi
xorl %eax, %eax
callq 0x3170
cmpl $0x0, 0xc(%rsp)
jle 0xe816
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r14,4), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x3170
incq %r14
cmpq %r14, %r13
jne 0xe7fb
movl $0xa, %edi
callq 0x3060
addq %rbp, %rbx
cmpq 0x10(%rsp), %r12
jne 0xe7dd
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: find_replace
void find_replace(char *str, char *orig, char *rep, char *output)
{
    char buffer[4096] = {0};
    char *p;

    sprintf(buffer, "%s", str);
    if(!(p = strstr(buffer, orig))){  // Is 'orig' even in 'str'?
        sprintf(output, "%s", str);
        return;
    }

    *p = '\0';

    sprintf(output, "%s%s%s", buffer, rep, p+strlen(orig));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r13
movl $0x1000, %edx           # imm = 0x1000
movq %r13, %rdi
xorl %esi, %esi
callq 0x31d0
movq %r13, %rdi
movq %r12, %rsi
callq 0x30a0
movq %r13, %rdi
movq %r15, %rsi
callq 0x34c0
testq %rax, %rax
je 0xe8b8
movq %rax, %r13
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x3150
addq %rax, %r13
leaq 0x447e5(%rip), %rsi     # 0x53088
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x3430
jmp 0xe8c3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x30a0
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: top_k
void top_k(float *a, int n, int k, int *index)
{
    int i,j;
    for(j = 0; j < k; ++j) index[j] = -1;
    for(i = 0; i < n; ++i){
        int curr = i;
        for(j = 0; j < k; ++j){
            if((index[j] < 0) || a[curr] > a[index[j]]){
                int swap = curr;
                curr = index[j];
                index[j] = swap;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl %edx, %r12d
testl %edx, %edx
jle 0xe911
leaq (,%r12,4), %rdx
movq %rbx, %rdi
movl $0xff, %esi
callq 0x31d0
testl %r14d, %r14d
jle 0xe94d
xorl %eax, %eax
testl %ebp, %ebp
jle 0xe946
xorl %ecx, %ecx
movl %eax, %edx
movslq (%rbx,%rcx,4), %rsi
testq %rsi, %rsi
js 0xe939
movslq %edx, %rdi
movss (%r15,%rdi,4), %xmm0
ucomiss (%r15,%rsi,4), %xmm0
jbe 0xe93e
movl %edx, (%rbx,%rcx,4)
movl %esi, %edx
incq %rcx
cmpq %rcx, %r12
jne 0xe920
incl %eax
cmpl %r14d, %eax
jne 0xe918
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: read_file
unsigned char *read_file(char *filename)
{
    FILE *fp = fopen(filename, "rb");
    size_t size;

    fseek(fp, 0, SEEK_END); 
    size = ftell(fp);
    fseek(fp, 0, SEEK_SET); 

    unsigned char *text = calloc(size+1, sizeof(char));
    fread(text, 1, size, fp);
    fclose(fp);
    return text;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x44729(%rip), %rsi     # 0x530b0
callq 0x33a0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3350
movq %rbx, %rdi
callq 0x3290
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3350
leaq 0x1(%r14), %rdi
movl $0x1, %esi
callq 0x3260
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30e0
movq %rbx, %rdi
callq 0x3140
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: split_str
list *split_str(char *s, char delim)
{
    size_t i;
    size_t len = strlen(s);
    list *l = make_list();
    list_insert(l, s);
    for(i = 0; i < len; ++i){
        if(s[i] == delim){
            s[i] = '\0';
            list_insert(l, &(s[i+1]));
        }
    }
    return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3150
movq %rax, %r15
xorl %eax, %eax
callq 0x10ea0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x10ef9
testq %r15, %r15
je 0xea65
incq %r14
cmpb %bl, -0x1(%r14)
jne 0xea5d
movb $0x0, -0x1(%r14)
movq %r12, %rdi
movq %r14, %rsi
callq 0x10ef9
incq %r14
decq %r15
jne 0xea47
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: strip
void strip(char *s)
{
    size_t i;
    size_t len = strlen(s);
    size_t offset = 0;
    for(i = 0; i < len; ++i){
        char c = s[i];
        if(c==' '||c=='\t'||c=='\n') ++offset;
        else s[i-offset] = c;
    }
    s[len-offset] = '\0';
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3150
xorl %ecx, %ecx
testq %rax, %rax
je 0xeaba
movabsq $0x100000600, %rdx      # imm = 0x100000600
movq %rax, %rsi
movq %rbx, %rdi
movzbl (%rdi), %r8d
cmpq $0x20, %r8
ja 0xeaa9
btq %r8, %rdx
jae 0xeaa9
incq %rcx
jmp 0xeab2
movq %rdi, %r9
subq %rcx, %r9
movb %r8b, (%r9)
incq %rdi
decq %rsi
jne 0xea94
subq %rcx, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: strip_char
void strip_char(char *s, char bad)
{
    size_t i;
    size_t len = strlen(s);
    size_t offset = 0;
    for(i = 0; i < len; ++i){
        char c = s[i];
        if(c==bad) ++offset;
        else s[i-offset] = c;
    }
    s[len-offset] = '\0';
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3150
xorl %ecx, %ecx
testq %rax, %rax
je 0xeafb
movq %rax, %rdx
movq %rbx, %rsi
movb (%rsi), %dil
cmpb %bpl, %dil
jne 0xeaea
incq %rcx
jmp 0xeaf3
movq %rsi, %r8
subq %rcx, %r8
movb %dil, (%r8)
incq %rsi
decq %rdx
jne 0xeadd
subq %rcx, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: read_all
void read_all(int fd, char *buffer, size_t bytes)
{
    size_t n = 0;
    while(n < bytes){
        int next = read(fd, buffer + n, bytes-n);
        if(next <= 0) error("read failed");
        n += next;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xec47
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r15d, %r15d
leaq (%r14,%r15), %rsi
movq %rbx, %rdx
subq %r15, %rdx
movl %ebp, %edi
callq 0x3220
testl %eax, %eax
jle 0xec52
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r15
cmpq %rbx, %r15
jb 0xec25
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3595
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: write_all
void write_all(int fd, char *buffer, size_t bytes)
{
    size_t n = 0;
    while(n < bytes){
        size_t next = write(fd, buffer + n, bytes-n);
        if(next <= 0) error("write failed");
        n += next;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xec8c
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r15d, %r15d
leaq (%r14,%r15), %rsi
movq %rbx, %rdx
subq %r15, %rdx
movl %ebp, %edi
callq 0x3110
testq %rax, %rax
je 0xec97
addq %rax, %r15
cmpq %rbx, %r15
jb 0xec6e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x35c1
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: parse_csv_line
list *parse_csv_line(char *line)
{
    list *l = make_list();
    char *c, *p;
    int in = 0;
    for(c = line, p = line; *c != '\0'; ++c){
        if(*c == '"') in = !in;
        else if(*c == ',' && !in){
            *c = '\0';
            list_insert(l, copy_string(p));
            p = c+1;
        }
    }
    list_insert(l, copy_string(p));
    return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x10ea0
movq %rax, %rbx
leaq 0x1(%r14), %r15
movzbl -0x1(%r15), %eax
cmpl $0x22, %eax
je 0xeceb
testl %eax, %eax
je 0xecf9
cmpb $0x2c, %al
jne 0xecf4
testl %ebp, %ebp
jne 0xecf4
movb $0x0, -0x1(%r15)
movq %r14, %rdi
callq 0xe753
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10ef9
xorl %ebp, %ebp
movq %r15, %r14
jmp 0xecf4
xorl %eax, %eax
testl %ebp, %ebp
sete %al
movl %eax, %ebp
incq %r15
jmp 0xecb6
movq %r14, %rdi
callq 0xe753
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10ef9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: count_fields
int count_fields(char *line)
{
    int count = 0;
    int done = 0;
    char *c;
    for(c = line; !done; ++c){
        done = (*c == '\0');
        if(*c == ',' || done) ++count;
    }
    return count;
}

// Assembly:
xorl %eax, %eax
movzbl (%rdi), %ecx
cmpl $0x2c, %ecx
je 0xed28
testl %ecx, %ecx
jne 0xed2a
incl %eax
incq %rdi
testb %cl, %cl
jne 0xed1c
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: parse_fields
float *parse_fields(char *line, int n)
{
    float *field = calloc(n, sizeof(float));
    char *c, *p, *end;
    int count = 0;
    int done = 0;
    for(c = line, p = line; !done; ++c){
        done = (*c == '\0');
        if(*c == ',' || done){
            *c = '\0';
            field[count] = strtod(p, &end);
            if(p == c) field[count] = nan("");
            if(end != c && (end != c-1 || *end != '\r')) field[count] = nan(""); //DOS file formats!
            p = c+1;
            ++count;
        }
    }
    return field;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movslq %esi, %rdi
movl $0x4, %esi
callq 0x3260
movq %rax, %rbx
xorl %ebp, %ebp
movq %r12, %r13
movzbl (%r13), %r15d
cmpl $0x2c, %r15d
je 0xed65
testl %r15d, %r15d
jne 0xedd0
movb $0x0, (%r13)
movq %r12, %rdi
movq %rsp, %rsi
callq 0x30f0
cvtsd2ss %xmm0, %xmm0
movslq %ebp, %r14
movss %xmm0, (%rbx,%r14,4)
cmpq %r12, %r13
jne 0xed9d
leaq 0x48e68(%rip), %rdi     # 0x57bf6
callq 0x3460
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx,%r14,4)
movq (%rsp), %rax
cmpq %rax, %r13
je 0xedca
leaq -0x1(%r13), %rcx
cmpq %rax, %rcx
jne 0xedb4
cmpb $0xd, (%rax)
je 0xedca
leaq 0x48e3b(%rip), %rdi     # 0x57bf6
callq 0x3460
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx,%r14,4)
leaq 0x1(%r13), %r12
incl %ebp
incq %r13
testb %r15b, %r15b
jne 0xed55
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_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: mean_arrays
void mean_arrays(float **a, int n, int els, float *avg)
{
    int i;
    int j;
    memset(avg, 0, els*sizeof(float));
    for(j = 0; j < n; ++j){
        for(i = 0; i < els; ++i){
            avg[i] += a[j][i];
        }
    }
    for(i = 0; i < els; ++i){
        avg[i] /= n;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %r15
movslq %edx, %rdx
shlq $0x2, %rdx
movq %rcx, %rdi
xorl %esi, %esi
callq 0x31d0
movl %r14d, %eax
testl %ebp, %ebp
jle 0xee89
movl %ebp, %ecx
xorl %edx, %edx
testl %r14d, %r14d
jle 0xee81
movq (%r15,%rdx,8), %rsi
xorl %edi, %edi
movss (%rsi,%rdi,4), %xmm0
addss (%rbx,%rdi,4), %xmm0
movss %xmm0, (%rbx,%rdi,4)
incq %rdi
cmpq %rdi, %rax
jne 0xee6a
incq %rdx
cmpq %rcx, %rdx
jne 0xee5f
testl %r14d, %r14d
jle 0xeead
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
xorl %ecx, %ecx
movss (%rbx,%rcx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xee97
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: variance_array
float variance_array(float *a, int n)
{
    int i;
    float sum = 0;
    float mean = mean_array(a, n);
    for(i = 0; i < n; ++i) sum += (a[i] - mean)*(a[i]-mean);
    float variance = sum/n;
    return variance;
}

// Assembly:
xorps %xmm0, %xmm0
movl %esi, %eax
xorps %xmm1, %xmm1
testl %esi, %esi
jle 0xef90
xorl %ecx, %ecx
addss (%rdi,%rcx,4), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0xef83
cvtsi2ss %esi, %xmm2
testl %esi, %esi
jle 0xefba
divss %xmm2, %xmm1
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm3
subss %xmm1, %xmm3
mulss %xmm3, %xmm3
addss %xmm3, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0xefa1
divss %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: normalize_array
void normalize_array(float *a, int n)
{
    int i;
    float mu = mean_array(a,n);
    float sigma = sqrt(variance_array(a,n));
    for(i = 0; i < n; ++i){
        a[i] = (a[i] - mu)/sigma;
    }
    mu = mean_array(a,n);
    sigma = sqrt(variance_array(a,n));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
xorps %xmm0, %xmm0
testl %esi, %esi
jle 0xf088
xorl %eax, %eax
addss (%r14,%rax,4), %xmm0
incq %rax
cmpq %rax, %r15
jne 0xf07a
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
movl %ebx, %esi
callq 0xef75
ucomiss 0x43fd9(%rip), %xmm0    # 0x53078
jb 0xf0a7
sqrtss %xmm0, %xmm0
jmp 0xf0ac
callq 0x32f0
testl %ebx, %ebx
movss 0xc(%rsp), %xmm2
jle 0xf0dc
cvtsi2ss %ebx, %xmm1
divss %xmm1, %xmm2
xorl %eax, %eax
movss (%r14,%rax,4), %xmm1
subss %xmm2, %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%r14,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xf0c0
movq %r14, %rdi
movl %ebx, %esi
callq 0xef75
xorps %xmm1, %xmm1
addq $0x10, %rsp
ucomiss %xmm1, %xmm0
jb 0xf0f8
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x32f0
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: mag_array
float mag_array(float *a, int n)
{
    int i;
    float sum = 0;
    for(i = 0; i < n; ++i){
        sum += a[i]*a[i];   
    }
    return sqrt(sum);
}

// Assembly:
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
testl %esi, %esi
jle 0xf144
movl %esi, %eax
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm2
mulss %xmm2, %xmm2
addss %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0xf12f
ucomiss %xmm1, %xmm0
jb 0x32f0
sqrtss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: sample_array
int sample_array(float *a, int n)
{
    float sum = sum_array(a, n);
    scale_array(a, n, 1./sum);
    float r = rand_uniform(0, 1);
    int i;
    for(i = 0; i < n; ++i){
        r = r - a[i];
        if (r <= 0) return i;
    }
    return n-1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
xorps %xmm0, %xmm0
testl %esi, %esi
jle 0xf195
xorl %eax, %eax
addss (%r14,%rax,4), %xmm0
incq %rax
cmpq %rax, %r15
jne 0xf187
testl %ebx, %ebx
jle 0xf1bf
movss 0x43e67(%rip), %xmm1    # 0x53008
divss %xmm0, %xmm1
xorl %eax, %eax
movss (%r14,%rax,4), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%r14,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xf1a7
callq 0x34f0
testl %ebx, %ebx
jle 0xf1f3
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x43e2d(%rip), %xmm0    # 0x53004
xorps %xmm1, %xmm1
addss %xmm1, %xmm0
xorl %eax, %eax
subss (%r14,%rax,4), %xmm0
ucomiss %xmm0, %xmm1
jae 0xf1f7
incq %rax
cmpq %rax, %r15
jne 0xf1e0
decl %ebx
jmp 0xf1f9
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: max_int_index
int max_int_index(int *a, int n)
{
    if(n <= 0) return -1;
    int i, max_i = 0;
    int max = a[0];
    for(i = 1; i < n; ++i){
        if(a[i] > max){
            max = a[i];
            max_i = i;
        }
    }
    return max_i;
}

// Assembly:
testl %esi, %esi
jle 0xf272
xorl %eax, %eax
cmpl $0x1, %esi
je 0xf271
movl (%rdi), %ecx
movl %esi, %edx
xorl %eax, %eax
movl $0x1, %esi
movl (%rdi,%rsi,4), %r8d
cmpl %ecx, %r8d
cmovgl %esi, %eax
cmovgl %r8d, %ecx
incq %rsi
cmpq %rsi, %rdx
jne 0xf25b
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: max_index
int max_index(float *a, int n)
{
    if(n <= 0) return -1;
    int i, max_i = 0;
    float max = a[0];
    for(i = 1; i < n; ++i){
        if(a[i] > max){
            max = a[i];
            max_i = i;
        }
    }
    return max_i;
}

// Assembly:
testl %esi, %esi
jle 0xf2ab
xorl %eax, %eax
cmpl $0x1, %esi
je 0xf2aa
movss (%rdi), %xmm0
movl %esi, %ecx
xorl %eax, %eax
movl $0x1, %edx
movss (%rdi,%rdx,4), %xmm1
ucomiss %xmm0, %xmm1
cmoval %edx, %eax
maxss %xmm0, %xmm1
incq %rdx
movaps %xmm1, %xmm0
cmpq %rdx, %rcx
jne 0xf290
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: rand_normal
float rand_normal()
{
    static int haveSpare = 0;
    static double rand1, rand2;

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

    haveSpare = 1;

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

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

// Assembly:
pushq %rax
cmpb $0x1, 0x5b498(%rip)     # 0x6a7a8
jne 0xf331
movb $0x0, 0x5b48f(%rip)     # 0x6a7a8
movsd 0x5b48f(%rip), %xmm0    # 0x6a7b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xf3a6
sqrtsd %xmm0, %xmm0
jmp 0xf3ab
movb $0x1, 0x5b470(%rip)     # 0x6a7a8
callq 0x34f0
cvtsi2sd %eax, %xmm1
divsd 0x43d0f(%rip), %xmm1    # 0x53058
movsd 0x43d0f(%rip), %xmm0    # 0x53060
maxsd %xmm1, %xmm0
callq 0x31e0
mulsd 0x43d06(%rip), %xmm0    # 0x53068
movsd %xmm0, 0x5b446(%rip)    # 0x6a7b0
callq 0x34f0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x43cda(%rip), %xmm0    # 0x53058
mulsd 0x43cea(%rip), %xmm0    # 0x53070
movsd %xmm0, 0x5b42a(%rip)    # 0x6a7b8
movsd 0x5b41a(%rip), %xmm0    # 0x6a7b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xf3bf
sqrtsd %xmm0, %xmm0
jmp 0xf3c4
callq 0x3470
movsd %xmm0, (%rsp)
movsd 0x5b400(%rip), %xmm0    # 0x6a7b8
callq 0x33e0
jmp 0xf3d6
callq 0x3470
movsd %xmm0, (%rsp)
movsd 0x5b3e7(%rip), %xmm0    # 0x6a7b8
callq 0x31f0
mulsd (%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: rand_size_t
size_t rand_size_t()
{
    return  ((size_t)(rand()&0xff) << 56) | 
        ((size_t)(rand()&0xff) << 48) |
        ((size_t)(rand()&0xff) << 40) |
        ((size_t)(rand()&0xff) << 32) |
        ((size_t)(rand()&0xff) << 24) |
        ((size_t)(rand()&0xff) << 16) |
        ((size_t)(rand()&0xff) << 8) |
        ((size_t)(rand()&0xff) << 0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x34f0
movl %eax, %ebx
shlq $0x38, %rbx
callq 0x34f0
movl %eax, %r14d
movl $0xff, %ebp
andl %ebp, %r14d
shlq $0x30, %r14
orq %rbx, %r14
callq 0x34f0
movl %eax, %ebx
andl %ebp, %ebx
shlq $0x28, %rbx
orq %r14, %rbx
callq 0x34f0
movl %eax, %r14d
andl %ebp, %r14d
shlq $0x20, %r14
orq %rbx, %r14
callq 0x34f0
movl %eax, %ebx
shll $0x18, %ebx
orq %r14, %rbx
callq 0x34f0
movl %eax, %r14d
andl %ebp, %r14d
shll $0x10, %r14d
orq %rbx, %r14
callq 0x34f0
shll $0x8, %eax
movzwl %ax, %ebx
orq %r14, %rbx
callq 0x34f0
andl %ebp, %eax
orq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/utils.c
// Function: one_hot_encode
float **one_hot_encode(float *a, int n, int k)
{
    int i;
    float **t = calloc(n, sizeof(float*));
    for(i = 0; i < n; ++i){
        t[i] = calloc(k, sizeof(float));
        int index = (int)a[i];
        t[i][index] = 1;
    }
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x3260
movq %rax, %r14
testl %r12d, %r12d
jle 0xf530
movslq %r15d, %r15
movl %ebp, %r12d
xorl %r13d, %r13d
movl $0x4, %esi
movq %r15, %rdi
callq 0x3260
movq %rax, (%r14,%r13,8)
cvttss2si (%rbx,%r13,4), %ecx
movslq %ecx, %rcx
movl $0x3f800000, (%rax,%rcx,4) # imm = 0x3F800000
incq %r13
cmpq %r13, %r12
jne 0xf507
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/deconvolutional_layer.c
// Function: bilinear_init
void bilinear_init(layer l)
{
    int i,j,f;
    float center = (l.size-1) / 2.;
    for(f = 0; f < l.n; ++f){
        for(j = 0; j < l.size; ++j){
            for(i = 0; i < l.size; ++i){
                float val = (1 - fabs(i - center)) * (1 - fabs(j - center));
                int c = f%l.c;
                int ind = f*l.size*l.size*l.c + c*l.size*l.size + j*l.size + i;
                l.weights[ind] = val;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0xa4(%rsp), %esi
testl %esi, %esi
jle 0xf61c
leaq 0x20(%rsp), %rax
movl 0x90(%rax), %edi
leal -0x1(%rdi), %ecx
cvtsi2sd %ecx, %xmm0
mulsd 0x43bab(%rip), %xmm0    # 0x53120
cvtsd2ss %xmm0, %xmm0
movl 0x74(%rax), %r8d
movq 0x250(%rax), %r9
movl %edi, %r10d
imull %edi, %r10d
xorl %r11d, %r11d
movaps 0x43bab(%rip), %xmm1    # 0x53140
movsd 0x43b8b(%rip), %xmm2    # 0x53128
xorl %ecx, %ecx
testl %edi, %edi
jle 0xf613
movl %ecx, %eax
cltd
idivl %r8d
addl %r11d, %edx
imull %r10d, %edx
xorl %eax, %eax
xorps %xmm3, %xmm3
cvtsi2ss %eax, %xmm3
subss %xmm0, %xmm3
andps %xmm1, %xmm3
xorps %xmm4, %xmm4
cvtss2sd %xmm3, %xmm4
movapd %xmm2, %xmm3
subsd %xmm4, %xmm3
xorl %ebx, %ebx
xorps %xmm4, %xmm4
cvtsi2ss %ebx, %xmm4
subss %xmm0, %xmm4
andps %xmm1, %xmm4
cvtss2sd %xmm4, %xmm4
movapd %xmm2, %xmm5
subsd %xmm4, %xmm5
mulsd %xmm3, %xmm5
xorps %xmm4, %xmm4
cvtsd2ss %xmm5, %xmm4
leal (%rdx,%rbx), %ebp
movslq %ebp, %r14
movss %xmm4, (%r9,%r14,4)
incq %rbx
cmpq %rbx, %rdi
jne 0xf5d1
incl %eax
addq %rdi, %rdx
cmpl %edi, %eax
jne 0xf5b2
incl %ecx
addl %r8d, %r11d
cmpl %esi, %ecx
jne 0xf59f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/deconvolutional_layer.c
// Function: forward_deconvolutional_layer
void forward_deconvolutional_layer(const layer l, network net)
{
    int i;

    int m = l.size*l.size*l.n;
    int n = l.h*l.w;
    int k = l.c;

    fill_cpu(l.outputs*l.batch, 0, l.output, 1);

    for(i = 0; i < l.batch; ++i){
        float *a = l.weights;
        float *b = net.input + i*l.c*l.h*l.w;
        float *c = net.workspace;

        gemm_cpu(1,0,m,n,k,1,a,m,b,n,0,c,n);

        col2im_cpu(net.workspace, l.out_c, l.out_h, l.out_w, l.size, l.stride, l.pad, l.output+i*l.outputs);
    }
    if (l.batch_normalize) {
        forward_batchnorm_layer(l, net);
    } else {
        add_bias(l.output, l.biases, l.batch, l.n, l.out_w*l.out_h);
    }
    activate_array(l.output, l.batch*l.n*l.out_w*l.out_h, l.activation);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4e0(%rsp), %r14
leaq 0x40(%rsp), %rbx
movl 0x90(%rbx), %r15d
imull %r15d, %r15d
imull 0x84(%rbx), %r15d
movl 0x48(%rbx), %edi
movl 0x70(%rbx), %r12d
imull 0x6c(%rbx), %r12d
movl 0x74(%rbx), %ebp
imull 0x58(%rbx), %edi
movq 0x268(%rbx), %rsi
xorps %xmm0, %xmm0
movl $0x1, %edx
callq 0x2863b
movl 0x48(%rbx), %edx
testl %edx, %edx
jle 0xf739
xorl %r13d, %r13d
movq 0x250(%rbx), %r9
movslq 0x74(%rbx), %rcx
movslq %r13d, %r13
imulq %r13, %rcx
movslq 0x6c(%rbx), %rdx
movslq 0x70(%rbx), %rax
imulq %rdx, %rax
imulq %rcx, %rax
shlq $0x2, %rax
addq 0xd8(%r14), %rax
subq $0x8, %rsp
xorps %xmm1, %xmm1
movl $0x1, %edi
xorl %esi, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
movss 0x4393b(%rip), %xmm0    # 0x53008
pushq %r12
pushq 0xf0(%r14)
pushq %r12
pushq %rax
pushq %r15
callq 0xdc4a
addq $0x30, %rsp
movq 0xf0(%r14), %rdi
movl 0x80(%rbx), %esi
movl 0x78(%rbx), %edx
movl 0x7c(%rbx), %ecx
movl 0x90(%rbx), %r8d
movl 0x98(%rbx), %r9d
movl 0xa8(%rbx), %eax
movslq 0x58(%rbx), %r10
imulq %r13, %r10
shlq $0x2, %r10
addq 0x268(%rbx), %r10
pushq %r10
pushq %rax
callq 0x27a81
addq $0x10, %rsp
incl %r13d
movl 0x48(%rbx), %edx
cmpl %edx, %r13d
jl 0xf681
cmpl $0x0, 0x40(%rbx)
je 0xf775
subq $0x5b0, %rsp            # imm = 0x5B0
movl $0x94, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x4a0(%rsp), %rdi
movl $0x22, %ecx
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3a360
addq $0x5b0, %rsp            # imm = 0x5B0
jmp 0xf797
movq 0x268(%rbx), %rdi
movq 0x230(%rbx), %rsi
movl 0x78(%rbx), %r8d
movl 0x84(%rbx), %ecx
imull 0x7c(%rbx), %r8d
callq 0x10996
movq 0x268(%rbx), %rdi
movl 0x84(%rbx), %esi
imull 0x48(%rbx), %esi
imull 0x7c(%rbx), %esi
imull 0x78(%rbx), %esi
movl 0x4(%rbx), %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x275e5