LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
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)
movq 0x268(%rax), %rdi
movl 0x58(%rax), %esi
imull 0x48(%rax), %esi
movl 0x4(%rax), %edx
movq 0x260(%rax), %rcx
callq 0x2e560
movq -0x40(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x3c899
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 0x4b530
jmp 0x3c8bc
movq -0x40(%rbp), %rax
movq 0x238(%rax), %rdi
movq 0x260(%rax), %rsi
movl 0x48(%rax), %edx
movl 0x58(%rax), %ecx
movl $0x1, %r8d
callq 0x8980
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movl 0x58(%rax), %edx
movl %edx, -0x14(%rbp)
movl 0x48(%rax), %edx
movl %edx, -0x18(%rbp)
movl 0x54(%rax), %edx
movl %edx, -0x1c(%rbp)
movq 0x260(%rax), %rdx
movq %rdx, -0x28(%rbp)
movq 0xd8(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq 0x258(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x18(%rbp), %r8d
movq -0x28(%rbp), %r9
movl -0x14(%rbp), %r14d
movq -0x30(%rbp), %rbx
movl -0x1c(%rbp), %r11d
movq -0x38(%rbp), %r10
movl -0x1c(%rbp), %eax
movl $0x1, %edi
xorl %esi, %esi
movss 0x346e5(%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), %rcx
movq -0x48(%rbp), %rax
movl 0x48(%rcx), %edx
movl %edx, -0x14(%rbp)
movl 0x58(%rcx), %edx
movl %edx, -0x18(%rbp)
movl 0x54(%rcx), %edx
movl %edx, -0x1c(%rbp)
movq 0x260(%rcx), %rdx
movq %rdx, -0x28(%rbp)
movq 0x250(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq 0xe8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3c9d4
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 -0x1c(%rbp), %r11d
movq -0x38(%rbp), %r10
movl -0x1c(%rbp), %eax
xorl %esi, %esi
movss 0x34659(%rip), %xmm1    # 0x7100c
movl %esi, %edi
movaps %xmm1, %xmm0
movl %r14d, (%rsp)
movq %rbx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x3aa0
addq $0x5f0, %rsp            # imm = 0x5F0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4b0(%rbp), %rcx
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movss 0x4(%rcx), %xmm0
mulss 0xec(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
movss 0x8(%rcx), %xmm0
movss %xmm0, -0x8(%rbp)
movss 0xc(%rcx), %xmm0
movss %xmm0, -0xc(%rbp)
movl (%rcx), %ecx
movl %ecx, -0x10(%rbp)
movl 0x58(%rax), %edi
movss -0x4(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq 0x238(%rax), %rsi
movq 0x230(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x18(%rbp), %rax
movl 0x58(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x238(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x3cac4
movq -0x18(%rbp), %rax
movl 0x58(%rax), %edi
movss -0x4(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq 0x248(%rax), %rsi
movq 0x240(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x18(%rbp), %rax
movl 0x58(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x248(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
movq -0x18(%rbp), %rax
movl 0x54(%rax), %edi
imull 0x58(%rax), %edi
movss -0xc(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
movq 0x250(%rax), %rsi
movq 0x258(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x18(%rbp), %rax
movl 0x54(%rax), %edi
imull 0x58(%rax), %edi
movss -0x4(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movq 0x258(%rax), %rsi
movq 0x250(%rax), %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movq -0x18(%rbp), %rax
movl 0x54(%rax), %edi
imull 0x58(%rax), %edi
movss -0x8(%rbp), %xmm0
movq 0x258(%rax), %rsi
movl $0x1, %edx
callq 0x2f6f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x58(%rcx), %eax
jge 0x3ccc8
movq -0x18(%rbp), %rax
movq 0x240(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x2b8(%rax), %rax
movslq -0x4(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x34480(%rip), %xmm1    # 0x71050
addsd %xmm1, %xmm0
callq 0x3430
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x54(%rcx), %eax
jge 0x3cc33
movq -0x18(%rbp), %rdx
movss -0xc(%rbp), %xmm0
movq 0x250(%rdx), %rax
movl -0x4(%rbp), %ecx
imull 0x54(%rdx), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
mulss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3cbf5
movq -0x18(%rbp), %rax
movq 0x2b0(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movss -0xc(%rbp), %xmm2
movq 0x230(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm1
movd %xmm0, %esi
xorl $0x80000000, %esi       # imm = 0x80000000
movd %esi, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rcx,%rdx,4)
movq 0x240(%rax), %rcx
movslq -0x4(%rbp), %rdx
movss 0x34382(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rcx,%rdx,4)
movq 0x2b0(%rax), %rcx
movslq -0x4(%rbp), %rdx
xorps %xmm0, %xmm0
movss %xmm0, (%rcx,%rdx,4)
movq 0x2b8(%rax), %rax
movslq -0x4(%rbp), %rcx
movss 0x34357(%rip), %xmm0    # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3cb87
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, 0x40(%rax)
je 0x3cd07
leaq 0x37a48(%rip), %rdi     # 0x74735
movb $0x0, %al
callq 0x3130
movq -0x8(%rbp), %rax
movq 0x240(%rax), %rdi
movl 0x58(%rax), %esi
callq 0x55d0
leaq 0x37a2f(%rip), %rdi     # 0x7473d
movb $0x0, %al
callq 0x3130
movq -0x8(%rbp), %rax
movq 0x230(%rax), %rdi
movl 0x58(%rax), %esi
callq 0x55d0
leaq 0x37a16(%rip), %rdi     # 0x74745
movb $0x0, %al
callq 0x3130
movq -0x8(%rbp), %rax
movq 0x250(%rax), %rdi
movl 0x58(%rax), %esi
callq 0x55d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x37a01(%rip), %rsi     # 0x74768
callq 0x3230
cmpl $0x0, %eax
jne 0x3cd7d
movl $0x3, -0x4(%rbp)
jmp 0x3ce39
movq -0x10(%rbp), %rdi
leaq 0x379e4(%rip), %rsi     # 0x7476c
callq 0x3230
cmpl $0x0, %eax
jne 0x3cd9e
movl $0x0, -0x4(%rbp)
jmp 0x3ce39
movq -0x10(%rbp), %rdi
leaq 0x379c7(%rip), %rsi     # 0x74770
callq 0x3230
cmpl $0x0, %eax
jne 0x3cdbc
movl $0x1, -0x4(%rbp)
jmp 0x3ce39
movq -0x10(%rbp), %rdi
leaq 0x39d7d(%rip), %rsi     # 0x76b44
callq 0x3230
cmpl $0x0, %eax
jne 0x3cdda
movl $0x4, -0x4(%rbp)
jmp 0x3ce39
movq -0x10(%rbp), %rdi
leaq 0x37992(%rip), %rsi     # 0x74777
callq 0x3230
cmpl $0x0, %eax
jne 0x3cdf8
movl $0x2, -0x4(%rbp)
jmp 0x3ce39
movq -0x10(%rbp), %rdi
leaq 0x37977(%rip), %rsi     # 0x7477a
callq 0x3230
cmpl $0x0, %eax
jne 0x3ce16
movl $0x5, -0x4(%rbp)
jmp 0x3ce39
movq 0x461db(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x37954(%rip), %rsi     # 0x7477f
movb $0x0, %al
callq 0x3240
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/cost_layer.c
// Function: get_cost_string
char *get_cost_string(COST_TYPE a)
{
    switch(a){
        case SEG:
            return "seg";
        case SSE:
            return "sse";
        case MASKED:
            return "masked";
        case SMOOTH:
            return "smooth";
        case L1:
            return "L1";
        case WGAN:
            return "wgan";
    }
    return "sse";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x3cec6
movq -0x18(%rbp), %rax
leaq 0x378e1(%rip), %rcx     # 0x74750
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x378e9(%rip), %rax     # 0x74768
movq %rax, -0x8(%rbp)
jmp 0x3ced1
leaq 0x378e0(%rip), %rax     # 0x7476c
movq %rax, -0x8(%rbp)
jmp 0x3ced1
leaq 0x378d7(%rip), %rax     # 0x74770
movq %rax, -0x8(%rbp)
jmp 0x3ced1
leaq 0x39c9e(%rip), %rax     # 0x76b44
movq %rax, -0x8(%rbp)
jmp 0x3ced1
leaq 0x378c4(%rip), %rax     # 0x74777
movq %rax, -0x8(%rbp)
jmp 0x3ced1
leaq 0x378ba(%rip), %rax     # 0x7477a
movq %rax, -0x8(%rbp)
jmp 0x3ced1
leaq 0x3789f(%rip), %rax     # 0x7476c
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq 0x460f3(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x37899(%rip), %rsi     # 0x747ab
movb $0x0, %al
callq 0x3240
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x20(%rbp), %rdi
movl $0x9, (%rdi)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x194(%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x54(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x58(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq %rax, 0x260(%rdi)
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq %rax, 0x268(%rdi)
movl $0x1, %edi
movl $0x4, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x1d8(%rdi)
leaq 0x22(%rip), %rcx        # 0x3cfe0
movq %rcx, 0x10(%rdi)
leaq 0x197(%rip), %rcx       # 0x3d160
movq %rcx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0xe0(%rax)
jne 0x3d00a
jmp 0x3d14b
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x3d07b
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rdx
movl -0x4(%rbp), %eax
movl 0x48(%rdx), %ecx
imull 0x54(%rdx), %ecx
cmpl %ecx, %eax
jge 0x3d079
movq -0x18(%rbp), %rax
movq 0xe0(%rax), %rax
movslq -0x4(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x372d3(%rip), %xmm1    # 0x7431c
ucomiss %xmm1, %xmm0
jne 0x3d06c
jp 0x3d06c
movq -0x18(%rbp), %rax
movq 0xd8(%rax), %rax
movslq -0x4(%rbp), %rcx
movss 0x372b5(%rip), %xmm0    # 0x7431c
movss %xmm0, (%rax,%rcx,4)
jmp 0x3d06e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3d01b
jmp 0x3d07b
movq -0x10(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x3d0b7
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x48(%rax), %edi
imull 0x54(%rax), %edi
movq 0xd8(%rcx), %rsi
movq 0xe0(%rcx), %rdx
movq 0x260(%rax), %rcx
movq 0x268(%rax), %r8
callq 0x2fa30
jmp 0x3d125
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x3d0f3
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x48(%rax), %edi
imull 0x54(%rax), %edi
movq 0xd8(%rcx), %rsi
movq 0xe0(%rcx), %rdx
movq 0x260(%rax), %rcx
movq 0x268(%rax), %r8
callq 0x2fb30
jmp 0x3d123
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x48(%rax), %edi
imull 0x54(%rax), %edi
movq 0xd8(%rcx), %rsi
movq 0xe0(%rcx), %rdx
movq 0x260(%rax), %rcx
movq 0x268(%rax), %r8
callq 0x2fdd0
jmp 0x3d125
movq -0x10(%rbp), %rax
movq 0x268(%rax), %rdi
movl 0x48(%rax), %esi
imull 0x54(%rax), %esi
callq 0x5480
movq -0x10(%rbp), %rax
movq 0x1d8(%rax), %rax
movss %xmm0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/cost_layer.c
// Function: resize_cost_layer
void resize_cost_layer(cost_layer *l, int inputs)
{
    l->inputs = inputs;
    l->outputs = inputs;
    l->delta = realloc(l->delta, inputs*l->batch*sizeof(float));
    l->output = realloc(l->output, inputs*l->batch*sizeof(float));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rdi
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x48(%rcx), %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x268(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3d6fe
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x18(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3030
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3d6b8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3d73f
jmp 0x3d811
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x2d(%rbp)
jge 0x3d776
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x3d782
jmp 0x3d811
jmp 0x3d784
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2e(%rbp)
je 0x3d7b1
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
setne %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
testb $0x1, %al
jne 0x3d7ba
jmp 0x3d7bc
jmp 0x3d784
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3d7cf
movl $0x1, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x38cef(%rip), %rsi     # 0x764df
movb $0x0, %al
callq 0x32f0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3d75d
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x371e0(%rip), %rsi     # 0x74a28
movl $0x1, %edx
callq 0x42990
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3860f(%rip), %rsi     # 0x75e6f
movl $0x1, %edx
callq 0x42990
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x370c2(%rip), %rsi     # 0x7493a
movl $0x1, %edx
callq 0x42990
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x370b1(%rip), %rsi     # 0x74941
xorl %edx, %edx
callq 0x42990
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x36cd1(%rip), %rsi     # 0x74576
leaq 0x36838(%rip), %rdx     # 0x740e4
callq 0x42920
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2d650
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, -0x2c(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x34(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x38(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x3c(%rbp)
movl (%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x3d8f0
cmpl $0x0, -0x38(%rbp)
je 0x3d8f0
cmpl $0x0, -0x3c(%rbp)
jne 0x3d8fc
leaq 0x3704e(%rip), %rdi     # 0x74945
callq 0x4c50
movq -0x58(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movl -0x14(%rbp), %r9d
movl -0x18(%rbp), %ebx
movl -0x1c(%rbp), %r11d
movl -0x20(%rbp), %r10d
movl -0x2c(%rbp), %eax
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x47490
movq -0x50(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x370b9(%rip), %rsi     # 0x74a28
movl $0x1, %edx
callq 0x42990
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x384e8(%rip), %rsi     # 0x75e6f
movl $0x1, %edx
callq 0x42990
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x36f9b(%rip), %rsi     # 0x7493a
movl $0x1, %edx
callq 0x42990
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x36bbf(%rip), %rsi     # 0x74576
leaq 0x36726(%rip), %rdx     # 0x740e4
callq 0x42920
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2d650
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, -0x3c(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x44(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x48(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x4c(%rbp)
movl (%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x3da02
cmpl $0x0, -0x48(%rbp)
je 0x3da02
cmpl $0x0, -0x4c(%rbp)
jne 0x3da0e
leaq 0x36f68(%rip), %rdi     # 0x74971
callq 0x4c50
movq -0x20(%rbp), %rdi
leaq 0x36f8e(%rip), %rsi     # 0x749a7
xorl %edx, %edx
callq 0x42b50
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x36f13(%rip), %rsi     # 0x74941
xorl %edx, %edx
callq 0x42b50
movl %eax, -0x54(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x36f74(%rip), %rsi     # 0x749b7
xorl %edx, %edx
callq 0x42b50
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0x3da61
movl -0x28(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x58(%rbp)
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rax
movl -0x40(%rbp), %esi
movl -0x44(%rbp), %edx
movl -0x48(%rbp), %ecx
movl -0x4c(%rbp), %r8d
movl -0x24(%rbp), %r9d
movl -0x28(%rbp), %r15d
movl -0x2c(%rbp), %r14d
movl -0x58(%rbp), %ebx
movl -0x3c(%rbp), %r11d
movl -0x50(%rbp), %r10d
movq 0x20(%rax), %rax
movl 0x70(%rax), %eax
movl %r15d, (%rsp)
movl %r14d, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x6210
movq -0x68(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x36cda(%rip), %rsi     # 0x74a12
movl $0x1, %edx
callq 0x42990
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x36cd1(%rip), %rsi     # 0x74a21
movl $0x1, %edx
callq 0x42990
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3680e(%rip), %rsi     # 0x74576
leaq 0x36375(%rip), %rdx     # 0x740e4
callq 0x42920
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2d650
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x36c18(%rip), %rsi     # 0x749a7
xorl %edx, %edx
callq 0x42b50
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x28(%rbp)
movl (%rax), %esi
movl 0xc(%rax), %edx
movl 0x8(%rax), %ecx
movl 0x10(%rax), %r8d
movl -0x18(%rbp), %r9d
movl -0x14(%rbp), %ebx
movl 0x18(%rax), %r11d
movl -0x24(%rbp), %r10d
movl -0x28(%rbp), %eax
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x4a290
movq -0x10(%rbp), %rdi
leaq 0x3680a(%rip), %rsi     # 0x745ec
xorl %edx, %edx
callq 0x42b50
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x44(%rdi)
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36c09(%rip), %rsi     # 0x74a30
movl $0x1, %edx
callq 0x42990
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36737(%rip), %rsi     # 0x74576
leaq 0x3629e(%rip), %rdx     # 0x740e4
callq 0x42920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d650
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36b41(%rip), %rsi     # 0x749a7
xorl %edx, %edx
callq 0x42b50
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x20(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
movl -0xc(%rbp), %ecx
movl 0x18(%rax), %r8d
movl -0x1c(%rbp), %r9d
movl -0x20(%rbp), %r10d
movq 0x20(%rax), %rax
movl 0x70(%rax), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x486d0
movq -0x8(%rbp), %rdi
leaq 0x3673f(%rip), %rsi     # 0x745ec
xorl %edx, %edx
callq 0x42b50
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x44(%rdi)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36b39(%rip), %rsi     # 0x74a30
movl $0x1, %edx
callq 0x42990
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36a98(%rip), %rsi     # 0x749a7
xorl %edx, %edx
callq 0x42b50
movq -0x20(%rbp), %rdi
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
movl -0xc(%rbp), %ecx
movl 0x18(%rax), %r8d
movl -0x10(%rbp), %r9d
movq 0x20(%rax), %rax
movl 0x70(%rax), %eax
movl %eax, (%rsp)
callq 0x49360
movq -0x8(%rbp), %rdi
leaq 0x361c2(%rip), %rsi     # 0x7410f
xorl %edx, %edx
callq 0x42b50
movq -0x20(%rbp), %rdi
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x120(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_lstm
layer parse_lstm(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_lstm_layer(params.batch, params.inputs, output, params.time_steps, batch_normalize, params.net->adam);

    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36a99(%rip), %rsi     # 0x74a30
movl $0x1, %edx
callq 0x42990
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x369f8(%rip), %rsi     # 0x749a7
xorl %edx, %edx
callq 0x42b50
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
movl -0xc(%rbp), %ecx
movl 0x18(%rax), %r8d
movl -0x10(%rbp), %r9d
movq 0x20(%rax), %rax
movl 0x70(%rax), %eax
movl %eax, (%rsp)
callq 0x4f4d0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36a19(%rip), %rsi     # 0x74a30
movl $0x1, %edx
callq 0x42990
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36547(%rip), %rsi     # 0x74576
leaq 0x360ae(%rip), %rdx     # 0x740e4
callq 0x42920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d650
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36951(%rip), %rsi     # 0x749a7
xorl %edx, %edx
callq 0x42b50
movq -0x38(%rbp), %rdi
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x20(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
movl -0xc(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
movq 0x20(%rax), %rax
movl 0x70(%rax), %eax
movl %eax, (%rsp)
callq 0x3c260
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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x368f8(%rip), %rsi     # 0x749bf
movl $0x1, %edx
callq 0x42b50
movq -0x20(%rbp), %rdi
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
movl -0xc(%rbp), %ecx
callq 0x31120
movq -0x8(%rbp), %rdi
leaq 0x36941(%rip), %rsi     # 0x74a37
movss 0x32f0e(%rip), %xmm0    # 0x7100c
callq 0x42ba0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x18c(%rdi)
movq -0x8(%rbp), %rdi
leaq 0x36929(%rip), %rsi     # 0x74a43
xorl %eax, %eax
movl %eax, %edx
callq 0x42920
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3e145
movq -0x18(%rbp), %rdi
callq 0x4f1c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x490(%rax)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %edx
movl %edx, 0x70(%rax)
movl 0x8(%rcx), %edx
movl %edx, 0x6c(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x74(%rax)
movq -0x8(%rbp), %rdi
leaq 0x368de(%rip), %rsi     # 0x74a48
xorps %xmm0, %xmm0
callq 0x42ba0
movq -0x20(%rbp), %rax
cvttss2si %xmm0, %ecx
movl %ecx, 0xa4(%rax)
movq -0x8(%rbp), %rdi
leaq 0x368c5(%rip), %rsi     # 0x74a50
xorl %edx, %edx
callq 0x42b50
movq -0x20(%rbp), %rcx
movl %eax, %edx
movq -0x30(%rbp), %rax
movl %edx, 0xf4(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e281
movq -0x8(%rbp), %rdi
callq 0x3110
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3e21c
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
jne 0x3e20f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3e211
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e1ed
movslq -0x20(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3e278
movq -0x8(%rbp), %rdi
callq 0x33d0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x3120
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3e235
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36510(%rip), %rsi     # 0x74a57
movl $0x14, %edx
callq 0x42990
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36583(%rip), %rsi     # 0x74ae2
movl $0x20, %edx
callq 0x42990
movq -0x20(%rbp), %rdi
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl (%rax), %esi
movl 0xc(%rax), %edx
movl 0x8(%rax), %ecx
movl -0xc(%rbp), %r8d
movl -0x10(%rbp), %r9d
callq 0x53890
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl 0x58(%rdi), %eax
cmpl 0x4(%rcx), %eax
jne 0x3e59d
jmp 0x3e5bc
leaq 0x364bf(%rip), %rdi     # 0x74a63
leaq 0x364d3(%rip), %rsi     # 0x74a7e
movl $0x15d, %edx            # imm = 0x15D
leaq 0x3652f(%rip), %rcx     # 0x74ae6
callq 0x3180
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x34742(%rip), %rsi     # 0x73399
leaq 0x35b0e(%rip), %rdx     # 0x7476c
callq 0x42920
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3cd50
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35ef1(%rip), %rsi     # 0x74b6f
movss 0x32386(%rip), %xmm0    # 0x7100c
callq 0x42ba0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movss %xmm0, -0x18(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
movl -0x14(%rbp), %ecx
movss -0x18(%rbp), %xmm0
callq 0x3cee0
movq -0x8(%rbp), %rdi
leaq 0x3610e(%rip), %rsi     # 0x74dc3
xorps %xmm0, %xmm0
callq 0x42ba0
movq -0x28(%rbp), %rdi
movss %xmm0, 0xe8(%rdi)
movq -0x8(%rbp), %rdi
leaq 0x35ede(%rip), %rsi     # 0x74bb2
movss 0x32330(%rip), %xmm0    # 0x7100c
callq 0x42ba0
movq -0x28(%rbp), %rdi
movss %xmm0, 0x148(%rdi)
movq -0x8(%rbp), %rdi
leaq 0x37bac(%rip), %rsi     # 0x768a4
xorps %xmm0, %xmm0
callq 0x42ba0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movss %xmm0, 0x164(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35e71(%rip), %rsi     # 0x74bb8
movl $0x1, %edx
callq 0x42990
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35e65(%rip), %rsi     # 0x74bc4
movl $0x1, %edx
callq 0x42990
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35e58(%rip), %rsi     # 0x74bcf
xorl %edx, %edx
callq 0x42990
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35e48(%rip), %rsi     # 0x74bd4
xorps %xmm0, %xmm0
callq 0x42c00
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35e36(%rip), %rsi     # 0x74bda
movss 0x32260(%rip), %xmm0    # 0x7100c
callq 0x42c00
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35e24(%rip), %rsi     # 0x74be5
movss 0x32243(%rip), %xmm0    # 0x7100c
callq 0x42c00
movq -0x40(%rbp), %rax
movss %xmm0, -0x20(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x28(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x30(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x3ee00
cmpl $0x0, -0x2c(%rbp)
je 0x3ee00
cmpl $0x0, -0x30(%rbp)
jne 0x3ee0c
leaq 0x35de7(%rip), %rdi     # 0x74bee
callq 0x4c50
movq -0x8(%rbp), %rdi
leaq 0x35e02(%rip), %rsi     # 0x74c19
xorl %edx, %edx
callq 0x42b50
movq -0x50(%rbp), %rdi
movl %eax, -0x34(%rbp)
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movl -0xc(%rbp), %r9d
movl -0x10(%rbp), %r10d
movl -0x14(%rbp), %eax
movss -0x18(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0x20(%rbp), %xmm2
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x302f0
movq -0x8(%rbp), %rdi
leaq 0x35dbe(%rip), %rsi     # 0x74c22
xorps %xmm0, %xmm0
callq 0x42c00
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movss %xmm0, 0xe4(%rcx)
movl -0x34(%rbp), %edx
movl %edx, 0x114(%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35a83(%rip), %rsi     # 0x7493a
movl $0x1, %edx
callq 0x42990
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35d59(%rip), %rsi     # 0x74c28
xorl %edx, %edx
callq 0x42b50
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35d4c(%rip), %rsi     # 0x74c30
xorl %edx, %edx
callq 0x42b50
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35d3f(%rip), %rsi     # 0x74c38
xorl %edx, %edx
callq 0x42b50
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x18(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x20(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x24(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x3ef32
cmpl $0x0, -0x24(%rbp)
je 0x3ef32
cmpl $0x0, -0x28(%rbp)
jne 0x3ef3e
leaq 0x35d05(%rip), %rdi     # 0x74c3e
callq 0x4c50
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0xc(%rbp), %r9d
movl -0x10(%rbp), %r11d
movl -0x14(%rbp), %r10d
movl -0x18(%rbp), %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x4e780
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35993(%rip), %rsi     # 0x7493a
movl $0x1, %edx
callq 0x42990
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x36ead(%rip), %rsi     # 0x75e6f
callq 0x42990
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
subl $0x1, %edx
leaq 0x359dc(%rip), %rsi     # 0x749b7
callq 0x42b50
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x1c(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x20(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x24(%rbp)
movl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3f012
cmpl $0x0, -0x20(%rbp)
je 0x3f012
cmpl $0x0, -0x24(%rbp)
jne 0x3f01e
leaq 0x35c51(%rip), %rdi     # 0x74c6a
callq 0x4c50
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movl -0x10(%rbp), %r9d
movl -0xc(%rbp), %r10d
movl -0x14(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x30ae0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)