LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/cost_layer.c
// Function: get_cost_type
COST_TYPE get_cost_type(char *s)
{
    if (strcmp(s, "seg")==0) return SEG;
    if (strcmp(s, "sse")==0) return SSE;
    if (strcmp(s, "masked")==0) return MASKED;
    if (strcmp(s, "smooth")==0) return SMOOTH;
    if (strcmp(s, "L1")==0) return L1;
    if (strcmp(s, "wgan")==0) return WGAN;
    fprintf(stderr, "Couldn't find cost type %s, going with SSE\n", s);
    return SSE;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x253c7(%rip), %rsi     # 0x58ed0
callq 0x3260
testl %eax, %eax
je 0x33b97
leaq 0x253b7(%rip), %rsi     # 0x58ed4
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x33b9e
leaq 0x253a8(%rip), %rsi     # 0x58ed8
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x33ba2
leaq 0x27a09(%rip), %rsi     # 0x5b54c
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x33ba9
cmpb $0x4c, (%rbx)
jne 0x33b60
cmpb $0x31, 0x1(%rbx)
jne 0x33b60
cmpb $0x0, 0x2(%rbx)
je 0x33bb7
leaq 0x2537b(%rip), %rsi     # 0x58ee2
movq %rbx, %rdi
callq 0x3260
movl $0x5, %ebp
testl %eax, %eax
je 0x33bae
movq 0x38479(%rip), %rax     # 0x6bff8
movq (%rax), %rdi
leaq 0x2535e(%rip), %rsi     # 0x58ee7
xorl %ebp, %ebp
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3270
jmp 0x33bae
movl $0x3, %ebp
jmp 0x33bae
xorl %ebp, %ebp
jmp 0x33bae
movl $0x1, %ebp
jmp 0x33bae
movl $0x4, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x2, %ebp
jmp 0x33bae
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/cost_layer.c
// Function: forward_cost_layer
void forward_cost_layer(cost_layer l, network net)
{
    if (!net.truth) return;
    if(l.cost_type == MASKED){
        int i;
        for(i = 0; i < l.batch*l.inputs; ++i){
            if(net.truth[i] == SECRET_NUM) net.input[i] = SECRET_NUM;
        }
    }
    if(l.cost_type == SMOOTH){
        smooth_l1_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    }else if(l.cost_type == L1){
        l1_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    } else {
        l2_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    }
    l.cost[0] = sum_array(l.output, l.batch*l.inputs);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x5a0(%rsp), %rdx
testq %rdx, %rdx
je 0x33ce7
leaq 0x4c0(%rsp), %rax
leaq 0x20(%rsp), %r15
movl 0x8(%r15), %ecx
cmpl $0x1, %ecx
je 0x33c6d
cmpl $0x2, %ecx
je 0x33c43
cmpl $0x4, %ecx
jne 0x33caa
movl 0x54(%r15), %ebx
imull 0x48(%r15), %ebx
movq 0xd8(%rax), %rsi
movq 0x260(%r15), %rcx
movq 0x268(%r15), %r14
movl %ebx, %edi
movq %r14, %r8
callq 0x2a02d
jmp 0x33cd2
movl 0x54(%r15), %ebx
imull 0x48(%r15), %ebx
movq 0xd8(%rax), %rsi
movq 0x260(%r15), %rcx
movq 0x268(%r15), %r14
movl %ebx, %edi
movq %r14, %r8
callq 0x2a0a0
jmp 0x33cd2
movl 0x54(%r15), %ebx
imull 0x48(%r15), %ebx
testl %ebx, %ebx
jle 0x33cb3
movq 0xd8(%rax), %rcx
movl %ebx, %esi
xorl %edi, %edi
movss 0x2523f(%rip), %xmm0    # 0x58ecc
movss (%rdx,%rdi,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0x33ca0
jp 0x33ca0
movl $0xc49a4000, (%rcx,%rdi,4) # imm = 0xC49A4000
incq %rdi
cmpq %rdi, %rsi
jne 0x33c8d
jmp 0x33cb3
movl 0x54(%r15), %ebx
imull 0x48(%r15), %ebx
movq 0xd8(%rax), %rsi
movq 0x260(%r15), %rcx
movq 0x268(%r15), %r14
movl %ebx, %edi
movq %r14, %r8
callq 0x2a253
movq %r14, %rdi
movl %ebx, %esi
callq 0xf5d3
movq 0x1d8(%r15), %rax
movss %xmm0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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), %rdi
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x341af
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 0x34184
movq 0x8(%rbx), %rdi
callq 0x3040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O3/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 0x3423d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edx, %r15d
leaq 0x26bc1(%rip), %r14     # 0x5ada9
xorl %r12d, %r12d
movq %rdi, %rax
incq %rdi
movq %rdi, %r13
movzbl (%r13), %ebp
incq %r13
cmpl $0x2c, %ebp
je 0x34205
testl %ebp, %ebp
jne 0x341f4
movb $0x0, -0x1(%r13)
leaq (%rbx,%r12,4), %rdx
movq %rax, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3320
incq %r12
cmpq %r15, %r12
jae 0x3422f
leaq -0x1(%r13), %rdi
movq %r13, %rax
testb %bpl, %bpl
jne 0x341ee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25011(%rip), %rsi     # 0x5926c
movq %r13, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, 0x4(%rsp)
leaq 0x264af(%rip), %rsi     # 0x5a722
movq %r13, %rdi
movl $0x1, %edx
callq 0x36eed
movq %rax, 0x18(%rsp)
leaq 0x24ef2(%rip), %rsi     # 0x5917e
movq %r13, %rdi
movl $0x1, %edx
callq 0x36eed
movq %rax, 0x10(%rsp)
leaq 0x24ee0(%rip), %rsi     # 0x59185
movq %r13, %rdi
xorl %edx, %edx
callq 0x36eed
movq %rax, 0x8(%rsp)
leaq 0x24a37(%rip), %rsi     # 0x58cf2
leaq 0x244a6(%rip), %rdx     # 0x58768
movq %r13, %rdi
callq 0x36e77
movq %rax, %rdi
callq 0x28746
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 0x34309
leaq 0x24e85(%rip), %rdi     # 0x59189
callq 0xf141
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 0x73a3
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_O3/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 0x24f00(%rip), %rsi     # 0x5926c
movq %r12, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, 0x4(%rsp)
leaq 0x2639e(%rip), %rsi     # 0x5a722
movq %r12, %rdi
movl $0x1, %edx
callq 0x36eed
movq %rax, 0x18(%rsp)
leaq 0x24de1(%rip), %rsi     # 0x5917e
movq %r12, %rdi
movl $0x1, %edx
callq 0x36eed
movq %rax, 0x10(%rsp)
leaq 0x2493c(%rip), %rsi     # 0x58cf2
leaq 0x243ab(%rip), %rdx     # 0x58768
movq %r12, %rdi
callq 0x36e77
movq %rax, %rdi
callq 0x28746
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 0x34405
leaq 0x24db5(%rip), %rdi     # 0x591b5
callq 0xf141
leaq 0x24ddf(%rip), %rsi     # 0x591eb
movq %r12, %rdi
xorl %edx, %edx
callq 0x37008
movl %eax, %ebx
leaq 0x24d66(%rip), %rsi     # 0x59185
movq %r12, %rdi
xorl %edx, %edx
callq 0x37008
movl %eax, %r14d
leaq 0x24dc8(%rip), %rsi     # 0x591fb
movq %r12, %rdi
xorl %edx, %edx
callq 0x37008
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 0x35dd
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_O3/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 0x24bbc(%rip), %rsi     # 0x59256
movq %r14, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, %r15d
leaq 0x24bb4(%rip), %rsi     # 0x59265
movq %r14, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, %ebp
leaq 0x2462b(%rip), %rsi     # 0x58cf2
leaq 0x2409a(%rip), %rdx     # 0x58768
movq %r14, %rdi
callq 0x36e77
movq %rax, %rdi
callq 0x28746
movl %eax, %r12d
leaq 0x24b03(%rip), %rsi     # 0x591eb
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
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 0x7ec3
addq $0x20, %rsp
leaq 0x24643(%rip), %rsi     # 0x58d68
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
movl %eax, 0x44(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24b22(%rip), %rsi     # 0x59274
movq %r14, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, %ebp
leaq 0x2458a(%rip), %rsi     # 0x58cf2
leaq 0x23ff9(%rip), %rdx     # 0x58768
movq %r14, %rdi
callq 0x36e77
movq %rax, %rdi
callq 0x28746
movl %eax, %r15d
leaq 0x24a62(%rip), %rsi     # 0x591eb
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
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 0x7874
addq $0x10, %rsp
leaq 0x245a4(%rip), %rsi     # 0x58d68
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
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_O3/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 0x24a80(%rip), %rsi     # 0x59274
movq %r14, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, %ebp
leaq 0x249e1(%rip), %rsi     # 0x591eb
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
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 0x7aad
leaq 0x23f53(%rip), %rsi     # 0x58793
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
movl %eax, 0x120(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2499e(%rip), %rsi     # 0x59274
movq %r14, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, %ebp
leaq 0x24406(%rip), %rsi     # 0x58cf2
leaq 0x23e75(%rip), %rdx     # 0x58768
movq %r14, %rdi
callq 0x36e77
movq %rax, %rdi
callq 0x28746
movl %eax, %r15d
leaq 0x248de(%rip), %rsi     # 0x591eb
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
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 0x4c3c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x248a4(%rip), %rsi     # 0x59203
movq %r14, %rdi
movl $0x1, %edx
callq 0x37008
movl (%r15), %esi
movl 0x4(%r15), %edx
movq %rbx, %rdi
movl %eax, %ecx
callq 0x2ad58
leaq 0x248f7(%rip), %rsi     # 0x5927b
movss 0x2067c(%rip), %xmm0    # 0x55008
movq %r14, %rdi
callq 0x37065
movss %xmm0, 0x18c(%rbx)
leaq 0x248e4(%rip), %rsi     # 0x59287
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e77
testq %rax, %rax
je 0x349c1
movq %rax, %rdi
callq 0x3efdc
movq %rax, 0x490(%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x6c(%rbx)
movl 0x10(%r15), %eax
movl %eax, 0x74(%rbx)
leaq 0x248b5(%rip), %rsi     # 0x5928c
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x37065
cvttss2si %xmm0, %eax
movl %eax, 0xa4(%rbx)
leaq 0x248a1(%rip), %rsi     # 0x59294
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
movl %eax, 0xf4(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x34a9a
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3140
movl $0x1, %r13d
movl $0x1, %ebp
testl %eax, %eax
jle 0x34a51
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 0x34a3d
movslq %ebp, %r12
movl $0x4, %esi
movq %r12, %rdi
callq 0x3250
movq %rax, %r15
cmpl $0x2, %r12d
cmovgel %ebp, %r13d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x3400
movl %eax, (%r15,%r12,4)
movq %r14, %rdi
movl $0x2c, %esi
callq 0x3150
movq %rax, %r14
incq %r14
incq %r12
cmpq %r12, %r13
jne 0x34a6f
movl %ebp, (%rbx)
jmp 0x34a9d
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_O3/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 0x245db(%rip), %rsi     # 0x5929b
movq %r14, %rdi
movl $0x14, %edx
callq 0x36eed
movl %eax, %ebp
leaq 0x24650(%rip), %rsi     # 0x59326
movq %r14, %rdi
movl $0x20, %edx
callq 0x36eed
movl 0x2c(%rsp), %edx
movl 0x20(%rsp), %esi
movl 0x28(%rsp), %ecx
movq %rbx, %rdi
movl %ebp, %r8d
movl %eax, %r9d
callq 0x90aa
movl 0x58(%rbx), %eax
cmpl 0x24(%rsp), %eax
jne 0x34d0e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x24592(%rip), %rdi     # 0x592a7
leaq 0x245a6(%rip), %rsi     # 0x592c2
leaq 0x24607(%rip), %rcx     # 0x5932a
movl $0x15d, %edx            # imm = 0x15D
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O3/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 0x22829(%rip), %rsi     # 0x57a7f
leaq 0x23c77(%rip), %rdx     # 0x58ed4
movq %r14, %rdi
callq 0x36e77
movq %rax, %rdi
callq 0x33afc
movl %eax, %ebp
leaq 0x2413d(%rip), %rsi     # 0x593b3
movss 0x1fd8a(%rip), %xmm0    # 0x55008
movq %r14, %rdi
callq 0x37065
movl 0x20(%rsp), %esi
movl 0x24(%rsp), %edx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x507f
leaq 0x24368(%rip), %rsi     # 0x59607
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x37065
movss %xmm0, 0xe8(%rbx)
leaq 0x2413d(%rip), %rsi     # 0x593f6
movq %r14, %rdi
movss 0x1fd44(%rip), %xmm0    # 0x55008
callq 0x37065
movss %xmm0, 0x148(%rbx)
leaq 0x25e88(%rip), %rsi     # 0x5b160
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x37065
movss %xmm0, 0x164(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x240ec(%rip), %rsi     # 0x593fc
movq %r14, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, 0x1c(%rsp)
leaq 0x240e0(%rip), %rsi     # 0x59408
movq %r14, %rdi
movl $0x1, %edx
callq 0x36eed
movq %rax, 0x28(%rsp)
leaq 0x240d2(%rip), %rsi     # 0x59413
movq %r14, %rdi
xorl %edx, %edx
callq 0x36eed
movq %rax, 0x20(%rsp)
leaq 0x240c1(%rip), %rsi     # 0x59418
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x370c5
movss %xmm0, 0x18(%rsp)
leaq 0x240af(%rip), %rsi     # 0x5941e
movss 0x1fc91(%rip), %xmm0    # 0x55008
movq %r14, %rdi
callq 0x370c5
movss %xmm0, 0x14(%rsp)
leaq 0x2409d(%rip), %rsi     # 0x59429
movq %r14, %rdi
movss 0x1fc71(%rip), %xmm0    # 0x55008
callq 0x370c5
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 0x353de
leaq 0x24059(%rip), %rdi     # 0x59432
callq 0xf141
leaq 0x24078(%rip), %rsi     # 0x5945d
movq %r14, %rdi
xorl %edx, %edx
callq 0x37008
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 0x46fc
addq $0x10, %rsp
leaq 0x24032(%rip), %rsi     # 0x59466
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x370c5
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_O3/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 0x23d02(%rip), %rsi     # 0x5917e
movq %r12, %rdi
movl $0x1, %edx
callq 0x36eed
movl %eax, 0x4(%rsp)
leaq 0x23fd8(%rip), %rsi     # 0x5946c
movq %r12, %rdi
xorl %edx, %edx
callq 0x37008
movq %rax, 0x10(%rsp)
leaq 0x23fca(%rip), %rsi     # 0x59474
movq %r12, %rdi
xorl %edx, %edx
callq 0x37008
movq %rax, 0x8(%rsp)
leaq 0x23fbc(%rip), %rsi     # 0x5947c
movq %r12, %rdi
xorl %edx, %edx
callq 0x37008
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 0x35504
leaq 0x23f83(%rip), %rdi     # 0x59482
callq 0xf141
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 0x3e9dc
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_O3/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 0x23c21(%rip), %rsi     # 0x5917e
movq %rbx, %rdi
movl $0x1, %edx
callq 0x36eed
leaq 0x251b1(%rip), %rsi     # 0x5a722
movq %rbx, %rdi
movq %rax, 0x8(%rsp)
movl %eax, %edx
callq 0x36eed
movl %eax, %r15d
leal -0x1(%r15), %edx
leaq 0x23c6d(%rip), %rsi     # 0x591fb
movq %rbx, %rdi
callq 0x37008
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 0x355d1
leaq 0x23ee8(%rip), %rdi     # 0x594ae
movq %rax, %r14
callq 0xf141
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 0x48df
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_O3/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 0x35647
leaq 0x23e9a(%rip), %rdi     # 0x594dc
callq 0xf141
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x72d9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23e96(%rip), %rsi     # 0x5950a
movss 0x1fbe8(%rip), %xmm0    # 0x55264
movq %rax, %rdi
callq 0x370c5
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movq %rbx, %rdi
callq 0x4825
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rbx)
movl 0x20(%rsp), %eax
movl %eax, 0x80(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x226f6(%rip), %rsi     # 0x57db6
movss 0x2389c(%rip), %xmm0    # 0x58f64
movq %r14, %rdi
callq 0x370c5
movss %xmm0, 0x14(%rsp)
leaq 0x23e39(%rip), %rsi     # 0x59516
movss 0x23883(%rip), %xmm0    # 0x58f68
movq %r14, %rdi
callq 0x370c5
movss %xmm0, 0x10(%rsp)
leaq 0x23e21(%rip), %rsi     # 0x5951b
movss 0x1f906(%rip), %xmm0    # 0x55008
movq %r14, %rdi
callq 0x370c5
movss %xmm0, 0xc(%rsp)
leaq 0x2500b(%rip), %rsi     # 0x5a722
movq %r14, %rdi
movl $0x5, %edx
callq 0x36eed
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 0x71a4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23d90(%rip), %rsi     # 0x59521
movq %r14, %rdi
callq 0x36fbf
movq %rax, %rdi
callq 0x3400
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 0x761b
addq $0x20, %rsp
leaq 0x234f9(%rip), %rsi     # 0x58cf2
leaq 0x22f8c(%rip), %rdx     # 0x5878c
movq %r14, %rdi
callq 0x36e77
movq %rax, %rdi
callq 0x28746
movl %eax, 0x4(%rbx)
leaq 0x2259c(%rip), %rsi     # 0x57db6
movss 0x1f7e6(%rip), %xmm0    # 0x55008
movq %r14, %rdi
callq 0x37065
movss %xmm0, 0x134(%rbx)
leaq 0x23cdd(%rip), %rsi     # 0x59516
movq %r14, %rdi
movss 0x1f7c4(%rip), %xmm0    # 0x55008
callq 0x37065
movss %xmm0, 0x138(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8cdb
movdqu 0x18(%rsp), %xmm0
movq 0x1c(%rsp), %rax
movq %rax, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq %rax, 0x7c(%rbx)
pshufd $0x34, %xmm0, %xmm0     # xmm0 = xmm0[0,1,3,0]
movdqu %xmm0, 0x6c(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2341a(%rip), %rsi     # 0x58cf2
leaq 0x22ead(%rip), %rdx     # 0x5878c
movq %rax, %rdi
callq 0x36e77
movq %rax, %rdi
callq 0x28746
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movq %rbx, %rdi
movl %eax, %ecx
callq 0x77d2
movdqu 0x18(%rsp), %xmm0
movq 0x1c(%rsp), %rax
movq %rax, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq %rax, 0x7c(%rbx)
pshufd $0x34, %xmm0, %xmm0     # xmm0 = xmm0[0,1,3,0]
movdqu %xmm0, 0x6c(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x237b3(%rip), %rsi     # 0x59313
callq 0x3260
testl %eax, %eax
je 0x35c07
leaq 0x239d8(%rip), %rsi     # 0x5954c
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x35c0e
leaq 0x239c6(%rip), %rsi     # 0x59551
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x35c15
leaq 0x239bc(%rip), %rsi     # 0x5955a
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x35c19
leaq 0x239ae(%rip), %rsi     # 0x5955f
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x35c20
leaq 0x2399f(%rip), %rsi     # 0x59563
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x35c27
leaq 0x239ee(%rip), %rsi     # 0x595c5
movq %rbx, %rdi
callq 0x3260
movl $0x4, %ebp
testl %eax, %eax
je 0x35c2c
movq 0x36409(%rip), %rax     # 0x6bff8
movq (%rax), %rdi
leaq 0x23972(%rip), %rsi     # 0x5956b
xorl %ebp, %ebp
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3270
jmp 0x35c2c
movl $0x6, %ebp
jmp 0x35c2c
movl $0x3, %ebp
jmp 0x35c2c
xorl %ebp, %ebp
jmp 0x35c2c
movl $0x1, %ebp
jmp 0x35c2c
movl $0x2, %ebp
jmp 0x35c2c
movl $0x5, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24c13(%rip), %rsi     # 0x5ae29
callq 0x3390
movq %rax, %rbx
testq %rax, %rax
jne 0x3622b
movq %r14, %rdi
callq 0xe925
xorl %eax, %eax
callq 0x11828
movq %rax, %r14
movq %rbx, %rdi
callq 0xe948
testq %rax, %rax
je 0x362f1
movq %rax, %r13
movl $0x1, %ebp
leaq 0x23530(%rip), %r15     # 0x59785
xorl %r12d, %r12d
movq %r13, %rdi
callq 0xf25f
movzbl (%r13), %eax
cmpl $0x3a, %eax
jg 0x36275
testl %eax, %eax
je 0x362d3
cmpl $0x23, %eax
je 0x362d3
jmp 0x362a9
cmpl $0x3b, %eax
je 0x362d3
cmpl $0x5b, %eax
jne 0x362a9
movl $0x10, %edi
callq 0x3300
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x11881
xorl %eax, %eax
callq 0x11828
movq %rax, 0x8(%r12)
movq %r13, (%r12)
jmp 0x362db
movq 0x8(%r12), %rsi
movq %r13, %rdi
callq 0x36d89
testl %eax, %eax
jne 0x362db
movq 0x35d37(%rip), %rax     # 0x6bff8
movq (%rax), %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x3270
movq %r13, %rdi
callq 0x3040
movq %rbx, %rdi
callq 0xe948
movq %rax, %r13
incl %ebp
testq %rax, %rax
jne 0x36258
movq %rbx, %rdi
callq 0x3130
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_O3/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 0x1068d
movq 0x2a0(%rsp), %rdi
movslq %ebp, %r12
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3440
cmpl $0x0, 0xb0(%rsp)
je 0x363c8
leaq 0x70(%rsp), %r14
movq 0x240(%r14), %rdi
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3440
movq 0x2b0(%r14), %rdi
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3440
movq 0x2b8(%r14), %rdi
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x3440
testl %ebp, %ebp
jle 0x364db
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 0x1ec7a(%rip), %xmm1    # 0x55090
maxss %xmm0, %xmm1
movss %xmm1, 0x14(%rsp)
movl $0x4, %esi
movl $0x1, %edx
leaq 0x14(%rsp), %rdi
movq %rbx, %rcx
callq 0x3440
cmpl $0x8, %r15d
jl 0x364b3
movl $0x1, %r15d
movq 0x8(%rsp), %rax
movl %eax, %r12d
xorl %r14d, %r14d
leaq (,%r14,8), %rax
xorl %edi, %edi
cmpq %r13, %rax
jge 0x3649b
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 0x36483
xorl %esi, %esi
orb %sil, %dl
cmpq $0x6, %rcx
ja 0x36498
leaq (%r15,%rcx), %rsi
incq %rcx
cmpq %r13, %rsi
jl 0x36470
movsbl %dl, %edi
movq %rbx, %rsi
callq 0x31f0
incq %r14
addl $0x8, %r12d
addq $0x8, %r15
cmpq %rbp, %r14
jne 0x3644e
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 0x363f6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3440
cmpl $0x0, 0x40(%r12)
je 0x3656f
movq 0x240(%r12), %rdi
movl $0x4, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3440
movq 0x2b0(%r12), %rdi
movl $0x4, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3440
movq 0x2b8(%r12), %rdi
movl $0x4, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3440
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 0x3440
// File: /workspace/github_c_makefile_star2_O3/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 0x3440
movq 0x270(%rsp), %rdi
movslq 0x74(%rsp), %rdx
imulq %r14, %rdx
movl $0x4, %esi
movq %rbx, %rcx
callq 0x3440
cmpl $0x0, 0x60(%rsp)
je 0x36689
leaq 0x20(%rsp), %r15
movq 0x240(%r15), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3440
movq 0x2b0(%r15), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3440
movq 0x2b8(%r15), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x3440
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3250
movq %rax, %r15
testl %r12d, %r12d
jle 0x36708
movl %r12d, %eax
movl %ebp, %ecx
leaq (,%rcx,4), %rdx
leaq (,%rax,4), %rsi
xorl %edi, %edi
movq %r15, %r8
movq %rbx, %r9
testl %ebp, %ebp
jle 0x366f9
movq %r8, %r10
xorl %r11d, %r11d
movss (%r9,%r11,4), %xmm0
movss %xmm0, (%r10)
incq %r11
addq %rsi, %r10
cmpq %r11, %rcx
jne 0x366e3
incq %rdi
addq %rdx, %r9
addq $0x4, %r8
cmpq %rax, %rdi
jne 0x366d9
shlq $0x2, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x32b0
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O3/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 0x30d0
movq 0x250(%r13), %r15
movslq 0x54(%r13), %r12
movq %r12, %rdx
imulq %r14, %rdx
movl $0x4, %esi
movq %r15, %rdi
movq %rbx, %rcx
callq 0x30d0
testl %ebp, %ebp
je 0x3678e
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x3668f
cmpl $0x0, 0x40(%r13)
je 0x367f2
cmpl $0x0, 0x184(%r13)
jne 0x367f2
movq 0x240(%r13), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30d0
movq 0x2b0(%r13), %rdi
movl $0x4, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x30d0
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 0x30d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq