LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x590(%rsp), %rdx
testq %rdx, %rdx
je 0x31d1e
leaq 0x4b0(%rsp), %rax
leaq 0x10(%rsp), %rbx
movl 0x8(%rbx), %ecx
cmpl $0x4, %ecx
je 0x31c99
cmpl $0x2, %ecx
je 0x31cbc
cmpl $0x1, %ecx
jne 0x31cdf
movl 0x54(%rbx), %edi
imull 0x48(%rbx), %edi
testl %edi, %edi
jle 0x31c8f
movq 0xd8(%rax), %rsi
movl %edi, %edi
xorl %r8d, %r8d
movss 0x2515a(%rip), %xmm0    # 0x56dcc
movss (%rdx,%r8,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x31c87
jp 0x31c87
movl $0xc49a4000, (%rsi,%r8,4) # imm = 0xC49A4000
incq %r8
cmpq %r8, %rdi
jne 0x31c72
cmpl $0x2, %ecx
je 0x31cbc
cmpl $0x4, %ecx
jne 0x31cdf
movl 0x54(%rbx), %edi
imull 0x48(%rbx), %edi
movq 0xd8(%rax), %rsi
movq 0x260(%rbx), %rcx
movq 0x268(%rbx), %r8
callq 0x287e9
jmp 0x31d00
movl 0x54(%rbx), %edi
imull 0x48(%rbx), %edi
movq 0xd8(%rax), %rsi
movq 0x260(%rbx), %rcx
movq 0x268(%rbx), %r8
callq 0x28862
jmp 0x31d00
movl 0x54(%rbx), %edi
imull 0x48(%rbx), %edi
movq 0xd8(%rax), %rsi
movq 0x260(%rbx), %rcx
movq 0x268(%rbx), %r8
callq 0x28a15
movq 0x268(%rbx), %rdi
movl 0x54(%rbx), %esi
imull 0x48(%rbx), %esi
callq 0xedee
movq 0x1d8(%rbx), %rax
movss %xmm0, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x54(%rdi)
movl %esi, 0x58(%rdi)
movq 0x260(%rdi), %rdi
movslq 0x48(%rbx), %rax
movslq %esi, %r14
imulq %r14, %rax
shlq $0x2, %rax
movq %rax, %rsi
callq 0x3360
movq %rax, 0x260(%rbx)
movq 0x268(%rbx), %rdi
movslq 0x48(%rbx), %rsi
imulq %r14, %rsi
shlq $0x2, %rsi
callq 0x3360
movq %rax, 0x268(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x321df
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
testq %r15, %r15
jne 0x321b8
movq 0x8(%rbx), %rdi
callq 0x3040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O1/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
sete %al
testl %edx, %edx
setle %cl
orb %al, %cl
jne 0x3227d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edx, %r15d
leaq 0x26a1c(%rip), %r14     # 0x58c38
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rdi, %rax
incq %rdi
movq %rdi, %rbp
movzbl (%rbp), %ecx
incq %rbp
cmpl $0x2c, %ecx
je 0x3223b
testl %ecx, %ecx
jne 0x3222b
testb %cl, %cl
movl $0x1, %ecx
cmovel %ecx, %r13d
movb $0x0, -0x1(%rbp)
leaq (%rbx,%r12,4), %rdx
movq %rax, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3330
incq %r12
cmpq %r15, %r12
jae 0x3226f
leaq -0x1(%rbp), %rdi
movq %rbp, %rax
testl %r13d, %r13d
je 0x32225
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/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 0x24ed1(%rip), %rsi     # 0x5716c
movq %r13, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, 0x4(%rsp)
leaq 0x26317(%rip), %rsi     # 0x585ca
movq %r13, %rdi
movl $0x1, %edx
callq 0x34d9f
movq %rax, 0x18(%rsp)
leaq 0x24db2(%rip), %rsi     # 0x5707e
movq %r13, %rdi
movl $0x1, %edx
callq 0x34d9f
movq %rax, 0x10(%rsp)
leaq 0x24da0(%rip), %rsi     # 0x57085
movq %r13, %rdi
xorl %edx, %edx
callq 0x34d9f
movq %rax, 0x8(%rsp)
leaq 0x248f7(%rip), %rsi     # 0x56bf2
leaq 0x24396(%rip), %rdx     # 0x56698
movq %r13, %rdi
callq 0x34d5b
movq %rax, %rdi
callq 0x27092
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 0x32349
leaq 0x24d45(%rip), %rdi     # 0x57089
callq 0xe956
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 0x70f9
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_O1/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), %rbx
leaq 0x24dc0(%rip), %rsi     # 0x5716c
movq %r12, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, 0x4(%rsp)
leaq 0x26206(%rip), %rsi     # 0x585ca
movq %r12, %rdi
movl $0x1, %edx
callq 0x34d9f
movq %rax, 0x18(%rsp)
leaq 0x24ca1(%rip), %rsi     # 0x5707e
movq %r12, %rdi
movl $0x1, %edx
callq 0x34d9f
movq %rax, 0x10(%rsp)
leaq 0x247fc(%rip), %rsi     # 0x56bf2
leaq 0x2429b(%rip), %rdx     # 0x56698
movq %r12, %rdi
callq 0x34d5b
movq %rax, %rdi
callq 0x27092
movq %rax, 0x8(%rsp)
movl (%rbx), %eax
movl %eax, (%rsp)
movl 0x8(%rbx), %ebp
movl 0xc(%rbx), %r15d
movl 0x10(%rbx), %r13d
testl %ebp, %ebp
setne %al
testl %r15d, %r15d
setne %cl
andb %al, %cl
testl %r13d, %r13d
setne %al
testb %al, %cl
jne 0x32445
leaq 0x24c75(%rip), %rdi     # 0x570b5
callq 0xe956
leaq 0x24c9f(%rip), %rsi     # 0x570eb
movq %r12, %rdi
xorl %edx, %edx
callq 0x34e93
movl %eax, %ebx
leaq 0x24c26(%rip), %rsi     # 0x57085
movq %r12, %rdi
xorl %edx, %edx
callq 0x34e93
movl %eax, %r14d
leaq 0x24c88(%rip), %rsi     # 0x570fb
movq %r12, %rdi
xorl %edx, %edx
callq 0x34e93
movq 0x18(%rsp), %r11
movl %r11d, %r10d
shrl $0x1f, %r10d
addl %r11d, %r10d
sarl %r10d
testl %r14d, %r14d
cmovel %eax, %r10d
leaq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x70(%rax), %eax
movq 0x20(%rsp), %r14
movq %r14, %rdi
movl (%rsp), %esi
movl %ebp, %edx
movl %r15d, %ecx
movl %r13d, %r8d
movl 0x4(%rsp), %r9d
pushq %rax
pushq %rbx
pushq 0x18(%rsp)
pushq %r10
pushq 0x30(%rsp)
pushq %r11
callq 0x35ed
addq $0x30, %rsp
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/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 0x24a7c(%rip), %rsi     # 0x57156
movq %r14, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, %r15d
leaq 0x24a74(%rip), %rsi     # 0x57165
movq %r14, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, %ebp
leaq 0x244eb(%rip), %rsi     # 0x56bf2
leaq 0x23f8a(%rip), %rdx     # 0x56698
movq %r14, %rdi
callq 0x34d5b
movq %rax, %rdi
callq 0x27092
movl %eax, %r12d
leaq 0x249c3(%rip), %rsi     # 0x570eb
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
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 0x7c22
addq $0x20, %rsp
leaq 0x24503(%rip), %rsi     # 0x56c68
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
movl %eax, 0x44(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x249e2(%rip), %rsi     # 0x57174
movq %r14, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, %ebp
leaq 0x2444a(%rip), %rsi     # 0x56bf2
leaq 0x23ee9(%rip), %rdx     # 0x56698
movq %r14, %rdi
callq 0x34d5b
movq %rax, %rdi
callq 0x27092
movl %eax, %r15d
leaq 0x24922(%rip), %rsi     # 0x570eb
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
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 0x75c6
addq $0x10, %rsp
leaq 0x24464(%rip), %rsi     # 0x56c68
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
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_O1/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 0x24940(%rip), %rsi     # 0x57174
movq %r14, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, %ebp
leaq 0x248a1(%rip), %rsi     # 0x570eb
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
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 0x780c
leaq 0x23e43(%rip), %rsi     # 0x566c3
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
movl %eax, 0x120(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2485e(%rip), %rsi     # 0x57174
movq %r14, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, %ebp
leaq 0x242c6(%rip), %rsi     # 0x56bf2
leaq 0x23d65(%rip), %rdx     # 0x56698
movq %r14, %rdi
callq 0x34d5b
movq %rax, %rdi
callq 0x27092
movl %eax, %r15d
leaq 0x2479e(%rip), %rsi     # 0x570eb
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
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 0x4ab2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/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 0x24764(%rip), %rsi     # 0x57103
movq %r14, %rdi
movl $0x1, %edx
callq 0x34e93
movl (%r15), %esi
movl 0x4(%r15), %edx
movq %rbx, %rdi
movl %eax, %ecx
callq 0x29518
leaq 0x247b7(%rip), %rsi     # 0x5717b
movss 0x2063c(%rip), %xmm0    # 0x53008
movq %r14, %rdi
callq 0x34ead
movss %xmm0, 0x18c(%rbx)
leaq 0x247a4(%rip), %rsi     # 0x57187
movq %r14, %rdi
xorl %edx, %edx
callq 0x34d5b
testq %rax, %rax
je 0x32a01
movq %rax, %rdi
callq 0x3cd97
movq %rax, 0x490(%rbx)
movl 0xc(%r15), %eax
movl %eax, 0x70(%rbx)
movl 0x8(%r15), %eax
movl %eax, 0x6c(%rbx)
movl 0x10(%r15), %eax
movl %eax, 0x74(%rbx)
leaq 0x2476f(%rip), %rsi     # 0x5718c
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x34ead
cvttss2si %xmm0, %eax
movl %eax, 0xa4(%rbx)
leaq 0x2475b(%rip), %rsi     # 0x57194
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
movl %eax, 0xf4(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x32ae0
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3150
movl $0x1, %r13d
movl $0x1, %ebp
testl %eax, %eax
jle 0x32a97
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %edx, %edx
cmpb $0x2c, (%r14,%rcx)
sete %dl
addl %edx, %ebp
incq %rcx
cmpq %rcx, %rax
jne 0x32a83
movslq %ebp, %r12
movl $0x4, %esi
movq %r12, %rdi
callq 0x3260
movq %rax, %r15
cmpl $0x2, %r12d
cmovgel %ebp, %r13d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x3410
movl %eax, (%r15,%r12,4)
movq %r14, %rdi
movl $0x2c, %esi
callq 0x3160
movq %rax, %r14
incq %r14
incq %r12
cmpq %r12, %r13
jne 0x32ab5
movl %ebp, (%rbx)
jmp 0x32ae3
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/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 0x24495(%rip), %rsi     # 0x5719b
movq %r14, %rdi
movl $0x14, %edx
callq 0x34d9f
movl %eax, %ebp
leaq 0x2450a(%rip), %rsi     # 0x57226
movq %r14, %rdi
movl $0x20, %edx
callq 0x34d9f
movl 0x2c(%rsp), %edx
movl 0x20(%rsp), %esi
movl 0x28(%rsp), %ecx
movq %rbx, %rdi
movl %ebp, %r8d
movl %eax, %r9d
callq 0x8ac8
movl 0x58(%rbx), %eax
cmpl 0x24(%rsp), %eax
jne 0x32d54
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2444c(%rip), %rdi     # 0x571a7
leaq 0x24460(%rip), %rsi     # 0x571c2
leaq 0x244c1(%rip), %rcx     # 0x5722a
movl $0x15d, %edx            # imm = 0x15D
callq 0x31c0
// File: /workspace/github_c_makefile_star2_O1/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 0x2270b(%rip), %rsi     # 0x559a7
leaq 0x23b31(%rip), %rdx     # 0x56dd4
movq %r14, %rdi
callq 0x34d5b
movq %rax, %rdi
callq 0x31b3c
movl %eax, %ebp
leaq 0x23ff7(%rip), %rsi     # 0x572b3
movss 0x1fd44(%rip), %xmm0    # 0x53008
movq %r14, %rdi
callq 0x34ead
movl 0x20(%rsp), %esi
movl 0x24(%rsp), %edx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x4df7
leaq 0x24222(%rip), %rsi     # 0x57507
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x34ead
movss %xmm0, 0xe8(%rbx)
leaq 0x23ff7(%rip), %rsi     # 0x572f6
movq %r14, %rdi
movss 0x1fcfe(%rip), %xmm0    # 0x53008
callq 0x34ead
movss %xmm0, 0x148(%rbx)
leaq 0x25cea(%rip), %rsi     # 0x59008
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x34ead
movss %xmm0, 0x164(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23fa6(%rip), %rsi     # 0x572fc
movq %r14, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, 0x1c(%rsp)
leaq 0x23f9a(%rip), %rsi     # 0x57308
movq %r14, %rdi
movl $0x1, %edx
callq 0x34d9f
movq %rax, 0x28(%rsp)
leaq 0x23f8c(%rip), %rsi     # 0x57313
movq %r14, %rdi
xorl %edx, %edx
callq 0x34d9f
movq %rax, 0x20(%rsp)
leaq 0x23f7b(%rip), %rsi     # 0x57318
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x34ed2
movss %xmm0, 0x18(%rsp)
leaq 0x23f69(%rip), %rsi     # 0x5731e
movss 0x1fc4b(%rip), %xmm0    # 0x53008
movq %r14, %rdi
callq 0x34ed2
movss %xmm0, 0x14(%rsp)
leaq 0x23f57(%rip), %rsi     # 0x57329
movq %r14, %rdi
movss 0x1fc2b(%rip), %xmm0    # 0x53008
callq 0x34ed2
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 0x33424
leaq 0x23f13(%rip), %rdi     # 0x57332
callq 0xe956
leaq 0x23f32(%rip), %rsi     # 0x5735d
movq %r14, %rdi
xorl %edx, %edx
callq 0x34e93
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 0x4588
addq $0x10, %rsp
leaq 0x23eec(%rip), %rsi     # 0x57366
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x34ed2
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_O1/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 $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x23bbc(%rip), %rsi     # 0x5707e
movq %r12, %rdi
movl $0x1, %edx
callq 0x34d9f
movl %eax, 0x4(%rsp)
leaq 0x23e92(%rip), %rsi     # 0x5736c
movq %r12, %rdi
xorl %edx, %edx
callq 0x34e93
movq %rax, 0x10(%rsp)
leaq 0x23e84(%rip), %rsi     # 0x57374
movq %r12, %rdi
xorl %edx, %edx
callq 0x34e93
movq %rax, 0x8(%rsp)
leaq 0x23e76(%rip), %rsi     # 0x5737c
movq %r12, %rdi
xorl %edx, %edx
callq 0x34e93
movl %eax, %r12d
movl 0x50(%rsp), %ebp
movl 0x58(%rsp), %r13d
movl 0x5c(%rsp), %r14d
movl 0x60(%rsp), %r15d
testl %r13d, %r13d
setne %al
testl %r14d, %r14d
setne %cl
andb %al, %cl
testl %r15d, %r15d
setne %al
testb %al, %cl
jne 0x3354a
leaq 0x23e3d(%rip), %rdi     # 0x57382
callq 0xe956
subq $0x8, %rsp
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %r13d, %ecx
movl %r15d, %r8d
movl 0xc(%rsp), %r9d
pushq %r12
pushq 0x18(%rsp)
pushq 0x28(%rsp)
callq 0x3c74c
addq $0x20, %rsp
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x23adb(%rip), %rsi     # 0x5707e
movq %rbx, %rdi
movl $0x1, %edx
callq 0x34d9f
leaq 0x25013(%rip), %rsi     # 0x585ca
movq %rbx, %rdi
movq %rax, 0x8(%rsp)
movl %eax, %edx
callq 0x34d9f
movl %eax, %r15d
leal -0x1(%r15), %edx
leaq 0x23b27(%rip), %rsi     # 0x570fb
movq %rbx, %rdi
callq 0x34e93
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 0x33617
leaq 0x23da2(%rip), %rdi     # 0x573ae
movq %rax, %r14
callq 0xe956
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 0x476b
addq $0x10, %rsp
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_avgpool
avgpool_layer parse_avgpool(list *options, size_params params)
{
    int batch,w,h,c;
    w = params.w;
    h = params.h;
    c = params.c;
    batch=params.batch;
    if(!(h && w && c)) error("Layer before avgpool layer must output image.");

    avgpool_layer layer = make_avgpool_layer(batch,w,h,c);
    return layer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x3c(%rsp), %ebp
movl 0x30(%rsp), %r12d
movl 0x38(%rsp), %r14d
movl 0x40(%rsp), %r15d
testl %r14d, %r14d
setne %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
testl %r15d, %r15d
setne %al
testb %al, %cl
jne 0x3368d
leaq 0x23d54(%rip), %rdi     # 0x573dc
callq 0xe956
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x702f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_dropout
dropout_layer parse_dropout(list *options, size_params params)
{
    float probability = option_find_float(options, "probability", .5);
    dropout_layer layer = make_dropout_layer(params.batch, params.inputs, probability);
    layer.out_w = params.w;
    layer.out_h = params.h;
    layer.out_c = params.c;
    return layer;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x23d50(%rip), %rsi     # 0x5740a
movss 0x1fb72(%rip), %xmm0    # 0x53234
movq %rax, %rdi
callq 0x34ed2
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movq %rbx, %rdi
callq 0x46b1
movl 0x1c(%rsp), %eax
movl %eax, 0x7c(%rbx)
movl 0x18(%rsp), %eax
movl %eax, 0x78(%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x80(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_normalization
layer parse_normalization(list *options, size_params params)
{
    float alpha = option_find_float(options, "alpha", .0001);
    float beta =  option_find_float(options, "beta" , .75);
    float kappa = option_find_float(options, "kappa", 1);
    int size = option_find_int(options, "size", 5);
    layer l = make_normalization_layer(params.batch, params.w, params.h, params.c, size, alpha, beta, kappa);
    return l;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x225d3(%rip), %rsi     # 0x55cde
movss 0x23751(%rip), %xmm0    # 0x56e64
movq %r14, %rdi
callq 0x34ed2
movss %xmm0, 0x14(%rsp)
leaq 0x23cee(%rip), %rsi     # 0x57416
movss 0x23738(%rip), %xmm0    # 0x56e68
movq %r14, %rdi
callq 0x34ed2
movss %xmm0, 0x10(%rsp)
leaq 0x23cd6(%rip), %rsi     # 0x5741b
movss 0x1f8bb(%rip), %xmm0    # 0x53008
movq %r14, %rdi
callq 0x34ed2
movss %xmm0, 0xc(%rsp)
leaq 0x24e68(%rip), %rsi     # 0x585ca
movq %r14, %rdi
movl $0x5, %edx
callq 0x34d9f
movl 0x3c(%rsp), %edx
movl 0x30(%rsp), %esi
movl 0x38(%rsp), %ecx
movl 0x40(%rsp), %r8d
movq %rbx, %rdi
movl %eax, %r9d
movss 0x14(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
callq 0x6efa
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_shortcut
layer parse_shortcut(list *options, size_params params, network *net)
{
    char *l = option_find(options, "from");
    int index = atoi(l);
    if(index < 0) index = params.index + index;

    int batch = params.batch;
    layer from = net->layers[index];

    layer s = make_shortcut_layer(batch, index, params.w, params.h, params.c, from.out_w, from.out_h, from.out_c);

    char *activation_s = option_find_str(options, "activation", "linear");
    ACTIVATION activation = get_activation(activation_s);
    s.activation = activation;
    s.alpha = option_find_float_quiet(options, "alpha", 1);
    s.beta = option_find_float_quiet(options, "beta", 1);
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x23c45(%rip), %rsi     # 0x57421
movq %r14, %rdi
callq 0x34e40
movq %rax, %rdi
callq 0x3410
movl %eax, %ecx
sarl $0x1f, %ecx
andl 0x34(%rsp), %ecx
addl %eax, %ecx
movq 0x20(%r15), %rax
movslq %ecx, %rdx
imulq $0x4a0, %rdx, %rcx      # imm = 0x4A0
movl 0x78(%rax,%rcx), %r10d
movl 0x7c(%rax,%rcx), %r11d
movl 0x80(%rax,%rcx), %eax
movl 0x2c(%rsp), %ecx
movl 0x20(%rsp), %esi
movl 0x28(%rsp), %r8d
movl 0x30(%rsp), %r9d
subq $0x8, %rsp
movq %rbx, %rdi
pushq %rax
pushq %r10
pushq %r11
callq 0x7371
addq $0x20, %rsp
leaq 0x233ae(%rip), %rsi     # 0x56bf2
leaq 0x22e71(%rip), %rdx     # 0x566bc
movq %r14, %rdi
callq 0x34d5b
movq %rax, %rdi
callq 0x27092
movl %eax, 0x4(%rbx)
leaq 0x22479(%rip), %rsi     # 0x55cde
movss 0x1f79b(%rip), %xmm0    # 0x53008
movq %r14, %rdi
callq 0x34ead
movss %xmm0, 0x134(%rbx)
leaq 0x23b92(%rip), %rsi     # 0x57416
movq %r14, %rdi
movss 0x1f779(%rip), %xmm0    # 0x53008
callq 0x34ead
movss %xmm0, 0x138(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_l2norm
layer parse_l2norm(list *options, size_params params)
{
    layer l = make_l2norm_layer(params.batch, params.inputs);
    l.h = l.out_h = params.h;
    l.w = l.out_w = params.w;
    l.c = l.out_c = params.c;
    return l;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x886b
movl 0x18(%rsp), %eax
movl %eax, 0x78(%rbx)
movl %eax, 0x6c(%rbx)
movl 0x1c(%rsp), %eax
movl %eax, 0x7c(%rbx)
movl %eax, 0x70(%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x80(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_logistic
layer parse_logistic(list *options, size_params params)
{
    layer l = make_logistic_layer(params.batch, params.inputs);
    l.h = l.out_h = params.h;
    l.w = l.out_w = params.w;
    l.c = l.out_c = params.c;
    return l;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x746b
movl 0x18(%rsp), %eax
movl %eax, 0x78(%rbx)
movl %eax, 0x6c(%rbx)
movl 0x1c(%rsp), %eax
movl %eax, 0x7c(%rbx)
movl %eax, 0x70(%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x80(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_activation
layer parse_activation(list *options, size_params params)
{
    char *activation_s = option_find_str(options, "activation", "linear");
    ACTIVATION activation = get_activation(activation_s);

    layer l = make_activation_layer(params.batch, params.inputs, activation);

    l.h = l.out_h = params.h;
    l.w = l.out_w = params.w;
    l.c = l.out_c = params.c;

    return l;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x232d1(%rip), %rsi     # 0x56bf2
leaq 0x22d94(%rip), %rdx     # 0x566bc
movq %rax, %rdi
callq 0x34d5b
movq %rax, %rdi
callq 0x27092
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movq %rbx, %rdi
movl %eax, %ecx
callq 0x7528
movl 0x18(%rsp), %eax
movl %eax, 0x78(%rbx)
movl %eax, 0x6c(%rbx)
movl 0x1c(%rsp), %eax
movl %eax, 0x7c(%rbx)
movl %eax, 0x70(%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x80(%rbx)
movl %eax, 0x74(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: get_policy
learning_rate_policy get_policy(char *s)
{
    if (strcmp(s, "random")==0) return RANDOM;
    if (strcmp(s, "poly")==0) return POLY;
    if (strcmp(s, "constant")==0) return CONSTANT;
    if (strcmp(s, "step")==0) return STEP;
    if (strcmp(s, "exp")==0) return EXP;
    if (strcmp(s, "sigmoid")==0) return SIG;
    if (strcmp(s, "steps")==0) return STEPS;
    fprintf(stderr, "Couldn't find policy %s, going with constant\n", s);
    return CONSTANT;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2366b(%rip), %rsi     # 0x57213
callq 0x3270
testl %eax, %eax
je 0x33c4f
leaq 0x23890(%rip), %rsi     # 0x5744c
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
je 0x33c56
leaq 0x2387e(%rip), %rsi     # 0x57451
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
je 0x33c5d
leaq 0x23874(%rip), %rsi     # 0x5745a
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
je 0x33c61
leaq 0x23866(%rip), %rsi     # 0x5745f
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
je 0x33c68
leaq 0x23857(%rip), %rsi     # 0x57463
movq %rbx, %rdi
callq 0x3270
testl %eax, %eax
je 0x33c6f
leaq 0x238a6(%rip), %rsi     # 0x574c5
movq %rbx, %rdi
callq 0x3270
movl $0x4, %ebp
testl %eax, %eax
je 0x33c74
movq 0x363c1(%rip), %rax     # 0x69ff8
movq (%rax), %rdi
leaq 0x2382a(%rip), %rsi     # 0x5746b
xorl %ebp, %ebp
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3280
jmp 0x33c74
movl $0x6, %ebp
jmp 0x33c74
movl $0x3, %ebp
jmp 0x33c74
xorl %ebp, %ebp
jmp 0x33c74
movl $0x1, %ebp
jmp 0x33c74
movl $0x2, %ebp
jmp 0x33c74
movl $0x5, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: read_cfg
list *read_cfg(char *filename)
{
    FILE *file = fopen(filename, "r");
    if(file == 0) file_error(filename);
    char *line;
    int nu = 0;
    list *options = make_list();
    section *current = 0;
    while((line=fgetl(file)) != 0){
        ++ nu;
        strip(line);
        switch(line[0]){
            case '[':
                current = malloc(sizeof(section));
                list_insert(options, current);
                current->options = make_list();
                current->type = line;
                break;
            case '\0':
            case '#':
            case ';':
                free(line);
                break;
            default:
                if(!read_option(line, current->options)){
                    fprintf(stderr, "Config file error line %d, could parse: %s\n", nu, line);
                    free(line);
                }
                break;
        }
    }
    fclose(file);
    return options;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x24a73(%rip), %rsi     # 0x58cd1
callq 0x33a0
movq %rax, %rbx
testq %rax, %rax
jne 0x34273
movq %r14, %rdi
callq 0xe142
xorl %eax, %eax
callq 0x10ea0
movq %rax, %r14
movq %rbx, %rdi
callq 0xe165
testq %rax, %rax
je 0x34339
movq %rax, %r13
movl $0x1, %ebp
leaq 0x233e8(%rip), %r15     # 0x57685
xorl %r12d, %r12d
movq %r13, %rdi
callq 0xea74
movzbl (%r13), %eax
cmpl $0x3a, %eax
jg 0x342bd
testl %eax, %eax
je 0x3431b
cmpl $0x23, %eax
je 0x3431b
jmp 0x342f1
cmpl $0x3b, %eax
je 0x3431b
cmpl $0x5b, %eax
jne 0x342f1
movl $0x10, %edi
callq 0x3310
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x10ef9
xorl %eax, %eax
callq 0x10ea0
movq %rax, 0x8(%r12)
movq %r13, (%r12)
jmp 0x34323
movq 0x8(%r12), %rsi
movq %r13, %rdi
callq 0x34c71
testl %eax, %eax
jne 0x34323
movq 0x35cef(%rip), %rax     # 0x69ff8
movq (%rax), %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x3280
movq %r13, %rdi
callq 0x3040
movq %rbx, %rdi
callq 0xe165
movq %rax, %r13
incl %ebp
testq %rax, %rax
jne 0x342a0
movq %rbx, %rdi
callq 0x3140
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_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: save_convolutional_weights_binary
void save_convolutional_weights_binary(layer l, FILE *fp)
{
    binarize_weights(l.weights, l.n, l.c*l.size*l.size, l.binary_weights);
    int size = l.c*l.size*l.size;
    int i, j, k;
    fwrite(l.biases, sizeof(float), l.n, fp);
    if (l.batch_normalize){
        fwrite(l.scales, sizeof(float), l.n, fp);
        fwrite(l.rolling_mean, sizeof(float), l.n, fp);
        fwrite(l.rolling_variance, sizeof(float), l.n, fp);
    }
    for(i = 0; i < l.n; ++i){
        float mean = l.binary_weights[i*size];
        if(mean < 0) mean = -mean;
        fwrite(&mean, sizeof(float), 1, fp);
        for(j = 0; j < size/8; ++j){
            int index = i*size + j*8;
            unsigned char c = 0;
            for(k = 0; k < 8; ++k){
                if (j*8 + k >= size) break;
                if (l.binary_weights[index + k] > 0) c = (c | 1<<k);
            }
            fwrite(&c, sizeof(char), 1, fp);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x2c0(%rsp), %rdi
movl 0xf4(%rsp), %ebp
movl 0x100(%rsp), %eax
movl 0xe4(%rsp), %r15d
imull %eax, %r15d
imull %eax, %r15d
movq 0x298(%rsp), %rcx
movl %ebp, %esi
movl %r15d, %edx
movq %rcx, 0x18(%rsp)
callq 0xfdc5
movq 0x2a0(%rsp), %rdi
movslq %ebp, %r12
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3450
cmpl $0x0, 0xb0(%rsp)
je 0x34410
leaq 0x70(%rsp), %r14
movq 0x240(%r14), %rdi
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3450
movq 0x2b0(%r14), %rdi
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3450
movq 0x2b8(%r14), %rdi
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3450
testl %ebp, %ebp
jle 0x34523
leal 0x7(%r15), %ebp
testl %r15d, %r15d
cmovnsl %r15d, %ebp
sarl $0x3, %ebp
movslq %r15d, %r13
movq $0x0, 0x8(%rsp)
xorl %ecx, %ecx
movq %r15, 0x28(%rsp)
movq %r12, 0x20(%rsp)
movq %rcx, 0x30(%rsp)
movq %rcx, %rax
imulq %r13, %rax
movq 0x18(%rsp), %rcx
movss (%rcx,%rax,4), %xmm0
movaps %xmm0, %xmm1
xorps 0x1ecf2(%rip), %xmm1    # 0x53150
maxss %xmm0, %xmm1
movss %xmm1, 0x14(%rsp)
movl $0x4, %esi
movl $0x1, %edx
leaq 0x14(%rsp), %rdi
movq %rbx, %rcx
callq 0x3450
cmpl $0x8, %r15d
jl 0x344fb
movl $0x1, %r15d
movq 0x8(%rsp), %rax
movl %eax, %r12d
xorl %r14d, %r14d
leaq (,%r14,8), %rax
xorl %edi, %edi
cmpq %r13, %rax
jge 0x344e3
movl %r12d, %eax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorps %xmm1, %xmm1
movl $0x1, %esi
shll %cl, %esi
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
ja 0x344cb
xorl %esi, %esi
orb %sil, %dl
cmpq $0x6, %rcx
ja 0x344e0
leaq (%r15,%rcx), %rsi
incq %rcx
cmpq %r13, %rsi
jl 0x344b8
movsbl %dl, %edi
movq %rbx, %rsi
callq 0x3200
incq %r14
addl $0x8, %r12d
addq $0x8, %r15
cmpq %rbp, %r14
jne 0x34496
movq 0x30(%rsp), %rcx
incq %rcx
movq 0x28(%rsp), %r15
movq 0x8(%rsp), %rax
addl %r15d, %eax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %r12
cmpq %r12, %rcx
jne 0x3443e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: save_convolutional_weights
void save_convolutional_weights(layer l, FILE *fp)
{
    if(l.binary){
        //save_convolutional_weights_binary(l, fp);
        //return;
    }
    int num = l.nweights;
    fwrite(l.biases, sizeof(float), l.n, fp);
    if (l.batch_normalize){
        fwrite(l.scales, sizeof(float), l.n, fp);
        fwrite(l.rolling_mean, sizeof(float), l.n, fp);
        fwrite(l.rolling_variance, sizeof(float), l.n, fp);
    }
    fwrite(l.weights, sizeof(float), num, fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movslq 0x5c(%r12), %r14
movq 0x230(%r12), %rdi
movslq 0x84(%r12), %r15
movl $0x4, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3450
cmpl $0x0, 0x40(%r12)
je 0x345b7
movq 0x240(%r12), %rdi
movl $0x4, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3450
movq 0x2b0(%r12), %rdi
movl $0x4, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3450
movq 0x2b8(%r12), %rdi
movl $0x4, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3450
movq 0x250(%r12), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3450
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: save_connected_weights
void save_connected_weights(layer l, FILE *fp)
{
    fwrite(l.biases, sizeof(float), l.outputs, fp);
    fwrite(l.weights, sizeof(float), l.outputs*l.inputs, fp);
    if (l.batch_normalize){
        fwrite(l.scales, sizeof(float), l.outputs, fp);
        fwrite(l.rolling_mean, sizeof(float), l.outputs, fp);
        fwrite(l.rolling_variance, sizeof(float), l.outputs, fp);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x250(%rsp), %rdi
movslq 0x78(%rsp), %r14
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3450
movq 0x270(%rsp), %rdi
movslq 0x74(%rsp), %rdx
imulq %r14, %rdx
movl $0x4, %esi
movq %rbx, %rcx
callq 0x3450
cmpl $0x0, 0x60(%rsp)
je 0x346d1
leaq 0x20(%rsp), %r15
movq 0x240(%r15), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3450
movq 0x2b0(%r15), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3450
movq 0x2b8(%r15), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x3450
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: transpose_matrix
void transpose_matrix(float *a, int rows, int cols)
{
    float *transpose = calloc(rows*cols, sizeof(float));
    int x, y;
    for(x = 0; x < rows; ++x){
        for(y = 0; y < cols; ++y){
            transpose[y*rows + x] = a[x*cols + y];
        }
    }
    memcpy(a, transpose, rows*cols*sizeof(float));
    free(transpose);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
movl %edx, %eax
imull %esi, %eax
movslq %eax, %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x3260
movq %rax, %r15
testl %r12d, %r12d
jle 0x34750
movl %ebp, %eax
movl %r12d, %ecx
leaq (,%rax,4), %rdx
leaq (,%rcx,4), %rsi
xorl %edi, %edi
movq %r15, %r8
movq %rbx, %r9
testl %ebp, %ebp
jle 0x34741
movq %r8, %r10
xorl %r11d, %r11d
movss (%r9,%r11,4), %xmm0
movss %xmm0, (%r10)
incq %r11
addq %rsi, %r10
cmpq %r11, %rax
jne 0x3472b
incq %rdi
addq %rdx, %r9
addq $0x4, %r8
cmpq %rcx, %rdi
jne 0x34721
shlq $0x2, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x32c0
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: load_connected_weights
void load_connected_weights(layer l, FILE *fp, int transpose)
{
    fread(l.biases, sizeof(float), l.outputs, fp);
    fread(l.weights, sizeof(float), l.outputs*l.inputs, fp);
    if(transpose){
        transpose_matrix(l.weights, l.inputs, l.outputs);
    }
    //printf("Biases: %f mean %f variance\n", mean_array(l.biases, l.outputs), variance_array(l.biases, l.outputs));
    //printf("Weights: %f mean %f variance\n", mean_array(l.weights, l.outputs*l.inputs), variance_array(l.weights, l.outputs*l.inputs));
    if (l.batch_normalize && (!l.dontloadscales)){
        fread(l.scales, sizeof(float), l.outputs, fp);
        fread(l.rolling_mean, sizeof(float), l.outputs, fp);
        fread(l.rolling_variance, sizeof(float), l.outputs, fp);
        //printf("Scales: %f mean %f variance\n", mean_array(l.scales, l.outputs), variance_array(l.scales, l.outputs));
        //printf("rolling_mean: %f mean %f variance\n", mean_array(l.rolling_mean, l.outputs), variance_array(l.rolling_mean, l.outputs));
        //printf("rolling_variance: %f mean %f variance\n", mean_array(l.rolling_variance, l.outputs), variance_array(l.rolling_variance, l.outputs));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movq 0x230(%r13), %rdi
movslq 0x58(%r13), %r14
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30e0
movq 0x250(%r13), %r15
movslq 0x54(%r13), %r12
movq %r12, %rdx
imulq %r14, %rdx
movl $0x4, %esi
movq %r15, %rdi
movq %rbx, %rcx
callq 0x30e0
testl %ebp, %ebp
je 0x347d6
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x346d7
cmpl $0x0, 0x40(%r13)
je 0x3483a
cmpl $0x0, 0x184(%r13)
jne 0x3483a
movq 0x240(%r13), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30e0
movq 0x2b0(%r13), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30e0
movq 0x2b8(%r13), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq