LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: csv_to_matrix
matrix csv_to_matrix(char *filename)
{
    FILE *fp = fopen(filename, "r");
    if(!fp) file_error(filename);

    matrix m;
    m.cols = -1;

    char *line;

    int n = 0;
    int size = 1024;
    m.vals = calloc(size, sizeof(float*));
    while((line = fgetl(fp))){
        if(m.cols == -1) m.cols = count_fields(line);
        if(n == size){
            size *= 2;
            m.vals = realloc(m.vals, size*sizeof(float*));
        }
        m.vals[n] = parse_fields(line, m.cols);
        free(line);
        ++n;
    }
    m.vals = realloc(m.vals, n*sizeof(float*));
    m.rows = n;
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x3cef6(%rip), %rsi     # 0x7656d
callq 0x3360
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x39690
movq -0x18(%rbp), %rdi
callq 0x4110
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
movl $0x400, -0x30(%rbp)     # imm = 0x400
movslq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4140
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x39730
cmpl $-0x1, -0xc(%rbp)
jne 0x396dc
movq -0x28(%rbp), %rdi
callq 0x52c0
movl %eax, -0xc(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x39701
movl -0x30(%rbp), %eax
shll %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3310
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5340
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
callq 0x3030
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x396b7
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3310
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: matrix_to_csv
void matrix_to_csv(matrix m)
{
    int i, j;

    for(i = 0; i < m.rows; ++i){
        for(j = 0; j < m.cols; ++j){
            if(j > 0) printf(",");
            printf("%.17g", m.vals[i][j]);
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x397ed
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x397d4
cmpl $0x0, -0x18(%rbp)
jle 0x397a2
leaq 0x3bfb5(%rip), %rdi     # 0x75750
movb $0x0, %al
callq 0x3130
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3acc1(%rip), %rdi     # 0x74483
movb $0x1, %al
callq 0x3130
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x39786
leaq 0x3c5d3(%rip), %rdi     # 0x75dae
movb $0x0, %al
callq 0x3130
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x39777
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/matrix.c
// Function: print_matrix
void print_matrix(matrix m)
{
    int i, j;
    printf("%d X %d Matrix:\n",m.rows, m.cols);
    printf(" __");
    for(j = 0; j < 16*m.cols-1; ++j) printf(" ");
    printf("__ \n");

    printf("|  ");
    for(j = 0; j < 16*m.cols-1; ++j) printf(" ");
    printf("  |\n");

    for(i = 0; i < m.rows; ++i){
        printf("|  ");
        for(j = 0; j < m.cols; ++j){
            printf("%15.7f ", m.vals[i][j]);
        }
        printf(" |\n");
    }
    printf("|__");
    for(j = 0; j < 16*m.cols-1; ++j) printf(" ");
    printf("__|\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x3ac6c(%rip), %rdi     # 0x74489
movb $0x0, %al
callq 0x3130
leaq 0x3ac6f(%rip), %rdi     # 0x7449a
movb $0x0, %al
callq 0x3130
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
shll $0x4, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x39862
leaq 0x3c3b3(%rip), %rdi     # 0x75c03
movb $0x0, %al
callq 0x3130
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x39839
leaq 0x3ac35(%rip), %rdi     # 0x7449e
movb $0x0, %al
callq 0x3130
leaq 0x3ac2c(%rip), %rdi     # 0x744a3
movb $0x0, %al
callq 0x3130
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
shll $0x4, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x398ae
leaq 0x3c367(%rip), %rdi     # 0x75c03
movb $0x0, %al
callq 0x3130
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x39885
leaq 0x3abf2(%rip), %rdi     # 0x744a7
movb $0x0, %al
callq 0x3130
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x39933
leaq 0x3abd1(%rip), %rdi     # 0x744a3
movb $0x0, %al
callq 0x3130
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3991a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3aba4(%rip), %rdi     # 0x744ac
movb $0x1, %al
callq 0x3130
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x398e0
leaq 0x3ab87(%rip), %rdi     # 0x744a8
movb $0x0, %al
callq 0x3130
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x398c3
leaq 0x3ab7a(%rip), %rdi     # 0x744b4
movb $0x0, %al
callq 0x3130
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
shll $0x4, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x39971
leaq 0x3c2a4(%rip), %rdi     # 0x75c03
movb $0x0, %al
callq 0x3130
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x39948
leaq 0x3ab40(%rip), %rdi     # 0x744b8
movb $0x0, %al
callq 0x3130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: get_base_args
load_args get_base_args(network *net)
{
    load_args args = {0};
    args.w = net->w;
    args.h = net->h;
    args.size = net->w;

    args.min = net->min_crop;
    args.max = net->max_crop;
    args.angle = net->angle;
    args.aspect = net->aspect;
    args.exposure = net->exposure;
    args.center = net->center;
    args.saturation = net->saturation;
    args.hue = net->hue;
    return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
xorl %esi, %esi
movl $0xa8, %edx
callq 0x3190
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x94(%rcx), %ecx
movl %ecx, 0x2c(%rdi)
movq -0x8(%rbp), %rcx
movl 0x90(%rcx), %ecx
movl %ecx, 0x28(%rdi)
movq -0x8(%rbp), %rcx
movl 0x94(%rcx), %ecx
movl %ecx, 0x4c(%rdi)
movq -0x8(%rbp), %rcx
movl 0xa0(%rcx), %ecx
movl %ecx, 0x44(%rdi)
movq -0x8(%rbp), %rcx
movl 0x9c(%rcx), %ecx
movl %ecx, 0x48(%rdi)
movq -0x8(%rbp), %rcx
movss 0xb0(%rcx), %xmm0
movss %xmm0, 0x68(%rdi)
movq -0x8(%rbp), %rcx
movss 0xb4(%rcx), %xmm0
movss %xmm0, 0x6c(%rdi)
movq -0x8(%rbp), %rcx
movss 0xb8(%rcx), %xmm0
movss %xmm0, 0x74(%rdi)
movq -0x8(%rbp), %rcx
movl 0xac(%rcx), %ecx
movl %ecx, 0x5c(%rdi)
movq -0x8(%rbp), %rcx
movss 0xbc(%rcx), %xmm0
movss %xmm0, 0x70(%rdi)
movq -0x8(%rbp), %rcx
movss 0xc0(%rcx), %xmm0
movss %xmm0, 0x78(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: load_network
network *load_network(char *cfg, char *weights, int clear)
{
    network *net = parse_network_cfg(cfg);
    if(weights && weights[0] != 0){
        load_weights(net, weights);
    }
    if(clear) (*net->seen) = 0;
    return net;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x400e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x39ab0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x39ab0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42680
cmpl $0x0, -0x14(%rbp)
je 0x39ac5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: make_network
network *make_network(int n)
{
    network *net = calloc(1, sizeof(network));
    net->n = n;
    net->layers = calloc(net->n, sizeof(layer));
    net->seen = calloc(1, sizeof(size_t));
    net->t    = calloc(1, sizeof(int));
    net->cost = calloc(1, sizeof(float));
    return net;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x110, %esi            # imm = 0x110
callq 0x3220
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rdi
movl $0x4a0, %esi            # imm = 0x4A0
callq 0x3220
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x1, %edi
movl $0x8, %esi
callq 0x3220
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, %edi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, %edi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: forward_network
void forward_network(network *netp)
{
    network net = *netp;
    int i;
    for(i = 0; i < net.n; ++i){
        net.index = i;
        layer l = net.layers[i];
        if(l.delta){
            fill_cpu(l.outputs * l.batch, 0, l.delta, 1);
        }
        l.forward(l, net);
        net.input = l.output;
        if(l.truth) {
            net.truth = l.output;
        }
    }
    calc_network_cost(netp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb80, %rsp            # imm = 0xB80
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x118(%rbp), %rdi
movl $0x110, %edx            # imm = 0x110
callq 0x3280
movl $0x0, -0x11c(%rbp)
movl -0x11c(%rbp), %eax
cmpl -0x118(%rbp), %eax
jge 0x3a2c1
movl -0x11c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0xf8(%rbp), %rsi
movslq -0x11c(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x5c0(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpq $0x0, -0x360(%rbp)
je 0x3a24d
movl -0x568(%rbp), %edi
imull -0x578(%rbp), %edi
movq -0x360(%rbp), %rsi
xorps %xmm0, %xmm0
movl $0x1, %edx
callq 0x2f740
movq -0x5b0(%rbp), %rax
movq %rsp, %rdi
movq %rdi, -0x5c8(%rbp)
movl $0x94, %ecx
leaq -0x5c0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x5c8(%rbp), %rdi
addq $0x4a0, %rdi            # imm = 0x4A0
movl $0x22, %ecx
leaq -0x118(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
callq *%rax
movq -0x358(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x4f8(%rbp)
je 0x3a2ab
movq -0x358(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3a2ad
movl -0x11c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x11c(%rbp)
jmp 0x3a1de
movq -0x8(%rbp), %rdi
callq 0x3a2e0
addq $0xb80, %rsp            # imm = 0xB80
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: calc_network_cost
void calc_network_cost(network *netp)
{
    network net = *netp;
    int i;
    float sum = 0;
    int count = 0;
    for(i = 0; i < net.n; ++i){
        if(net.layers[i].cost){
            sum += net.layers[i].cost[0];
            ++count;
        }
    }
    *net.cost = sum/count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x118(%rbp), %rdi
movl $0x110, %edx            # imm = 0x110
callq 0x3280
xorps %xmm0, %xmm0
movss %xmm0, -0x120(%rbp)
movl $0x0, -0x124(%rbp)
movl $0x0, -0x11c(%rbp)
movl -0x11c(%rbp), %eax
cmpl -0x118(%rbp), %eax
jge 0x3a3ab
movq -0xf8(%rbp), %rax
movslq -0x11c(%rbp), %rcx
imulq $0x4a0, %rcx, %rcx      # imm = 0x4A0
addq %rcx, %rax
cmpq $0x0, 0x1d8(%rax)
je 0x3a395
movq -0xf8(%rbp), %rax
movslq -0x11c(%rbp), %rcx
imulq $0x4a0, %rcx, %rcx      # imm = 0x4A0
addq %rcx, %rax
movq 0x1d8(%rax), %rax
movss (%rax), %xmm0
addss -0x120(%rbp), %xmm0
movss %xmm0, -0x120(%rbp)
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x3a397
movl -0x11c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x11c(%rbp)
jmp 0x3a323
movss -0x120(%rbp), %xmm0
cvtsi2ssl -0x124(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: update_network
void update_network(network *netp)
{
    network net = *netp;
    int i;
    update_args a = {0};
    a.batch = net.batch*net.subdivisions;
    a.learning_rate = get_current_rate(netp);
    a.momentum = net.momentum;
    a.decay = net.decay;
    a.adam = net.adam;
    a.B1 = net.B1;
    a.B2 = net.B2;
    a.eps = net.eps;
    ++*net.t;
    a.t = *net.t;

    for(i = 0; i < net.n; ++i){
        layer l = net.layers[i];
        if(l.update){
            l.update(l, a);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xab0, %rsp            # imm = 0xAB0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x118(%rbp), %rdi
movl $0x110, %edx            # imm = 0x110
callq 0x3280
leaq -0x140(%rbp), %rdi
xorl %esi, %esi
movl $0x24, %edx
callq 0x3190
movl -0x114(%rbp), %eax
imull -0xfc(%rbp), %eax
movl %eax, -0x140(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39b60
movss %xmm0, -0x13c(%rbp)
movss -0xe0(%rbp), %xmm0
movss %xmm0, -0x138(%rbp)
movss -0xdc(%rbp), %xmm0
movss %xmm0, -0x134(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x130(%rbp)
movss -0xa4(%rbp), %xmm0
movss %xmm0, -0x12c(%rbp)
movss -0xa0(%rbp), %xmm0
movss %xmm0, -0x128(%rbp)
movss -0x9c(%rbp), %xmm0
movss %xmm0, -0x124(%rbp)
movq -0x108(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x108(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x120(%rbp)
movl $0x0, -0x11c(%rbp)
movl -0x11c(%rbp), %eax
cmpl -0x118(%rbp), %eax
jge 0x3a55a
movq -0xf8(%rbp), %rsi
movslq -0x11c(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x5e0(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpq $0x0, -0x5c0(%rbp)
je 0x3a544
movq -0x5c0(%rbp), %rax
movq %rsp, %rdi
movq %rdi, -0x5e8(%rbp)
movl $0x94, %ecx
leaq -0x5e0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x5e8(%rbp), %rcx
movl -0x120(%rbp), %edx
movl %edx, 0x4c0(%rcx)
movups -0x140(%rbp), %xmm0
movups -0x130(%rbp), %xmm1
movups %xmm1, 0x4b0(%rcx)
movups %xmm0, 0x4a0(%rcx)
callq *%rax
jmp 0x3a546
movl -0x11c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x11c(%rbp)
jmp 0x3a4ae
addq $0xab0, %rsp            # imm = 0xAB0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: backward_network
void backward_network(network *netp)
{
    network net = *netp;
    int i;
    network orig = net;
    for(i = net.n-1; i >= 0; --i){
        layer l = net.layers[i];
        if(l.stopbackward) break;
        if(i == 0){
            net = orig;
        }else{
            layer prev = net.layers[i-1];
            net.input = prev.output;
            net.delta = prev.delta;
        }
        net.index = i;
        l.backward(l, net);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1130, %rsp           # imm = 0x1130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x118(%rbp), %rdi
movl $0x110, %edx            # imm = 0x110
callq 0x3280
leaq -0x230(%rbp), %rdi
leaq -0x118(%rbp), %rsi
movl $0x110, %edx            # imm = 0x110
callq 0x3280
movl -0x118(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x11c(%rbp)
cmpl $0x0, -0x11c(%rbp)
jl 0x3a6f1
movq -0xf8(%rbp), %rsi
movslq -0x11c(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x6d0(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpl $0x0, -0x558(%rbp)
je 0x3a62f
jmp 0x3a6f1
cmpl $0x0, -0x11c(%rbp)
jne 0x3a652
leaq -0x118(%rbp), %rdi
leaq -0x230(%rbp), %rsi
movl $0x110, %edx            # imm = 0x110
callq 0x3280
jmp 0x3a695
movq -0xf8(%rbp), %rsi
movl -0x11c(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0xb70(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
movq -0x908(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x910(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x11c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x6b8(%rbp), %rax
movq %rsp, %rdi
movq %rdi, -0xb78(%rbp)
movl $0x94, %ecx
leaq -0x6d0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0xb78(%rbp), %rdi
addq $0x4a0, %rdi            # imm = 0x4A0
movl $0x22, %ecx
leaq -0x118(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
callq *%rax
movl -0x11c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x11c(%rbp)
jmp 0x3a5eb
addq $0x1130, %rsp           # imm = 0x1130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: train_network_datum
float train_network_datum(network *net)
{
    *net->seen += net->batch;
    net->train = 1;
    forward_network(net);
    backward_network(net);
    float error = *net->cost;
    if(((*net->seen)/net->batch)%net->subdivisions == 0) update_network(net);
    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xf8(%rax)
movq -0x8(%rbp), %rdi
callq 0x3a1b0
movq -0x8(%rbp), %rdi
callq 0x3a5a0
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movss (%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq -0x8(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x3a78a
movq -0x8(%rbp), %rdi
callq 0x3a3d0
movss -0xc(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: train_network_sgd
float train_network_sgd(network *net, data d, int n)
{
    int batch = net->batch;

    int i;
    float sum = 0;
    for(i = 0; i < n; ++i){
        get_random_batch(d, batch, net->input, net->truth);
        float err = train_network_datum(net);
        sum += err;
    }
    return (float)sum/(n*batch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3a843
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %edi
movq -0x8(%rbp), %rcx
movq 0xd8(%rcx), %rsi
movq -0x8(%rbp), %rcx
movq 0xe0(%rcx), %rdx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x382b0
movq -0x8(%rbp), %rdi
callq 0x3a700
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3a7d0
movss -0x18(%rbp), %xmm0
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: train_network
float train_network(network *net, data d)
{
    assert(d.X.rows % net->batch == 0);
    int batch = net->batch;
    int n = d.X.rows / batch;

    int i;
    float sum = 0;
    for(i = 0; i < n; ++i){
        get_next_batch(d, batch, i*batch, net->input, net->truth);
        float err = train_network_datum(net);
        sum += err;
    }
    return (float)sum/(n*batch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x4(%rcx)
cmpl $0x0, %edx
jne 0x3a886
jmp 0x3a8a5
leaq 0x39d85(%rip), %rdi     # 0x74612
leaq 0x39d99(%rip), %rsi     # 0x7462d
movl $0x121, %edx            # imm = 0x121
leaq 0x39d97(%rip), %rcx     # 0x74637
callq 0x3180
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, -0xc(%rbp)
movl 0x8(%rax), %eax
cltd
idivl -0xc(%rbp)
movl %eax, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3a946
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
imull -0xc(%rbp), %esi
movq -0x8(%rbp), %rcx
movq 0xd8(%rcx), %rdx
movq -0x8(%rbp), %rcx
movq 0xe0(%rcx), %rcx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x38370
movq -0x8(%rbp), %rdi
callq 0x3a700
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3a8cc
movss -0x18(%rbp), %xmm0
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: set_batch_network
void set_batch_network(network *net, int b)
{
    net->batch = b;
    int i;
    for(i = 0; i < net->n; ++i){
        net->layers[i].batch = b;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3a9fe
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rdx
imulq $0x4a0, %rdx, %rdx      # imm = 0x4A0
addq %rdx, %rax
movl %ecx, 0x48(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3a9cc
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: get_network_output_layer
layer get_network_output_layer(network *net)
{
    int i;
    for(i = net->n - 1; i >= 0; --i){
        if(net->layers[i].type != COST) break;
    }
    return net->layers[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x3ae50
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a0, %rcx, %rcx      # imm = 0x4A0
addq %rcx, %rax
cmpl $0x9, (%rax)
je 0x3ae43
jmp 0x3ae50
jmp 0x3ae45
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3ae20
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: get_network_detection_layer
layer get_network_detection_layer(network *net)
{
    int i;
    for(i = 0; i < net->n; ++i){
        if(net->layers[i].type == DETECTION){
            return net->layers[i];
        }
    }
    fprintf(stderr, "Detection layer not found!!\n");
    layer l = {0};
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3aef4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a0, %rcx, %rcx      # imm = 0x4A0
addq %rcx, %rax
cmpl $0x5, (%rax)
jne 0x3aee7
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
jmp 0x3af1c
jmp 0x3aee9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3ae9b
movq 0x480fd(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
leaq 0x397a0(%rip), %rsi     # 0x746a5
movb $0x0, %al
callq 0x3240
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: get_network_image_layer
image get_network_image_layer(network *net, int i)
{
    layer l = net->layers[i];
    if (l.out_w && l.out_h && l.out_c){
        return float_to_image(l.out_w, l.out_h, l.out_c, l.output);
    }
    image def = {0};
    return def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x4c0(%rbp)
movq %rdi, -0x4b8(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4b0(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpl $0x0, -0x434(%rbp)
je 0x3afb9
cmpl $0x0, -0x438(%rbp)
je 0x3afb9
cmpl $0x0, -0x430(%rbp)
je 0x3afb9
movq -0x4c0(%rbp), %rdi
movl -0x434(%rbp), %esi
movl -0x438(%rbp), %edx
movl -0x430(%rbp), %ecx
movq -0x248(%rbp), %r8
callq 0xfbb0
jmp 0x3afcc
movq -0x4c0(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3190
movq -0x4b8(%rbp), %rax
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: get_network_image
image get_network_image(network *net)
{
    int i;
    for(i = net->n-1; i >= 0; --i){
        image m = get_network_image_layer(net, i);
        if(m.h != 0) return m;
    }
    image def = {0};
    return def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x3b02f
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x3af30
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x3b022
jmp 0x3b03f
jmp 0x3b024
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3b000
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3190
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: visualize_network
void visualize_network(network *net)
{
    image *prev = 0;
    int i;
    char buff[256];
    for(i = 0; i < net->n; ++i){
        sprintf(buff, "Layer %d", i);
        layer l = net->layers[i];
        if(l.type == CONVOLUTIONAL){
            prev = visualize_convolutional_layer(l, buff, prev);
        }
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa70, %rsp            # imm = 0xA70
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3b117
leaq -0x120(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x380cf(%rip), %rsi     # 0x7315d
movb $0x0, %al
callq 0x33f0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x14(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x5c0(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpl $0x0, -0x5c0(%rbp)
jne 0x3b107
leaq -0x120(%rbp), %rax
movq %rax, -0x5c8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x5d0(%rbp)
movq %rsp, %rdi
movl $0x94, %ecx
leaq -0x5c0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x5d0(%rbp), %rsi
movq -0x5c8(%rbp), %rdi
callq 0x8d10
movq %rax, -0x10(%rbp)
jmp 0x3b109
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3b06e
addq $0xa70, %rsp            # imm = 0xA70
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: network_predict
float *network_predict(network *net, float *input)
{
    network orig = *net;
    net->input = input;
    net->truth = 0;
    net->train = 0;
    net->delta = 0;
    forward_network(net);
    float *out = net->output;
    *net = orig;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movl $0x110, %edx            # imm = 0x110
callq 0x3280
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xf8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xe8(%rax)
movq -0x8(%rbp), %rdi
callq 0x3a1b0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movl $0x110, %edx            # imm = 0x110
callq 0x3280
movq -0x128(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: num_detections
int num_detections(network *net, float thresh)
{
    int i;
    int s = 0;
    for(i = 0; i < net->n; ++i){
        layer l = net->layers[i];
        if(l.type == YOLO){
            s += yolo_num_detections(l, thresh);
        }
        if(l.type == DETECTION || l.type == REGION){
            s += l.w*l.h*l.n;
        }
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x960, %rsp            # imm = 0x960
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3b2bf
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x10(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4b8(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpl $0x17, -0x4b8(%rbp)
jne 0x3b283
movss -0xc(%rbp), %xmm0
movq %rsp, %rdi
movl $0x94, %ecx
leaq -0x4b8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x53200
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x5, -0x4b8(%rbp)
je 0x3b295
cmpl $0x16, -0x4b8(%rbp)
jne 0x3b2af
movl -0x448(%rbp), %eax
imull -0x44c(%rbp), %eax
imull -0x434(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3b2b1
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3b222
movl -0x14(%rbp), %eax
addq $0x960, %rsp            # imm = 0x960
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: make_network_boxes
detection *make_network_boxes(network *net, float thresh, int *num)
{
    layer l = net->layers[net->n - 1];
    int i;
    int nboxes = num_detections(net, thresh);
    if(num) *num = nboxes;
    detection *dets = calloc(nboxes, sizeof(detection));
    for(i = 0; i < nboxes; ++i){
        dets[i].prob = calloc(l.classes, sizeof(float));
        if(l.coords > 4){
            dets[i].mask = calloc(l.coords-4, sizeof(float));
        }
    }
    return dets;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
cltq
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4b8(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
movq -0x8(%rbp), %rdi
movss -0xc(%rbp), %xmm0
callq 0x3b200
movl %eax, -0x4c0(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3b33d
movl -0x4c0(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movslq -0x4c0(%rbp), %rdi
movl $0x30, %esi
callq 0x3220
movq %rax, -0x4c8(%rbp)
movl $0x0, -0x4bc(%rbp)
movl -0x4bc(%rbp), %eax
cmpl -0x4c0(%rbp), %eax
jge 0x3b3eb
movslq -0x3bc(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x4c8(%rbp), %rax
movslq -0x4bc(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
cmpl $0x4, -0x3b8(%rbp)
jle 0x3b3d5
movl -0x3b8(%rbp), %eax
subl $0x4, %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x4c8(%rbp), %rax
movslq -0x4bc(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
jmp 0x3b3d7
movl -0x4bc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4bc(%rbp)
jmp 0x3b35f
movq -0x4c8(%rbp), %rax
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: free_detections
void free_detections(detection *dets, int n)
{
    int i;
    for(i = 0; i < n; ++i){
        free(dets[i].prob);
        if(dets[i].mask) free(dets[i].mask);
    }
    free(dets);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3b721
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x20(%rax)
je 0x3b714
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x3030
jmp 0x3b716
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3b6c6
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: network_predict_image
float *network_predict_image(network *net, image im)
{
    image imr = letterbox_image(im, net->w, net->h);
    set_batch_network(net, 1);
    float *p = network_predict(net, imr.data);
    free_image(imr);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl 0x94(%rcx), %esi
movq -0x8(%rbp), %rcx
movl 0x90(%rcx), %edx
leaq -0x20(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x12c60
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3a9b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b160
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xedb0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: network_predict_data
matrix network_predict_data(network *net, data test)
{
    int i,j,b;
    int k = net->outputs;
    matrix pred = make_matrix(test.X.rows, k);
    float *X = calloc(net->batch*test.X.cols, sizeof(float));
    for(i = 0; i < test.X.rows; i += net->batch){
        for(b = 0; b < net->batch; ++b){
            if(i+b == test.X.rows) break;
            memcpy(X+b*test.X.cols, test.X.vals[i+b], test.X.cols*sizeof(float));
        }
        float *out = network_predict(net, X);
        for(b = 0; b < net->batch; ++b){
            if(i+b == test.X.rows) break;
            for(j = 0; j < k; ++j){
                pred.vals[i+b][j] = out[j+b*k];
            }
        }
    }
    free(X);
    return pred;   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl 0x84(%rcx), %ecx
movl %ecx, -0x28(%rbp)
movl 0x8(%rax), %edi
movl -0x28(%rbp), %esi
callq 0x39450
movq -0x40(%rbp), %rcx
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
imull 0xc(%rcx), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x40(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3bb53
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3bab1
movq -0x40(%rbp), %rcx
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0x3ba6f
jmp 0x3bab1
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %ecx
imull 0xc(%rax), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rcx
movl -0x1c(%rbp), %edx
addl -0x24(%rbp), %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rsi
movslq 0xc(%rax), %rdx
shlq $0x2, %rdx
callq 0x3280
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3ba52
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3b160
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3bb3f
movq -0x40(%rbp), %rcx
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0x3bae6
jmp 0x3bb3f
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x3bb32
movq -0x38(%rbp), %rax
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %edx
imull -0x28(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3baed
jmp 0x3bb34
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3bac9
jmp 0x3bb41
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ba3b
movq -0x30(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: print_network
void print_network(network *net)
{
    int i,j;
    for(i = 0; i < net->n; ++i){
        layer l = net->layers[i];
        float *output = l.output;
        int n = l.outputs;
        float mean = mean_array(output, n);
        float vari = variance_array(output, n);
        fprintf(stderr, "Layer %d - Mean: %f, Variance: %f\n",i,mean, vari);
        if(n > 100) n = 100;
        for(j = 0; j < n; ++j) fprintf(stderr, "%f, ", output[j]);
        if(n == 100)fprintf(stderr,".....\n");
        fprintf(stderr, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3bce0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4b0(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
movq -0x248(%rbp), %rax
movq %rax, -0x4b8(%rbp)
movl -0x458(%rbp), %eax
movl %eax, -0x4bc(%rbp)
movq -0x4b8(%rbp), %rdi
movl -0x4bc(%rbp), %esi
callq 0x54d0
movss %xmm0, -0x4c0(%rbp)
movq -0x4b8(%rbp), %rdi
movl -0x4bc(%rbp), %esi
callq 0x5640
movss %xmm0, -0x4c4(%rbp)
movq 0x473e7(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movss -0x4c0(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x4c4(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x38a8c(%rip), %rsi     # 0x746c2
movb $0x2, %al
callq 0x3240
cmpl $0x64, -0x4bc(%rbp)
jle 0x3bc50
movl $0x64, -0x4bc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x4bc(%rbp), %eax
jge 0x3bc99
movq 0x4738f(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x4b8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x38a5e(%rip), %rsi     # 0x746e5
movb $0x1, %al
callq 0x3240
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3bc57
cmpl $0x64, -0x4bc(%rbp)
jne 0x3bcba
movq 0x4734f(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
leaq 0x38a37(%rip), %rsi     # 0x746ea
movb $0x0, %al
callq 0x3240
movq 0x47337(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
leaq 0x3a0e3(%rip), %rsi     # 0x75dae
movb $0x0, %al
callq 0x3240
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3bb86
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: network_accuracy
float network_accuracy(network *net, data d)
{
    matrix guess = network_predict_data(net, d);
    float acc = matrix_topk_accuracy(d.y, guess,1);
    free_matrix(guess);
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3b9e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %r8d
callq 0x39080
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x39030
movss -0x1c(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: network_accuracies
float *network_accuracies(network *net, data d, int n)
{
    static float acc[2];
    matrix guess = network_predict_data(net, d);
    acc[0] = matrix_topk_accuracy(d.y, guess, 1);
    acc[1] = matrix_topk_accuracy(d.y, guess, n);
    free_matrix(guess);
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3b9e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %r8d
callq 0x39080
movq -0x28(%rbp), %rax
movss %xmm0, 0x47eb9(%rip)    # 0x83e90
movl -0xc(%rbp), %r8d
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x39080
movss %xmm0, 0x47e9c(%rip)    # 0x83e94
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x39030
leaq 0x47e84(%rip), %rax     # 0x83e90
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: network_accuracy_multi
float network_accuracy_multi(network *net, data d, int n)
{
    matrix guess = network_predict_data_multi(net, d, n);
    float acc = matrix_topk_accuracy(d.y, guess,1);
    free_matrix(guess);
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3b810
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %r8d
callq 0x39080
movss %xmm0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x39030
movss -0x24(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: free_network
void free_network(network *net)
{
    int i;
    for(i = 0; i < net->n; ++i){
        free_layer(net->layers[i]);
    }
    free(net->layers);
    if(net->input) free(net->input);
    if(net->truth) free(net->truth);
    free(net);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp            # imm = 0x4B0
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3c102
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x46f00
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3c0c6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x3c12d
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x3c14b
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x4b0, %rsp            # imm = 0x4B0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: network_output_layer
layer network_output_layer(network *net)
{
    int i;
    for(i = net->n - 1; i >= 0; --i){
        if(net->layers[i].type != COST) break;
    }
    return net->layers[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x3c1b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a0, %rcx, %rcx      # imm = 0x4A0
addq %rcx, %rax
cmpl $0x9, (%rax)
je 0x3c1a3
jmp 0x3c1b0
jmp 0x3c1a5
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3c180
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/connected_layer.c
// Function: forward_connected_layer
void forward_connected_layer(layer l, network net)
{
    fill_cpu(l.outputs*l.batch, 0, l.output, 1);
    int m = l.batch;
    int k = l.inputs;
    int n = l.outputs;
    float *a = net.input;
    float *b = l.weights;
    float *c = l.output;
    gemm(0,1,m,n,k,1,a,k,b,k,1,c,n);
    if(l.batch_normalize){
        forward_batchnorm_layer(l, net);
    } else {
        add_bias(l.output, l.biases, l.batch, l.outputs, 1);
    }
    activate_array(l.output, l.outputs*l.batch, l.activation);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x5f0, %rsp            # imm = 0x5F0
leaq 0x4b0(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x58(%rax), %edi
imull 0x48(%rax), %edi
movq 0x268(%rax), %rsi
xorps %xmm0, %xmm0
movl $0x1, %edx
callq 0x2f740
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movl 0x48(%rax), %edx
movl %edx, -0x14(%rbp)
movl 0x54(%rax), %edx
movl %edx, -0x18(%rbp)
movl 0x58(%rax), %edx
movl %edx, -0x1c(%rbp)
movq 0xd8(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq 0x250(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x268(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x18(%rbp), %r8d
movq -0x28(%rbp), %r9
movl -0x18(%rbp), %r14d
movq -0x30(%rbp), %rbx
movl -0x18(%rbp), %r11d
movq -0x38(%rbp), %r10
movl -0x1c(%rbp), %eax
xorl %edi, %edi
movl $0x1, %esi
movss 0x34895(%rip), %xmm1    # 0x7100c
movaps %xmm1, %xmm0
movl %r14d, (%rsp)
movq %rbx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x3aa0
movq -0x40(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x3c7d1
movq -0x40(%rbp), %rsi
movq %rsp, %rdi
movq %rdi, -0x50(%rbp)
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x4a0, %rdi            # imm = 0x4A0
movl $0x22, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x4b2d0
jmp 0x3c7f4
movq -0x40(%rbp), %rax
movq 0x268(%rax), %rdi
movq 0x230(%rax), %rsi
movl 0x48(%rax), %edx
movl 0x58(%rax), %ecx
movl $0x1, %r8d
callq 0x8840
movq -0x40(%rbp), %rax
movq 0x268(%rax), %rdi
movl 0x58(%rax), %esi
imull 0x48(%rax), %esi
movl 0x4(%rax), %edx
callq 0x2dfa0
addq $0x5f0, %rsp            # imm = 0x5F0
popq %rbx
popq %r14
popq %rbp
retq
nopw (%rax,%rax)