LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x23cfa
movq 0x20(%rbx), %rax
imulq $0x4a0, %r12, %rcx      # imm = 0x4A0
movl 0x58(%rax,%rcx), %r13d
movq 0x268(%rax,%rcx), %r14
movq %r14, %rdi
movl %r13d, %esi
callq 0x48c4
movss %xmm0, 0x4(%rsp)
movq %r14, %rdi
movl %r13d, %esi
callq 0x49b0
movq 0x403a1(%rip), %rax     # 0x63ff8
movq (%rax), %rdi
cvtss2sd 0x4(%rsp), %xmm2
cvtss2sd %xmm0, %xmm1
leaq 0x2c123(%rip), %rsi     # 0x4fd8e
movl %r12d, %edx
movaps %xmm2, %xmm0
movb $0x2, %al
callq 0x3270
cmpl $0x64, %r13d
pushq $0x64
popq %rax
movl %eax, %r15d
cmovll %r13d, %r15d
testl %r15d, %r15d
movl $0x0, %eax
cmovlel %eax, %r15d
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x23cbc
movq 0x40358(%rip), %rax     # 0x63ff8
movq (%rax), %rdi
cvtss2sd (%r14,%rbp,4), %xmm0
leaq 0x2c101(%rip), %rsi     # 0x4fdb1
movb $0x1, %al
callq 0x3270
incq %rbp
jmp 0x23c94
cmpl $0x64, %r13d
jge 0x23cdc
movq 0x4032f(%rip), %rax     # 0x63ff8
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x31f0
incq %r12
jmp 0x23c10
movq 0x40315(%rip), %rax     # 0x63ff8
movq (%rax), %rcx
leaq 0x2c0c9(%rip), %rdi     # 0x4fdb6
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
callq 0x3440
jmp 0x23cc2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/network.c
// Function: compare_networks
void compare_networks(network *n1, network *n2, data test)
{
    matrix g1 = network_predict_data(n1, test);
    matrix g2 = network_predict_data(n2, test);
    int i;
    int a,b,c,d;
    a = b = c = d = 0;
    for(i = 0; i < g1.rows; ++i){
        int truth = max_index(test.y.vals[i], test.y.cols);
        int p1 = max_index(g1.vals[i], g1.cols);
        int p2 = max_index(g2.vals[i], g2.cols);
        if(p1 == truth){
            if(p2 == truth) ++d;
            else ++c;
        }else{
            if(p2 == truth) ++b;
            else ++a;
        }
    }
    printf("%5d %5d\n%5d %5d\n", a, b, c, d);
    float num = pow((abs(b - c) - 1.), 2.);
    float den = b + c;
    printf("%f\n", num/den); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movaps 0xb0(%rsp), %xmm0
movaps 0xc0(%rsp), %xmm1
movaps 0xd0(%rsp), %xmm2
movaps 0xe0(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x23a7d
movq %rax, %r14
movq %rdx, 0x70(%rsp)
movaps 0xb0(%rsp), %xmm0
movaps 0xc0(%rsp), %xmm1
movaps 0xd0(%rsp), %xmm2
movaps 0xe0(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x23a7d
movq %rax, %r15
movq %rdx, 0x68(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0xcc(%rsp), %eax
movl %eax, 0x5c(%rsp)
movq %r14, %rbp
shrq $0x20, %rbp
shrq $0x20, %r15
xorl %r12d, %r12d
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
movl $0x0, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl $0x0, 0x4c(%rsp)
cmpq %r12, %r13
je 0x23e57
movq 0x60(%rsp), %rax
movq (%rax,%r12,8), %rdi
movl 0x5c(%rsp), %esi
callq 0x4c73
movl %eax, %r14d
movq 0x70(%rsp), %rax
movq (%rax,%r12,8), %rdi
movl %ebp, %esi
callq 0x4c73
movl %eax, %ebx
movq 0x68(%rsp), %rax
movq (%rax,%r12,8), %rdi
movl %r15d, %esi
callq 0x4c73
cmpl %r14d, %ebx
jne 0x23e3d
cmpl %r14d, %eax
jne 0x23e48
incl 0x50(%rsp)
jmp 0x23e52
cmpl %r14d, %eax
jne 0x23e4e
incl 0x54(%rsp)
jmp 0x23e52
incl 0x58(%rsp)
jmp 0x23e52
incl 0x4c(%rsp)
incq %r12
jmp 0x23df0
leaq 0x2bf5f(%rip), %rdi     # 0x4fdbd
movl 0x4c(%rsp), %esi
movl 0x54(%rsp), %ebp
movl %ebp, %edx
movl 0x58(%rsp), %ebx
movl %ebx, %ecx
movl 0x50(%rsp), %r8d
xorl %eax, %eax
callq 0x3160
movl %ebp, %eax
subl %ebx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
decl %ecx
cvtsi2sd %ecx, %xmm0
mulsd %xmm0, %xmm0
addl %ebx, %ebp
cvtsi2ss %ebp, %xmm1
cvtsd2ss %xmm0, %xmm0
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2da20(%rip), %rdi     # 0x518c8
movb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3160
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movaps 0x60(%rsp), %xmm0
movaps 0x70(%rsp), %xmm1
movaps 0x80(%rsp), %xmm2
movaps 0x90(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x23a7d
movq %rax, %rbx
movq %rdx, %r14
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
pushq $0x1
popq %r8
movq %rax, %rdx
movq %r14, %rcx
callq 0x21f11
movss %xmm0, 0x44(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21edc
movss 0x44(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movaps 0x90(%rsp), %xmm2
movaps 0xa0(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x23a7d
movq %rax, %r14
movq %rdx, %r15
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
pushq $0x1
popq %r8
movq %rax, %rdx
movq %r15, %rcx
callq 0x21f11
movss %xmm0, 0x4086a(%rip)    # 0x64810
leaq 0x40863(%rip), %r12     # 0x64810
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
movl %ebx, %r8d
callq 0x21f11
movss %xmm0, 0x40841(%rip)    # 0x64814
movq %r14, %rdi
movq %r15, %rsi
callq 0x21edc
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movaps 0x60(%rsp), %xmm0
movaps 0x70(%rsp), %xmm1
movaps 0x80(%rsp), %xmm2
movaps 0x90(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x238be
movq %rax, %rbx
movq %rdx, %r14
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
pushq $0x1
popq %r8
movq %rax, %rdx
movq %r14, %rcx
callq 0x21f11
movss %xmm0, 0x44(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21edc
movss 0x44(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x4a0, %rsp            # imm = 0x4A0
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq (%rbx), %rax
movq 0x20(%rbx), %rsi
cmpq %rax, %r15
jge 0x240a7
addq %r14, %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x2c5c0
incq %r15
addq $0x4a0, %r14            # imm = 0x4A0
jmp 0x2407c
movq %rsi, %rdi
callq 0x3040
movq 0xd8(%rbx), %rdi
callq 0x3040
movq 0xe0(%rbx), %rdi
callq 0x3040
movq %rbx, %rdi
addq $0x4a0, %rsp            # imm = 0x4A0
popq %rbx
popq %r14
popq %r15
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
decl %ecx
movq 0x20(%rsi), %rsi
movq %rax, %rdx
decq %rdx
testl %eax, %eax
jle 0x2410e
movl %edx, %edi
imulq $0x4a0, %rdi, %rdi      # imm = 0x4A0
decl %eax
decq %rdx
cmpl $0x9, (%rsi,%rdi)
je 0x240f4
jmp 0x24110
movl %ecx, %eax
cltq
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
movl $0x4a0, %edx            # imm = 0x4A0
movq %rbx, %rdi
callq 0x32b0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x40(%rsp), %rbx
movl 0x48(%rbx), %r15d
movl 0x58(%rbx), %r12d
movl %r15d, %ebp
imull %r12d, %ebp
movq 0x268(%rbx), %r14
pushq $0x1
popq %r13
xorps %xmm0, %xmm0
movl %ebp, %edi
movq %r14, %rsi
movl %r13d, %edx
callq 0x1b449
movl 0x54(%rbx), %r8d
movq 0x5b8(%rsp), %r9
subq $0x8, %rsp
movss 0x27aea(%rip), %xmm0    # 0x4c008
xorl %edi, %edi
movl %r13d, %esi
movl %r15d, %edx
movl %r12d, %ecx
movaps %xmm0, %xmm1
pushq %r12
pushq %r14
pushq %r8
pushq 0x250(%rbx)
pushq %r8
callq 0x3954
addq $0x30, %rsp
cmpl $0x0, 0x40(%rbx)
je 0x24593
leaq 0x4e0(%rsp), %rax
subq $0x5b0, %rsp            # imm = 0x5B0
movl $0x94, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x4a0(%rsp), %rdi
pushq $0x22
popq %rcx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x2fc4e
addq $0x5b0, %rsp            # imm = 0x5B0
movq 0x268(%rbx), %r14
movl 0x48(%rbx), %ebp
imull 0x58(%rbx), %ebp
jmp 0x245ac
movq 0x230(%rbx), %rsi
pushq $0x1
popq %r8
movq %r14, %rdi
movl %r15d, %edx
movl %r12d, %ecx
callq 0x6cd3
movl 0x4(%rbx), %edx
movq %r14, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a4f8
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/connected_layer.c
// Function: backward_connected_layer
void backward_connected_layer(layer l, network net)
{
    gradient_array(l.output, l.outputs*l.batch, l.activation, l.delta);

    if(l.batch_normalize){
        backward_batchnorm_layer(l, net);
    } else {
        backward_bias(l.bias_updates, l.delta, l.batch, l.outputs, 1);
    }

    int m = l.outputs;
    int k = l.batch;
    int n = l.inputs;
    float *a = l.delta;
    float *b = net.input;
    float *c = l.weight_updates;
    gemm(1,0,m,n,k,1,a,m,b,n,1,c,n);

    m = l.batch;
    k = l.outputs;
    n = l.inputs;

    a = l.delta;
    b = l.weights;
    c = net.delta;

    if(c) gemm(0,0,m,n,k,1,a,k,b,n,1,c,n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x4d0(%rsp), %r14
leaq 0x30(%rsp), %rbx
movq 0x268(%rbx), %rdi
movl 0x58(%rbx), %r15d
movl 0x4(%rbx), %edx
movl 0x48(%rbx), %ebp
movl %ebp, %esi
imull %r15d, %esi
movq 0x260(%rbx), %r12
movq %r12, %rcx
callq 0x1a748
cmpl $0x0, 0x40(%rbx)
je 0x2464a
subq $0x5b0, %rsp            # imm = 0x5B0
movl $0x94, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x4a0(%rsp), %rdi
pushq $0x22
popq %rcx
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x2fe3b
addq $0x5b0, %rsp            # imm = 0x5B0
movl 0x48(%rbx), %ebp
movl 0x58(%rbx), %r15d
movq 0x260(%rbx), %r12
jmp 0x24662
movq 0x238(%rbx), %rdi
pushq $0x1
popq %r8
movq %r12, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x6dbf
movl 0x54(%rbx), %ecx
subq $0x8, %rsp
pushq $0x1
popq %rdi
movss 0x27994(%rip), %xmm0    # 0x4c008
xorl %esi, %esi
movl %r15d, %edx
movl %ebp, %r8d
movq %r12, %r9
movaps %xmm0, %xmm1
pushq %rcx
pushq 0x258(%rbx)
pushq %rcx
pushq 0xd8(%r14)
pushq %r15
callq 0x3954
addq $0x30, %rsp
movq 0xe8(%r14), %rax
testq %rax, %rax
je 0x246e0
movq 0x260(%rbx), %r9
movl 0x48(%rbx), %edx
movl 0x54(%rbx), %ecx
movl 0x58(%rbx), %r8d
subq $0x8, %rsp
movss 0x27943(%rip), %xmm0    # 0x4c008
xorl %edi, %edi
xorl %esi, %esi
movaps %xmm0, %xmm1
pushq %rcx
pushq %rax
pushq %rcx
pushq 0x250(%rbx)
pushq %r8
callq 0x3954
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/connected_layer.c
// Function: update_connected_layer
void update_connected_layer(layer l, update_args a)
{
    float learning_rate = a.learning_rate*l.learning_rate_scale;
    float momentum = a.momentum;
    float decay = a.decay;
    int batch = a.batch;
    axpy_cpu(l.outputs, learning_rate/batch, l.bias_updates, 1, l.biases, 1);
    scal_cpu(l.outputs, momentum, l.bias_updates, 1);

    if(l.batch_normalize){
        axpy_cpu(l.outputs, learning_rate/batch, l.scale_updates, 1, l.scales, 1);
        scal_cpu(l.outputs, momentum, l.scale_updates, 1);
    }

    axpy_cpu(l.inputs*l.outputs, -decay*batch, l.weights, 1, l.weight_updates, 1);
    axpy_cpu(l.inputs*l.outputs, learning_rate/batch, l.weight_updates, 1, l.weights, 1);
    scal_cpu(l.inputs*l.outputs, momentum, l.weight_updates, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x50(%rsp), %r15
movss 0x4f4(%rsp), %xmm0
movss 0x4f8(%rsp), %xmm1
movss %xmm1, 0x4(%rsp)
mulss 0xec(%r15), %xmm0
movss 0x4fc(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
cvtsi2ssl 0x4f0(%rsp), %xmm1
movl 0x58(%r15), %ebx
movss %xmm1, 0xc(%rsp)
divss %xmm1, %xmm0
movq 0x238(%r15), %r14
movq 0x230(%r15), %rcx
pushq $0x1
popq %rbp
movl %ebx, %edi
movss %xmm0, 0x8(%rsp)
movq %r14, %rsi
movl %ebp, %edx
movl %ebp, %r8d
callq 0x1b3ed
movl %ebx, %edi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
movl %ebp, %edx
callq 0x1b423
cmpl $0x0, 0x40(%r15)
je 0x247b5
movq 0x240(%r15), %rcx
movq 0x248(%r15), %r14
pushq $0x1
popq %rbp
movl %ebx, %edi
movss 0x8(%rsp), %xmm0
movq %r14, %rsi
movl %ebp, %edx
movl %ebp, %r8d
callq 0x1b3ed
movl %ebx, %edi
movss 0x4(%rsp), %xmm0
movq %r14, %rsi
movl %ebp, %edx
callq 0x1b423
imull 0x54(%r15), %ebx
movaps 0x10(%rsp), %xmm0
xorps 0x2798a(%rip), %xmm0    # 0x4c150
mulss 0xc(%rsp), %xmm0
movq 0x250(%r15), %r14
movq 0x258(%r15), %r15
pushq $0x1
popq %rbp
movl %ebx, %edi
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x1b3ed
movl %ebx, %edi
movss 0x8(%rsp), %xmm0
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x1b3ed
movl %ebx, %edi
movss 0x4(%rsp), %xmm0
movq %r15, %rsi
movl %ebp, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1b423
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/connected_layer.c
// Function: denormalize_connected_layer
void denormalize_connected_layer(layer l)
{
    int i, j;
    for(i = 0; i < l.outputs; ++i){
        float scale = l.scales[i]/sqrt(l.rolling_variance[i] + .000001);
        for(j = 0; j < l.inputs; ++j){
            l.weights[i*l.inputs + j] *= scale;
        }
        l.biases[i] -= l.rolling_mean[i] * scale;
        l.scales[i] = 1;
        l.rolling_mean[i] = 0;
        l.rolling_variance[i] = 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0xb8(%rsp), %ecx
movq 0x2a0(%rsp), %rbp
movq 0x318(%rsp), %rsi
movslq 0xb4(%rsp), %r14
movq 0x2b0(%rsp), %r13
movq 0x310(%rsp), %r8
xorl %ebx, %ebx
testl %r14d, %r14d
movl $0x0, %r12d
cmovgl %r14d, %r12d
movq 0x290(%rsp), %r15
testl %ecx, %ecx
cmovlel %ebx, %ecx
shlq $0x2, %r14
movsd 0x277c8(%rip), %xmm2    # 0x4c050
xorpd %xmm3, %xmm3
movl $0x3f800000, %r10d      # imm = 0x3F800000
movq %rsi, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq %rcx, %rbx
je 0x2494c
cvtss2sd (%rbp,%rbx,4), %xmm1
cvtss2sd (%rsi,%rbx,4), %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm3, %xmm0
jb 0x248c5
sqrtsd %xmm0, %xmm0
jmp 0x248f7
movsd %xmm1, 0x20(%rsp)
callq 0x3460
movsd 0x20(%rsp), %xmm1
movl $0x3f800000, %r10d      # imm = 0x3F800000
xorpd %xmm3, %xmm3
movsd 0x27768(%rip), %xmm2    # 0x4c050
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rcx
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
xorl %eax, %eax
cmpq %rax, %r12
je 0x2491d
movss (%r13,%rax,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%r13,%rax,4)
incq %rax
jmp 0x24901
movss (%r15,%rbx,4), %xmm1
mulss (%r8,%rbx,4), %xmm0
subss %xmm0, %xmm1
movss %xmm1, (%r15,%rbx,4)
movl %r10d, (%rbp,%rbx,4)
andl $0x0, (%r8,%rbx,4)
movl %r10d, (%rsi,%rbx,4)
incq %rbx
addq %r14, %r13
jmp 0x248a1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/connected_layer.c
// Function: statistics_connected_layer
void statistics_connected_layer(layer l)
{
    if(l.batch_normalize){
        printf("Scales ");
        print_statistics(l.scales, l.outputs);
        /*
           printf("Rolling Mean ");
           print_statistics(l.rolling_mean, l.outputs);
           printf("Rolling Variance ");
           print_statistics(l.rolling_variance, l.outputs);
         */
    }
    printf("Biases ");
    print_statistics(l.biases, l.outputs);
    printf("Weights ");
    print_statistics(l.weights, l.outputs);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x20(%rsp), %r14
cmpl $0x0, 0x40(%r14)
je 0x2498d
leaq 0x2b48f(%rip), %rdi     # 0x4fe01
xorl %eax, %eax
callq 0x3160
movq 0x240(%r14), %rdi
movl 0x58(%r14), %ebx
movl %ebx, %esi
callq 0x495f
jmp 0x24991
movl 0x58(%r14), %ebx
leaq 0x2b471(%rip), %rdi     # 0x4fe09
xorl %eax, %eax
callq 0x3160
movq 0x230(%r14), %rdi
movl %ebx, %esi
callq 0x495f
leaq 0x2b45d(%rip), %rdi     # 0x4fe11
xorl %eax, %eax
callq 0x3160
movq 0x250(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x495f
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/cost_layer.c
// Function: get_cost_type
COST_TYPE get_cost_type(char *s)
{
    if (strcmp(s, "seg")==0) return SEG;
    if (strcmp(s, "sse")==0) return SSE;
    if (strcmp(s, "masked")==0) return MASKED;
    if (strcmp(s, "smooth")==0) return SMOOTH;
    if (strcmp(s, "L1")==0) return L1;
    if (strcmp(s, "wgan")==0) return WGAN;
    fprintf(stderr, "Couldn't find cost type %s, going with SSE\n", s);
    return SSE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2b443(%rip), %rsi     # 0x4fe20
callq 0x3260
testl %eax, %eax
je 0x24a47
leaq 0x2b437(%rip), %rsi     # 0x4fe24
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x24a4b
leaq 0x2b428(%rip), %rsi     # 0x4fe28
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x24a4f
leaq 0x2d9f9(%rip), %rsi     # 0x5240c
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x24a53
cmpb $0x4c, (%rbx)
jne 0x24a30
cmpb $0x31, 0x1(%rbx)
jne 0x24a30
cmpb $0x0, 0x2(%rbx)
je 0x24a5f
leaq 0x2b3fb(%rip), %rsi     # 0x4fe32
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
jne 0x24a63
pushq $0x5
jmp 0x24a55
pushq $0x3
jmp 0x24a55
xorl %ebp, %ebp
jmp 0x24a56
pushq $0x1
jmp 0x24a55
pushq $0x4
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x2
jmp 0x24a55
movq 0x3f58e(%rip), %rax     # 0x63ff8
movq (%rax), %rdi
leaq 0x2b3c3(%rip), %rsi     # 0x4fe37
xorl %ebp, %ebp
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3270
jmp 0x24a56
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/cost_layer.c
// Function: make_cost_layer
cost_layer make_cost_layer(int batch, int inputs, COST_TYPE cost_type, float scale)
{
    fprintf(stderr, "cost                                           %4d\n",  inputs);
    cost_layer l = {0};
    l.type = COST;

    l.scale = scale;
    l.batch = batch;
    l.inputs = inputs;
    l.outputs = inputs;
    l.cost_type = cost_type;
    l.delta = calloc(inputs*batch, sizeof(float));
    l.output = calloc(inputs*batch, sizeof(float));
    l.cost = calloc(1, sizeof(float));

    l.forward = forward_cost_layer;
    l.backward = backward_cost_layer;
    return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movl %ecx, %r14d
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movq 0x3f539(%rip), %rax     # 0x63ff8
movq (%rax), %rdi
leaq 0x2b39a(%rip), %rsi     # 0x4fe63
xorl %eax, %eax
callq 0x3270
movl $0x4a0, %edx            # imm = 0x4A0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x31c0
movl $0x9, (%rbx)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x194(%rbx)
movl %r15d, 0x48(%rbx)
movl %ebp, 0x54(%rbx)
movl %ebp, 0x58(%rbx)
movl %r14d, 0x8(%rbx)
imull %r15d, %ebp
movslq %ebp, %r14
pushq $0x4
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, 0x260(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, 0x268(%rbx)
pushq $0x1
popq %rdi
movq %r15, %rsi
callq 0x3250
movq %rax, 0x1d8(%rbx)
leaq 0x1d(%rip), %rax        # 0x24b66
movq %rax, 0x10(%rbx)
leaq 0x127(%rip), %rax       # 0x24c7b
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/cost_layer.c
// Function: forward_cost_layer
void forward_cost_layer(cost_layer l, network net)
{
    if (!net.truth) return;
    if(l.cost_type == MASKED){
        int i;
        for(i = 0; i < l.batch*l.inputs; ++i){
            if(net.truth[i] == SECRET_NUM) net.input[i] = SECRET_NUM;
        }
    }
    if(l.cost_type == SMOOTH){
        smooth_l1_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    }else if(l.cost_type == L1){
        l1_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    } else {
        l2_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    }
    l.cost[0] = sum_array(l.output, l.batch*l.inputs);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x5a0(%rsp), %rdx
testq %rdx, %rdx
je 0x24c75
leaq 0x4c0(%rsp), %rax
leaq 0x20(%rsp), %r15
movl 0x8(%r15), %ecx
cmpl $0x1, %ecx
je 0x24bf7
cmpl $0x2, %ecx
je 0x24bcd
cmpl $0x4, %ecx
jne 0x24c38
movl 0x54(%r15), %ebx
imull 0x48(%r15), %ebx
movq 0xd8(%rax), %rsi
movq 0x260(%r15), %rcx
movq 0x268(%r15), %r14
movl %ebx, %edi
movq %r14, %r8
callq 0x1b5f7
jmp 0x24c60
movl 0x54(%r15), %ebx
imull 0x48(%r15), %ebx
movq 0xd8(%rax), %rsi
movq 0x260(%r15), %rcx
movq 0x268(%r15), %r14
movl %ebx, %edi
movq %r14, %r8
callq 0x1b66b
jmp 0x24c60
movl 0x54(%r15), %ebx
imull 0x48(%r15), %ebx
movq 0xd8(%rax), %rsi
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
movss 0x2b201(%rip), %xmm0    # 0x4fe1c
cmpq %rax, %rcx
je 0x24c48
movss (%rdx,%rax,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x24c33
jp 0x24c33
movl $0xc49a4000, (%rsi,%rax,4) # imm = 0xC49A4000
incq %rax
jmp 0x24c1b
movl 0x54(%r15), %ebx
movq 0xd8(%rax), %rsi
imull 0x48(%r15), %ebx
movq 0x260(%r15), %rcx
movq 0x268(%r15), %r14
movl %ebx, %edi
movq %r14, %r8
callq 0x1b819
movq %r14, %rdi
movl %ebx, %esi
callq 0x48aa
movq 0x1d8(%r15), %rax
movss %xmm0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: free_section
void free_section(section *s)
{
    free(s->type);
    node *n = s->options->front;
    while(n){
        kvp *pair = (kvp *)n->val;
        free(pair->key);
        free(pair);
        node *next = n->next;
        free(n);
        n = next;
    }
    free(s->options);
    free(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3040
movq 0x8(%rbx), %rax
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x250ea
movq (%r14), %r15
movq (%r15), %rdi
callq 0x3040
movq %r15, %rdi
callq 0x3040
movq 0x8(%r14), %r15
movq %r14, %rdi
callq 0x3040
movq %r15, %r14
jmp 0x250c1
movq 0x8(%rbx), %rdi
callq 0x3040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_data
void parse_data(char *data, float *a, int n)
{
    int i;
    if(!data) return;
    char *curr = data;
    char *next = data;
    int done = 0;
    for(i = 0; i < n && !done; ++i){
        while(*++next !='\0' && *next != ',');
        if(*next == '\0') done = 1;
        *next = '\0';
        sscanf(curr, "%g", &a[i]);
        curr = next+1;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2517a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edx, %r15
xorl %r12d, %r12d
movq %rdi, %rbp
xorl %r14d, %r14d
cmpq %r15, %r12
jge 0x2516c
testl %r14d, %r14d
jne 0x2516c
incq %rbp
movq %rbp, %r13
movzbl (%r13), %eax
incq %r13
cmpl $0x2c, %eax
je 0x25140
testl %eax, %eax
jne 0x2512f
xorl %r14d, %r14d
testb %al, %al
sete %r14b
leaq -0x1(%r13), %rbp
movb $0x0, -0x1(%r13)
leaq (%rbx,%r12,4), %rdx
leaq 0x2cb0c(%rip), %rsi     # 0x51c69
xorl %eax, %eax
callq 0x3320
incq %r12
movq %r13, %rdi
jmp 0x2511f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_local
local_layer parse_local(list *options, size_params params)
{
    int n = option_find_int(options, "filters",1);
    int size = option_find_int(options, "size",1);
    int stride = option_find_int(options, "stride",1);
    int pad = option_find_int(options, "pad",0);
    char *activation_s = option_find_str(options, "activation", "logistic");
    ACTIVATION activation = get_activation(activation_s);

    int batch,h,w,c;
    h = params.h;
    w = params.w;
    c = params.c;
    batch=params.batch;
    if(!(h && w && c)) error("Layer before local layer must output image.");

    local_layer layer = make_local_layer(batch,h,w,c,n,size,stride,pad,activation);

    return layer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, 0x20(%rsp)
leaq 0x2b024(%rip), %rsi     # 0x501bc
pushq $0x1
popq %rbx
movq %r13, %rdi
movl %ebx, %edx
callq 0x2977d
movl %eax, 0x4(%rsp)
leaq 0x2c42a(%rip), %rsi     # 0x515da
movq %r13, %rdi
movl %ebx, %edx
callq 0x2977d
movq %rax, 0x18(%rsp)
leaq 0x2af08(%rip), %rsi     # 0x500ce
movq %r13, %rdi
movl %ebx, %edx
callq 0x2977d
movq %rax, 0x10(%rsp)
leaq 0x2aef9(%rip), %rsi     # 0x500d5
movq %r13, %rdi
xorl %edx, %edx
callq 0x2977d
movq %rax, 0x8(%rsp)
leaq 0x2aa50(%rip), %rsi     # 0x4fc42
leaq 0x2a4bf(%rip), %rdx     # 0x4f6b8
movq %r13, %rdi
callq 0x29737
movq %rax, %rdi
callq 0x1a016
movl %eax, %r13d
movl 0x60(%rsp), %r15d
movl 0x68(%rsp), %r14d
movl 0x6c(%rsp), %ebp
movl 0x70(%rsp), %ebx
testl %r14d, %r14d
setne %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
testl %ebx, %ebx
setne %al
testb %al, %cl
jne 0x25240
leaq 0x2ae9e(%rip), %rdi     # 0x500d9
callq 0x43df
movq 0x20(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
movl 0x4(%rsp), %r9d
pushq %r13
pushq 0x10(%rsp)
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0x2c802
addq $0x20, %rsp
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_deconvolutional
layer parse_deconvolutional(list *options, size_params params)
{
    int n = option_find_int(options, "filters",1);
    int size = option_find_int(options, "size",1);
    int stride = option_find_int(options, "stride",1);

    char *activation_s = option_find_str(options, "activation", "logistic");
    ACTIVATION activation = get_activation(activation_s);

    int batch,h,w,c;
    h = params.h;
    w = params.w;
    c = params.c;
    batch=params.batch;
    if(!(h && w && c)) error("Layer before deconvolutional layer must output image.");
    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
    int pad = option_find_int_quiet(options, "pad",0);
    int padding = option_find_int_quiet(options, "padding",0);
    if(pad) padding = size/2;

    layer l = make_deconvolutional_layer(batch,h,w,c,n,size,stride,padding, activation, batch_normalize, params.net->adam);

    return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, 0x20(%rsp)
leaq 0x60(%rsp), %r14
leaq 0x2af19(%rip), %rsi     # 0x501bc
pushq $0x1
popq %rbx
movq %r12, %rdi
movl %ebx, %edx
callq 0x2977d
movl %eax, 0x4(%rsp)
leaq 0x2c31f(%rip), %rsi     # 0x515da
movq %r12, %rdi
movl %ebx, %edx
callq 0x2977d
movq %rax, 0x18(%rsp)
leaq 0x2adfd(%rip), %rsi     # 0x500ce
movq %r12, %rdi
movl %ebx, %edx
callq 0x2977d
movq %rax, 0x10(%rsp)
leaq 0x2a95b(%rip), %rsi     # 0x4fc42
leaq 0x2a3ca(%rip), %rdx     # 0x4f6b8
movq %r12, %rdi
callq 0x29737
movq %rax, %rdi
callq 0x1a016
movq %rax, 0x8(%rsp)
movl (%r14), %eax
movl %eax, (%rsp)
movl 0x8(%r14), %ebp
movl 0xc(%r14), %r15d
movl 0x10(%r14), %r13d
testl %ebp, %ebp
setne %al
testl %r15d, %r15d
setne %cl
andb %al, %cl
testl %r13d, %r13d
setne %al
testb %al, %cl
jne 0x25338
leaq 0x2add2(%rip), %rdi     # 0x50105
callq 0x43df
leaq 0x2adfc(%rip), %rsi     # 0x5013b
movq %r12, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, %r14d
leaq 0x2ad82(%rip), %rsi     # 0x500d5
movq %r12, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, %ebx
leaq 0x2ade5(%rip), %rsi     # 0x5014b
movq %r12, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, %ecx
pushq $0x2
popq %rsi
movq 0x18(%rsp), %r11
movl %r11d, %eax
cltd
idivl %esi
testl %ebx, %ebx
cmovel %ecx, %eax
leaq 0x60(%rsp), %rcx
movq 0x20(%rcx), %rcx
movl 0x70(%rcx), %r10d
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl (%rsp), %esi
movl %ebp, %edx
movl %r15d, %ecx
movl %r13d, %r8d
movl 0x4(%rsp), %r9d
pushq %r10
pushq %r14
pushq 0x18(%rsp)
pushq %rax
pushq 0x30(%rsp)
pushq %r11
callq 0x4fc7
addq $0x30, %rsp
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_crnn
layer parse_crnn(list *options, size_params params)
{
    int output_filters = option_find_int(options, "output_filters",1);
    int hidden_filters = option_find_int(options, "hidden_filters",1);
    char *activation_s = option_find_str(options, "activation", "logistic");
    ACTIVATION activation = get_activation(activation_s);
    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);

    layer l = make_crnn_layer(params.batch, params.w, params.h, params.c, hidden_filters, output_filters, params.time_steps, activation, batch_normalize);

    l.shortcut = option_find_int_quiet(options, "shortcut", 0);

    return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2abe8(%rip), %rsi     # 0x501a6
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %edx
callq 0x2977d
movl %eax, %r15d
leaq 0x2abe0(%rip), %rsi     # 0x501b5
movq %r14, %rdi
movl %ebp, %edx
callq 0x2977d
movl %eax, %ebp
leaq 0x2a65a(%rip), %rsi     # 0x4fc42
leaq 0x2a0c9(%rip), %rdx     # 0x4f6b8
movq %r14, %rdi
callq 0x29737
movq %rax, %rdi
callq 0x1a016
movl %eax, %r12d
leaq 0x2ab32(%rip), %rsi     # 0x5013b
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl 0x3c(%rsp), %edx
movl 0x30(%rsp), %esi
movl 0x38(%rsp), %ecx
movl 0x40(%rsp), %r8d
movl 0x48(%rsp), %r10d
movq %rbx, %rdi
movl %ebp, %r9d
pushq %rax
pushq %r12
pushq %r10
pushq %r15
callq 0x2eeb0
addq $0x20, %rsp
leaq 0x2a672(%rip), %rsi     # 0x4fcb8
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, 0x44(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_rnn
layer parse_rnn(list *options, size_params params)
{
    int output = option_find_int(options, "output",1);
    char *activation_s = option_find_str(options, "activation", "logistic");
    ACTIVATION activation = get_activation(activation_s);
    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);

    layer l = make_rnn_layer(params.batch, params.inputs, output, params.time_steps, activation, batch_normalize, params.net->adam);

    l.shortcut = option_find_int_quiet(options, "shortcut", 0);

    return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2ab51(%rip), %rsi     # 0x501c4
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x2977d
movl %eax, %ebp
leaq 0x2a5bb(%rip), %rsi     # 0x4fc42
leaq 0x2a02a(%rip), %rdx     # 0x4f6b8
movq %r14, %rdi
callq 0x29737
movq %rax, %rdi
callq 0x1a016
movl %eax, %r15d
leaq 0x2aa93(%rip), %rsi     # 0x5013b
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl 0x30(%rsp), %esi
movl 0x34(%rsp), %edx
movl 0x48(%rsp), %r8d
movq 0x50(%rsp), %rcx
movl 0x70(%rcx), %r10d
movq %rbx, %rdi
movl %ebp, %ecx
movl %r15d, %r9d
pushq %r10
pushq %rax
callq 0x2d6d4
popq %rax
popq %rcx
leaq 0x2a5d7(%rip), %rsi     # 0x4fcb8
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, 0x44(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_gru
layer parse_gru(list *options, size_params params)
{
    int output = option_find_int(options, "output",1);
    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);

    layer l = make_gru_layer(params.batch, params.inputs, output, params.time_steps, batch_normalize, params.net->adam);
    l.tanh = option_find_int_quiet(options, "tanh", 0);

    return l;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2aab3(%rip), %rsi     # 0x501c4
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x2977d
movl %eax, %ebp
leaq 0x2aa16(%rip), %rsi     # 0x5013b
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl 0x30(%rsp), %esi
movl 0x34(%rsp), %edx
movl 0x48(%rsp), %r8d
movq 0x50(%rsp), %rcx
movl 0x70(%rcx), %ecx
movl %ecx, (%rsp)
movq %rbx, %rdi
movl %ebp, %ecx
movl %eax, %r9d
callq 0x2e210
leaq 0x29f88(%rip), %rsi     # 0x4f6e3
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, 0x120(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_connected
layer parse_connected(list *options, size_params params)
{
    int output = option_find_int(options, "output",1);
    char *activation_s = option_find_str(options, "activation", "logistic");
    ACTIVATION activation = get_activation(activation_s);
    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);

    layer l = make_connected_layer(params.batch, params.inputs, output, activation, batch_normalize, params.net->adam);
    return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2a9d5(%rip), %rsi     # 0x501c4
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x2977d
movl %eax, %ebp
leaq 0x2a43f(%rip), %rsi     # 0x4fc42
leaq 0x29eae(%rip), %rdx     # 0x4f6b8
movq %r14, %rdi
callq 0x29737
movq %rax, %rdi
callq 0x1a016
movl %eax, %r15d
leaq 0x2a917(%rip), %rsi     # 0x5013b
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl 0x30(%rsp), %esi
movl 0x34(%rsp), %edx
movq 0x50(%rsp), %rcx
movl 0x70(%rcx), %ecx
movl %ecx, (%rsp)
movq %rbx, %rdi
movl %ebp, %ecx
movl %r15d, %r8d
movl %eax, %r9d
callq 0x24180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_softmax
layer parse_softmax(list *options, size_params params)
{
    int groups = option_find_int_quiet(options, "groups",1);
    layer l = make_softmax_layer(params.batch, params.inputs, groups);
    l.temperature = option_find_float_quiet(options, "temperature", 1);
    char *tree_file = option_find_str(options, "tree", 0);
    if (tree_file) l.softmax_tree = read_tree(tree_file);
    l.w = params.w;
    l.h = params.h;
    l.c = params.c;
    l.spatial = option_find_float_quiet(options, "spatial", 0);
    l.noloss =  option_find_int_quiet(options, "noloss", 0);
    return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
leaq 0x2a8dd(%rip), %rsi     # 0x50153
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x29884
movl (%r15), %esi
movl 0x4(%r15), %edx
movq %rbx, %rdi
movl %eax, %ecx
callq 0x1c654
leaq 0x2a932(%rip), %rsi     # 0x501cb
movss 0x26767(%rip), %xmm0    # 0x4c008
movq %r14, %rdi
callq 0x2989e
movss %xmm0, 0x18c(%rbx)
leaq 0x2a91f(%rip), %rsi     # 0x501d7
movq %r14, %rdi
xorl %edx, %edx
callq 0x29737
testq %rax, %rax
je 0x258d6
movq %rax, %rdi
callq 0x325a2
movq %rax, 0x490(%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x6c(%rbx)
movl 0x10(%r15), %eax
movl %eax, 0x74(%rbx)
leaq 0x2a8f0(%rip), %rsi     # 0x501dc
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x2989e
cvttss2si %xmm0, %eax
movl %eax, 0xa4(%rbx)
leaq 0x2a8dc(%rip), %rsi     # 0x501e4
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, 0xf4(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_yolo_mask
int *parse_yolo_mask(char *a, int *num)
{
    int *mask = 0;
    if(a){
        int len = strlen(a);
        int n = 1;
        int i;
        for(i = 0; i < len; ++i){
            if (a[i] == ',') ++n;
        }
        mask = calloc(n, sizeof(int));
        for(i = 0; i < n; ++i){
            int val = atoi(a);
            mask[i] = val;
            a = strchr(a, ',')+1;
        }
        *num = n;
    }
    return mask;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x259a4
movq %rdi, %r15
movq %rsi, (%rsp)
callq 0x3140
testl %eax, %eax
cmovlel %r14d, %eax
pushq $0x1
popq %r13
cmpq %r14, %rax
je 0x25961
xorl %ecx, %ecx
cmpb $0x2c, (%r15,%r14)
sete %cl
addl %ecx, %r13d
incq %r14
jmp 0x2594a
movl %r13d, %r12d
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0x3250
movq %rax, %r14
xorl %ebx, %ebx
pushq $0x2c
popq %rbp
cmpq %rbx, %r12
je 0x2599d
movq %r15, %rdi
callq 0x3400
movl %eax, (%r14,%rbx,4)
movq %r15, %rdi
movl %ebp, %esi
callq 0x3150
movq %rax, %r15
incq %r15
incq %rbx
jmp 0x25977
movq (%rsp), %rax
movl %r13d, (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_iseg
layer parse_iseg(list *options, size_params params)
{
    int classes = option_find_int(options, "classes", 20);
    int ids = option_find_int(options, "ids", 32);
    layer l = make_iseg_layer(params.batch, params.w, params.h, classes, ids);
    assert(l.outputs == params.inputs);
    return l;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2a637(%rip), %rsi     # 0x501eb
pushq $0x14
popq %rdx
movq %r14, %rdi
callq 0x2977d
movl %eax, %ebp
leaq 0x2a6ae(%rip), %rsi     # 0x50276
pushq $0x20
popq %rdx
movq %r14, %rdi
callq 0x2977d
movl 0x2c(%rsp), %edx
movl 0x20(%rsp), %esi
movl 0x28(%rsp), %ecx
movq %rbx, %rdi
movl %ebp, %r8d
movl %eax, %r9d
callq 0x35df8
movl 0x58(%rbx), %eax
cmpl 0x24(%rsp), %eax
jne 0x25bfe
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2a5f2(%rip), %rdi     # 0x501f7
leaq 0x2a606(%rip), %rsi     # 0x50212
leaq 0x2a667(%rip), %rcx     # 0x5027a
movl $0x15d, %edx            # imm = 0x15D
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_cost
cost_layer parse_cost(list *options, size_params params)
{
    char *type_s = option_find_str(options, "type", "sse");
    COST_TYPE type = get_cost_type(type_s);
    float scale = option_find_float_quiet(options, "scale",1);
    cost_layer layer = make_cost_layer(params.batch, params.inputs, type, scale);
    layer.ratio =  option_find_float_quiet(options, "ratio",0);
    layer.noobject_scale =  option_find_float_quiet(options, "noobj", 1);
    layer.thresh =  option_find_float_quiet(options, "thresh",0);
    return layer;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28873(%rip), %rsi     # 0x4e99f
leaq 0x29cf1(%rip), %rdx     # 0x4fe24
movq %r14, %rdi
callq 0x29737
movq %rax, %rdi
callq 0x249d0
movl %eax, %ebp
leaq 0x2a1b7(%rip), %rsi     # 0x50303
movss 0x25eb4(%rip), %xmm0    # 0x4c008
movq %r14, %rdi
callq 0x2989e
movl 0x20(%rsp), %esi
movl 0x24(%rsp), %edx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x24aa0
leaq 0x2a3e2(%rip), %rsi     # 0x50557
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x2989e
movss %xmm0, 0xe8(%rbx)
leaq 0x2a1b7(%rip), %rsi     # 0x50346
movq %r14, %rdi
movss 0x25e6e(%rip), %xmm0    # 0x4c008
callq 0x2989e
movss %xmm0, 0x148(%rbx)
leaq 0x2be72(%rip), %rsi     # 0x52020
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x2989e
movss %xmm0, 0x164(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_crop
crop_layer parse_crop(list *options, size_params params)
{
    int crop_height = option_find_int(options, "crop_height",1);
    int crop_width = option_find_int(options, "crop_width",1);
    int flip = option_find_int(options, "flip",0);
    float angle = option_find_float(options, "angle",0);
    float saturation = option_find_float(options, "saturation",1);
    float exposure = option_find_float(options, "exposure",1);

    int batch,h,w,c;
    h = params.h;
    w = params.w;
    c = params.c;
    batch=params.batch;
    if(!(h && w && c)) error("Layer before crop layer must output image.");

    int noadjust = option_find_int_quiet(options, "noadjust",0);

    crop_layer l = make_crop_layer(batch,h,w,c,crop_height,crop_width,flip, angle, saturation, exposure);
    l.shift = option_find_float(options, "shift", 0);
    l.noadjust = noadjust;
    return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x2a166(%rip), %rsi     # 0x5034c
pushq $0x1
popq %rbx
movq %r14, %rdi
movl %ebx, %edx
callq 0x2977d
movl %eax, 0x1c(%rsp)
leaq 0x2a15a(%rip), %rsi     # 0x50358
movq %r14, %rdi
movl %ebx, %edx
callq 0x2977d
movq %rax, 0x28(%rsp)
leaq 0x2a14f(%rip), %rsi     # 0x50363
movq %r14, %rdi
xorl %edx, %edx
callq 0x2977d
movq %rax, 0x20(%rsp)
leaq 0x2a13e(%rip), %rsi     # 0x50368
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x298c3
movss %xmm0, 0x18(%rsp)
leaq 0x2a12c(%rip), %rsi     # 0x5036e
movss 0x25dbe(%rip), %xmm0    # 0x4c008
movq %r14, %rdi
callq 0x298c3
movss %xmm0, 0x14(%rsp)
leaq 0x2a11a(%rip), %rsi     # 0x50379
movq %r14, %rdi
movss 0x25d9e(%rip), %xmm0    # 0x4c008
callq 0x298c3
movss %xmm0, 0x10(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x78(%rsp), %r13d
movl 0x7c(%rsp), %ebp
movl 0x80(%rsp), %r12d
testl %r13d, %r13d
setne %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
testl %r12d, %r12d
setne %al
testb %al, %cl
jne 0x262b1
leaq 0x2a0d6(%rip), %rdi     # 0x50382
callq 0x43df
leaq 0x2a0f5(%rip), %rsi     # 0x503ad
movq %r14, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, %ebx
movq 0x30(%rsp), %r15
movq %r15, %rdi
movl 0xc(%rsp), %esi
movl %r13d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
movl 0x1c(%rsp), %r9d
movss 0x18(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movss 0x10(%rsp), %xmm2
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0x1bb99
popq %rax
popq %rcx
leaq 0x2a0b1(%rip), %rsi     # 0x503b6
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x298c3
movss %xmm0, 0xe4(%r15)
movl %ebx, 0x114(%r15)
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_reorg
layer parse_reorg(list *options, size_params params)
{
    int stride = option_find_int(options, "stride",1);
    int reverse = option_find_int_quiet(options, "reverse",0);
    int flatten = option_find_int_quiet(options, "flatten",0);
    int extra = option_find_int_quiet(options, "extra",0);

    int batch,h,w,c;
    h = params.h;
    w = params.w;
    c = params.c;
    batch=params.batch;
    if(!(h && w && c)) error("Layer before reorg layer must output image.");

    layer layer = make_reorg_layer(batch,w,h,c,stride,reverse, flatten, extra);
    return layer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, 0x20(%rsp)
leaq 0x29d7f(%rip), %rsi     # 0x500ce
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x2977d
movl %eax, 0xc(%rsp)
leaq 0x2a057(%rip), %rsi     # 0x503bc
movq %r12, %rdi
xorl %edx, %edx
callq 0x29884
movq %rax, 0x18(%rsp)
leaq 0x2a049(%rip), %rsi     # 0x503c4
movq %r12, %rdi
xorl %edx, %edx
callq 0x29884
movq %rax, 0x10(%rsp)
leaq 0x2a03b(%rip), %rsi     # 0x503cc
movq %r12, %rdi
xorl %edx, %edx
callq 0x29884
movl %eax, %r12d
movl 0x60(%rsp), %ebp
movl 0x68(%rsp), %r13d
movl 0x6c(%rsp), %r14d
movl 0x70(%rsp), %ebx
testl %r13d, %r13d
setne %al
testl %r14d, %r14d
setne %cl
andb %al, %cl
testl %ebx, %ebx
setne %al
testb %al, %cl
jne 0x263d3
leaq 0x2a004(%rip), %rdi     # 0x503d2
callq 0x43df
subq $0x8, %rsp
movq 0x28(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %r13d, %ecx
movl %ebx, %r8d
movl 0x14(%rsp), %r9d
pushq %r12
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0x31f0c
addq $0x20, %rsp
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_maxpool
maxpool_layer parse_maxpool(list *options, size_params params)
{
    int stride = option_find_int(options, "stride",1);
    int size = option_find_int(options, "size",stride);
    int padding = option_find_int_quiet(options, "padding", size-1);

    int batch,h,w,c;
    h = params.h;
    w = params.w;
    c = params.c;
    batch=params.batch;
    if(!(h && w && c)) error("Layer before maxpool layer must output image.");

    maxpool_layer layer = make_maxpool_layer(batch,h,w,c,size,stride,padding);
    return layer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
leaq 0x29c9d(%rip), %rsi     # 0x500ce
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x2977d
leaq 0x2b197(%rip), %rsi     # 0x515da
movq %rbx, %rdi
movq %rax, 0x8(%rsp)
movl %eax, %edx
callq 0x2977d
movl %eax, %r15d
leal -0x1(%r15), %edx
leaq 0x29ceb(%rip), %rsi     # 0x5014b
movq %rbx, %rdi
callq 0x29884
movl 0x50(%rsp), %ebx
movl 0x58(%rsp), %ebp
movl 0x5c(%rsp), %r13d
movl 0x60(%rsp), %r12d
testl %ebp, %ebp
setne %dl
testl %r13d, %r13d
setne %cl
andb %dl, %cl
testl %r12d, %r12d
setne %dl
testb %dl, %cl
jne 0x264a3
leaq 0x29f66(%rip), %rdi     # 0x503fe
movq %rax, %r14
callq 0x43df
movq %r14, %rax
movq 0x10(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r13d, %ecx
movl %r12d, %r8d
movl %r15d, %r9d
pushq %rax
pushq 0x10(%rsp)
callq 0x1c146
popq %rax
popq %rcx
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq