LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rsi, -0x8(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x10(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x14(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x18(%rbp)
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3f0a1
cmpl $0x0, -0x10(%rbp)
je 0x3f0a1
cmpl $0x0, -0x18(%rbp)
jne 0x3f0ad
leaq 0x35bf0(%rip), %rdi     # 0x74c98
callq 0x4c50
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
callq 0x46b80
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35bcf(%rip), %rsi     # 0x74cc6
movss 0x320ed(%rip), %xmm0    # 0x711ec
callq 0x42c00
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movss %xmm0, -0xc(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
movss -0xc(%rbp), %xmm0
callq 0x30760
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rcx), %edx
movl %edx, 0x7c(%rdi)
movl 0x8(%rcx), %edx
movl %edx, 0x78(%rdi)
movl 0x10(%rcx), %ecx
movl %ecx, 0x80(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3454e(%rip), %rsi     # 0x736c5
movss 0x35669(%rip), %xmm0    # 0x747e8
callq 0x42c00
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35b3e(%rip), %rsi     # 0x74cd2
movss 0x35648(%rip), %xmm0    # 0x747e4
callq 0x42c00
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35b26(%rip), %rsi     # 0x74cd7
movss 0x31e53(%rip), %xmm0    # 0x7100c
callq 0x42c00
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x36ca1(%rip), %rsi     # 0x75e6f
movl $0x5, %edx
callq 0x42990
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movl (%rax), %esi
movl 0xc(%rax), %edx
movl 0x8(%rax), %ecx
movl 0x10(%rax), %r8d
movl -0x18(%rbp), %r9d
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movss -0x14(%rbp), %xmm2
callq 0x46440
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_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 %rbp
movq %rsp, %rbp
subq $0x500, %rsp            # imm = 0x500
movq %rdi, -0x4e8(%rbp)
movq %rdi, -0x4e0(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x4d8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35a46(%rip), %rsi     # 0x74cdd
callq 0x42ad0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x3f2c2
movq -0x4d8(%rbp), %rax
movl 0x14(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x4d8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4c0(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
movq -0x4d8(%rbp), %rax
movq -0x4e8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movl 0xc(%rax), %ecx
movl 0x8(%rax), %r8d
movl 0x10(%rax), %r9d
movl -0x444(%rbp), %r11d
movl -0x448(%rbp), %r10d
movl -0x440(%rbp), %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x47f20
movq -0x8(%rbp), %rdi
leaq 0x35231(%rip), %rsi     # 0x74576
leaq 0x34dbc(%rip), %rdx     # 0x74108
callq 0x42920
movq %rax, -0x4c8(%rbp)
movq -0x4c8(%rbp), %rdi
callq 0x2d650
movl %eax, %ecx
movq -0x4e8(%rbp), %rax
movl %ecx, -0x4cc(%rbp)
movl -0x4cc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
leaq 0x3433e(%rip), %rsi     # 0x736c5
movss 0x31c7d(%rip), %xmm0    # 0x7100c
callq 0x42ba0
movq -0x4e8(%rbp), %rax
movss %xmm0, 0x134(%rax)
movq -0x8(%rbp), %rdi
leaq 0x35924(%rip), %rsi     # 0x74cd2
movss 0x31c56(%rip), %xmm0    # 0x7100c
callq 0x42ba0
movq -0x4e8(%rbp), %rcx
movq -0x4e0(%rbp), %rax
movss %xmm0, 0x138(%rcx)
addq $0x500, %rsp            # imm = 0x500
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
callq 0x51840
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rcx), %edx
movl %edx, 0x78(%rdi)
movl %edx, 0x6c(%rdi)
movl 0xc(%rcx), %edx
movl %edx, 0x7c(%rdi)
movl %edx, 0x70(%rdi)
movl 0x10(%rcx), %ecx
movl %ecx, 0x80(%rdi)
movl %ecx, 0x74(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x350af(%rip), %rsi     # 0x74576
leaq 0x34c3a(%rip), %rdx     # 0x74108
callq 0x42920
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d650
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
movl -0x14(%rbp), %ecx
callq 0x48530
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rcx), %edx
movl %edx, 0x78(%rdi)
movl %edx, 0x6c(%rdi)
movl 0xc(%rcx), %edx
movl %edx, 0x7c(%rdi)
movl %edx, 0x70(%rdi)
movl 0x10(%rcx), %ecx
movl %ecx, 0x80(%rdi)
movl %ecx, 0x74(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: parse_upsample
layer parse_upsample(list *options, size_params params, network *net)
{

    int stride = option_find_int(options, "stride",2);
    layer l = make_upsample_layer(params.batch, params.w, params.h, params.c, stride);
    l.scale = option_find_float_quiet(options, "scale", 1);
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x353df(%rip), %rsi     # 0x7493a
movl $0x2, %edx
callq 0x42990
movq -0x28(%rbp), %rdi
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl (%rax), %esi
movl 0xc(%rax), %edx
movl 0x8(%rax), %ecx
movl 0x10(%rax), %r8d
movl -0x14(%rbp), %r9d
callq 0x444f0
movq -0x8(%rbp), %rdi
leaq 0x355dd(%rip), %rsi     # 0x74b6f
movss 0x31a72(%rip), %xmm0    # 0x7100c
callq 0x42ba0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movss %xmm0, 0x194(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x35278(%rip), %rsi     # 0x74acf
callq 0x3230
cmpl $0x0, %eax
jne 0x3f86d
movl $0x6, -0x4(%rbp)
jmp 0x3f94a
movq -0x10(%rbp), %rdi
leaq 0x35490(%rip), %rsi     # 0x74d08
callq 0x3230
cmpl $0x0, %eax
jne 0x3f88e
movl $0x3, -0x4(%rbp)
jmp 0x3f94a
movq -0x10(%rbp), %rdi
leaq 0x35474(%rip), %rsi     # 0x74d0d
callq 0x3230
cmpl $0x0, %eax
jne 0x3f8af
movl $0x0, -0x4(%rbp)
jmp 0x3f94a
movq -0x10(%rbp), %rdi
leaq 0x3545c(%rip), %rsi     # 0x74d16
callq 0x3230
cmpl $0x0, %eax
jne 0x3f8cd
movl $0x1, -0x4(%rbp)
jmp 0x3f94a
movq -0x10(%rbp), %rdi
leaq 0x35443(%rip), %rsi     # 0x74d1b
callq 0x3230
cmpl $0x0, %eax
jne 0x3f8eb
movl $0x2, -0x4(%rbp)
jmp 0x3f94a
movq -0x10(%rbp), %rdi
leaq 0x35429(%rip), %rsi     # 0x74d1f
callq 0x3230
cmpl $0x0, %eax
jne 0x3f909
movl $0x5, -0x4(%rbp)
jmp 0x3f94a
movq -0x10(%rbp), %rdi
leaq 0x3546d(%rip), %rsi     # 0x74d81
callq 0x3230
cmpl $0x0, %eax
jne 0x3f927
movl $0x4, -0x4(%rbp)
jmp 0x3f94a
movq 0x436ca(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x353eb(%rip), %rsi     # 0x74d27
movb $0x0, %al
callq 0x3240
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x35706(%rip), %rsi     # 0x7656d
callq 0x3360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x40e80
movq -0x8(%rbp), %rdi
callq 0x4110
movl $0x0, -0x1c(%rbp)
movb $0x0, %al
callq 0x8df0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4140
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x40f7a
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4df0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x40f2a
jmp 0x40ed2
movl -0x34(%rbp), %eax
subl $0x23, %eax
je 0x40f2a
jmp 0x40edc
movl -0x34(%rbp), %eax
subl $0x3b, %eax
je 0x40f2a
jmp 0x40ee6
movl -0x34(%rbp), %eax
subl $0x5b, %eax
jne 0x40f35
jmp 0x40ef0
movl $0x10, %edi
callq 0x32d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8ed0
movb $0x0, %al
callq 0x8df0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x40f75
movq -0x18(%rbp), %rdi
callq 0x3030
jmp 0x40f75
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x427a0
cmpl $0x0, %eax
jne 0x40f73
movq 0x420a6(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq 0x33fde(%rip), %rsi     # 0x74f41
movb $0x0, %al
callq 0x3240
movq -0x18(%rbp), %rdi
callq 0x3030
jmp 0x40f75
jmp 0x40e9a
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xb8(%rax)
je 0x411cf
jmp 0x411cf
movq -0x18(%rbp), %rax
movl 0x5c(%rax), %ecx
movl %ecx, -0xc(%rbp)
movq 0x230(%rax), %rdi
movslq 0x84(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x4125f
movq -0x18(%rbp), %rax
movq 0x240(%rax), %rdi
movslq 0x84(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
movq -0x18(%rbp), %rax
movq 0x2b0(%rax), %rdi
movslq 0x84(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rdi
movslq 0x84(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
movq -0x18(%rbp), %rax
movq 0x250(%rax), %rdi
movslq -0xc(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x230(%rax), %rdi
movslq 0x58(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
movq -0x10(%rbp), %rcx
movq 0x250(%rcx), %rdi
movl 0x58(%rcx), %eax
imull 0x54(%rcx), %eax
movslq %eax, %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x413b1
movq -0x10(%rbp), %rax
movq 0x240(%rax), %rdi
movslq 0x58(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
movq -0x10(%rbp), %rax
movq 0x2b0(%rax), %rdi
movslq 0x58(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
movq -0x10(%rbp), %rax
movq 0x2b8(%rax), %rdi
movslq 0x58(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x3410
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x41a3c
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x41a2f
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x419f0
jmp 0x41a31
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x419e1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x3280
movq -0x18(%rbp), %rdi
callq 0x3030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x230(%rax), %rdi
movslq 0x58(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movq -0x18(%rbp), %rcx
movq 0x250(%rcx), %rdi
movl 0x58(%rcx), %eax
imull 0x54(%rcx), %eax
movslq %eax, %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
cmpl $0x0, -0xc(%rbp)
je 0x41adf
movq -0x18(%rbp), %rax
movq 0x250(%rax), %rdi
movl 0x54(%rax), %esi
movl 0x58(%rax), %edx
callq 0x419b0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x41b4d
movq -0x18(%rbp), %rax
cmpl $0x0, 0x184(%rax)
jne 0x41b4d
movq -0x18(%rbp), %rax
movq 0x240(%rax), %rdi
movslq 0x58(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movq -0x18(%rbp), %rax
movq 0x2b0(%rax), %rdi
movslq 0x58(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rdi
movslq 0x58(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/parser.c
// Function: load_convolutional_weights
void load_convolutional_weights(layer l, FILE *fp)
{
    if(l.binary){
        //load_convolutional_weights_binary(l, fp);
        //return;
    }
    if(l.numload) l.n = l.numload;
    int num = l.c/l.groups*l.n*l.size*l.size;
    fread(l.biases, sizeof(float), l.n, fp);
    if (l.batch_normalize && (!l.dontloadscales)){
        fread(l.scales, sizeof(float), l.n, fp);
        fread(l.rolling_mean, sizeof(float), l.n, fp);
        fread(l.rolling_variance, sizeof(float), l.n, fp);
        if(0){
            int i;
            for(i = 0; i < l.n; ++i){
                printf("%g, ", l.rolling_mean[i]);
            }
            printf("\n");
            for(i = 0; i < l.n; ++i){
                printf("%g, ", l.rolling_variance[i]);
            }
            printf("\n");
        }
        if(0){
            fill_cpu(l.n, 0, l.rolling_mean, 1);
            fill_cpu(l.n, 0, l.rolling_variance, 1);
        }
        if(0){
            int i;
            for(i = 0; i < l.n; ++i){
                printf("%g, ", l.rolling_mean[i]);
            }
            printf("\n");
            for(i = 0; i < l.n; ++i){
                printf("%g, ", l.rolling_variance[i]);
            }
            printf("\n");
        }
    }
    fread(l.weights, sizeof(float), num, fp);
    //if(l.c == 3) scal_cpu(num, 1./256, l.weights, 1);
    if (l.flipped) {
        transpose_matrix(l.weights, l.c*l.size*l.size, l.n);
    }
    //if (l.binary) binarize_weights(l.weights, l.n, l.c*l.size*l.size, l.weights);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xb8(%rax)
je 0x41ddf
jmp 0x41ddf
movq -0x18(%rbp), %rax
cmpl $0x0, 0x188(%rax)
je 0x41dfc
movq -0x18(%rbp), %rax
movl 0x188(%rax), %ecx
movl %ecx, 0x84(%rax)
movq -0x18(%rbp), %rcx
movl 0x74(%rcx), %eax
cltd
idivl 0x8c(%rcx)
movl %eax, %ecx
movq -0x18(%rbp), %rax
imull 0x84(%rax), %ecx
imull 0x90(%rax), %ecx
imull 0x90(%rax), %ecx
movl %ecx, -0xc(%rbp)
movq 0x230(%rax), %rdi
movslq 0x84(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x41ebb
movq -0x18(%rbp), %rax
cmpl $0x0, 0x184(%rax)
jne 0x41ebb
movq -0x18(%rbp), %rax
movq 0x240(%rax), %rdi
movslq 0x84(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movq -0x18(%rbp), %rax
movq 0x2b0(%rax), %rdi
movslq 0x84(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rdi
movslq 0x84(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movq -0x18(%rbp), %rax
movq 0x250(%rax), %rdi
movslq -0xc(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x41f09
movq -0x18(%rbp), %rax
movq 0x250(%rax), %rdi
movl 0x74(%rax), %esi
imull 0x90(%rax), %esi
imull 0x90(%rax), %esi
movl 0x84(%rax), %edx
callq 0x419b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: read_data_cfg
list *read_data_cfg(char *filename)
{
    FILE *file = fopen(filename, "r");
    if(file == 0) file_error(filename);
    char *line;
    int nu = 0;
    list *options = make_list();
    while((line=fgetl(file)) != 0){
        ++ nu;
        strip(line);
        switch(line[0]){
            case '\0':
            case '#':
            case ';':
                free(line);
                break;
            default:
                if(!read_option(line, options)){
                    fprintf(stderr, "Config file error line %d, could parse: %s\n", nu, line);
                    free(line);
                }
                break;
        }
    }
    fclose(file);
    return options;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x33ea6(%rip), %rsi     # 0x7656d
callq 0x3360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x426e0
movq -0x8(%rbp), %rdi
callq 0x4110
movl $0x0, -0x1c(%rbp)
movb $0x0, %al
callq 0x8df0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4140
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4278a
movl -0x1c(%rbp), %eax
incl %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4df0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x4273e
jmp 0x4272a
movl -0x2c(%rbp), %eax
subl $0x23, %eax
je 0x4273e
jmp 0x42734
movl -0x2c(%rbp), %eax
subl $0x3b, %eax
jne 0x42749
jmp 0x4273e
movq -0x18(%rbp), %rdi
callq 0x3030
jmp 0x42785
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x427a0
cmpl $0x0, %eax
jne 0x42783
movq 0x40896(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq 0x327ce(%rip), %rsi     # 0x74f41
movb $0x0, %al
callq 0x3240
movq -0x18(%rbp), %rdi
callq 0x3030
jmp 0x42785
jmp 0x426f2
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: read_option
int read_option(char *s, list *options)
{
    size_t i;
    size_t len = strlen(s);
    char *val = 0;
    for(i = 0; i < len; ++i){
        if(s[i] == '='){
            s[i] = '\0';
            val = s+i+1;
            break;
        }
    }
    if(i == len-1) return 0;
    char *key = s;
    option_insert(options, key, val);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3110
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x42816
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x42806
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x42816
jmp 0x42808
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x427cd
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x42830
movl $0x0, -0x4(%rbp)
jmp 0x42850
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x42a00
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: get_metadata
metadata get_metadata(char *file)
{
    metadata m = {0};
    list *options = read_data_cfg(file);

    char *name_list = option_find_str(options, "names", 0);
    if(!name_list) name_list = option_find_str(options, "labels", 0);
    if(!name_list) {
        fprintf(stderr, "No names or labels found\n");
    } else {
        m.names = get_labels(name_list);
    }
    m.classes = option_find_int(options, "classes", 2);
    free_list(options);
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3190
movq -0x18(%rbp), %rdi
callq 0x426b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x32711(%rip), %rsi     # 0x74fa5
xorl %eax, %eax
movl %eax, %edx
callq 0x42920
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x428c0
movq -0x20(%rbp), %rdi
leaq 0x31a93(%rip), %rsi     # 0x74346
xorl %eax, %eax
movl %eax, %edx
callq 0x42920
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x428e1
movq 0x4072a(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
leaq 0x326d3(%rip), %rsi     # 0x74fab
movb $0x0, %al
callq 0x3240
jmp 0x428ee
movq -0x28(%rbp), %rdi
callq 0x343c0
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x3215e(%rip), %rsi     # 0x74a57
movl $0x2, %edx
callq 0x42990
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8fb0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: option_find_str
char *option_find_str(list *l, char *key, char *def)
{
    char *v = option_find(l, key);
    if(v) return v;
    if(def) fprintf(stderr, "%s: Using default '%s'\n", key, def);
    return def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42ad0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x42956
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x42985
cmpq $0x0, -0x20(%rbp)
je 0x4297d
movq 0x40694(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x32668(%rip), %rsi     # 0x74fde
movb $0x0, %al
callq 0x3240
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: option_find_int
int option_find_int(list *l, char *key, int def)
{
    char *v = option_find(l, key);
    if(v) return atoi(v);
    fprintf(stderr, "%s: Using default '%d'\n", key, def);
    return def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42ad0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x429c9
movq -0x28(%rbp), %rdi
callq 0x33d0
movl %eax, -0x4(%rbp)
jmp 0x429ee
movq 0x40628(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x32615(%rip), %rsi     # 0x74ff6
movb $0x0, %al
callq 0x3240
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: option_insert
void option_insert(list *l, char *key, char *val)
{
    kvp *p = malloc(sizeof(kvp));
    p->key = key;
    p->val = val;
    p->used = 0;
    list_insert(l, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8ed0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: option_unused
void option_unused(list *l)
{
    node *n = l->front;
    while(n){
        kvp *p = (kvp *)n->val;
        if(!p->used){
            fprintf(stderr, "Unused field: '%s = %s'\n", p->key, p->val);
        }
        n = n->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42ac9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x42abb
movq 0x4055d(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x32511(%rip), %rsi     # 0x74fc5
movb $0x0, %al
callq 0x3240
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x42a78
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: option_find
char *option_find(list *l, char *key)
{
    node *n = l->front;
    while(n){
        kvp *p = (kvp *)n->val;
        if(strcmp(p->key, key) == 0){
            p->used = 1;
            return p->val;
        }
        n = n->next;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x42b3a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3230
cmpl $0x0, %eax
jne 0x42b2c
movq -0x28(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x42b42
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x42aec
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/option_list.c
// Function: option_find_float
float option_find_float(list *l, char *key, float def)
{
    char *v = option_find(l, key);
    if(v) return atof(v);
    fprintf(stderr, "%s: Using default '%lf'\n", key, def);
    return def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42ad0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x42c41
movq -0x28(%rbp), %rdi
callq 0x30c0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x42c70
movq 0x403b0(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x323af(%rip), %rsi     # 0x7500e
movb $0x1, %al
callq 0x3240
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/detection_layer.c
// Function: make_detection_layer
detection_layer make_detection_layer(int batch, int inputs, int n, int side, int classes, int coords, int rescore)
{
    detection_layer l = {0};
    l.type = DETECTION;

    l.n = n;
    l.batch = batch;
    l.inputs = inputs;
    l.classes = classes;
    l.coords = coords;
    l.rescore = rescore;
    l.side = side;
    l.w = side;
    l.h = side;
    assert(side*side*((1 + l.coords)*l.n + l.classes) == inputs);
    l.cost = calloc(1, sizeof(float));
    l.outputs = l.inputs;
    l.truths = l.side*l.side*(1+l.coords+l.classes);
    l.output = calloc(batch*l.outputs, sizeof(float));
    l.delta = calloc(batch*l.outputs, sizeof(float));

    l.forward = forward_detection_layer;
    l.backward = backward_detection_layer;

    fprintf(stderr, "Detection Layer\n");
    srand(0);

    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movl %r9d, -0x14(%rbp)
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x20(%rbp), %rdi
movl $0x5, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x84(%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x54(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0xfc(%rdi)
movl 0x10(%rbp), %eax
movl %eax, 0x100(%rdi)
movl 0x18(%rbp), %eax
movl %eax, 0x108(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x94(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x70(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x6c(%rdi)
movl -0x10(%rbp), %eax
imull -0x10(%rbp), %eax
movl 0x100(%rdi), %ecx
addl $0x1, %ecx
imull 0x84(%rdi), %ecx
addl 0xfc(%rdi), %ecx
imull %ecx, %eax
cmpl -0x8(%rbp), %eax
jne 0x42d2c
jmp 0x42d4b
leaq 0x322f9(%rip), %rdi     # 0x7502c
leaq 0x32327(%rip), %rsi     # 0x75061
movl $0x1c, %edx
leaq 0x3232d(%rip), %rcx     # 0x75073
callq 0x3180
movl $0x1, %edi
movl $0x4, %esi
callq 0x3220
movq -0x20(%rbp), %rcx
movq %rax, 0x1d8(%rcx)
movl 0x54(%rcx), %eax
movl %eax, 0x58(%rcx)
movl 0x94(%rcx), %eax
imull 0x94(%rcx), %eax
movl 0x100(%rcx), %edx
addl $0x1, %edx
addl 0xfc(%rcx), %edx
imull %edx, %eax
movl %eax, 0x68(%rcx)
movl -0x4(%rbp), %eax
imull 0x58(%rcx), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x20(%rbp), %rcx
movq %rax, 0x268(%rcx)
movl -0x4(%rbp), %eax
imull 0x58(%rcx), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x260(%rax)
leaq 0x3b(%rip), %rcx        # 0x42e10
movq %rcx, 0x10(%rax)
leaq 0xe30(%rip), %rcx       # 0x43c10
movq %rcx, 0x18(%rax)
movq 0x4020d(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
leaq 0x322c6(%rip), %rsi     # 0x750bb
movb $0x0, %al
callq 0x3240
xorl %edi, %edi
callq 0x31e0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/route_layer.c
// Function: make_route_layer
route_layer make_route_layer(int batch, int n, int *input_layers, int *input_sizes)
{
    fprintf(stderr,"route ");
    route_layer l = {0};
    l.type = ROUTE;
    l.batch = batch;
    l.n = n;
    l.input_layers = input_layers;
    l.input_sizes = input_sizes;
    int i;
    int outputs = 0;
    for(i = 0; i < n; ++i){
        fprintf(stderr," %d", input_layers[i]);
        outputs += input_sizes[i];
    }
    fprintf(stderr, "\n");
    l.outputs = outputs;
    l.inputs = outputs;
    l.delta =  calloc(outputs*batch, sizeof(float));
    l.output = calloc(outputs*batch, sizeof(float));;

    l.forward = forward_route_layer;
    l.backward = backward_route_layer;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x30(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq 0x3f093(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
leaq 0x311b3(%rip), %rsi     # 0x75122
movb $0x0, %al
callq 0x3240
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3190
movq -0x28(%rbp), %rdi
movl $0x8, (%rdi)
movl -0x4(%rbp), %eax
movl %eax, 0x48(%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x84(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x1a8(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x1b0(%rdi)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x4400a
movq 0x3f026(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x32139(%rip), %rsi     # 0x76120
movb $0x0, %al
callq 0x3240
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x43fc3
movq 0x3efe7(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
leaq 0x31d93(%rip), %rsi     # 0x75dae
movb $0x0, %al
callq 0x3240
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, 0x58(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x54(%rax)
movl -0x20(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x260(%rax)
movl -0x20(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3220
movq -0x28(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq %rdx, 0x268(%rcx)
leaq 0x1f(%rip), %rdx        # 0x440a0
movq %rdx, 0x10(%rcx)
leaq 0x124(%rip), %rdx       # 0x441b0
movq %rdx, 0x18(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/route_layer.c
// Function: forward_route_layer
void forward_route_layer(const route_layer l, network net)
{
    int i, j;
    int offset = 0;
    for(i = 0; i < l.n; ++i){
        int index = l.input_layers[i];
        float *input = net.layers[index].output;
        int input_size = l.input_sizes[i];
        for(j = 0; j < l.batch; ++j){
            copy_cpu(input_size, input + j*input_size, 1, l.output + offset + j*l.outputs, 1);
        }
        offset += input_size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x28(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x441a3
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x1a8(%rax), %rdx
movslq -0x4(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
movl %edx, -0x10(%rbp)
movq 0x20(%rcx), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x4a0, %rdx, %rdx      # imm = 0x4A0
addq %rdx, %rcx
movq 0x268(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x1b0(%rax), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x28(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x4418c
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x8(%rbp), %eax
imull -0x1c(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
movq 0x268(%rdx), %rcx
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movl -0x8(%rbp), %eax
imull 0x58(%rdx), %eax
cltq
shlq $0x2, %rax
addq %rax, %rcx
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f960
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4412a
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x440c9
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/route_layer.c
// Function: backward_route_layer
void backward_route_layer(const route_layer l, network net)
{
    int i, j;
    int offset = 0;
    for(i = 0; i < l.n; ++i){
        int index = l.input_layers[i];
        float *delta = net.layers[index].delta;
        int input_size = l.input_sizes[i];
        for(j = 0; j < l.batch; ++j){
            axpy_cpu(input_size, 1, l.delta + offset + j*l.outputs, 1, delta + j*input_size, 1);
        }
        offset += input_size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x28(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x84(%rcx), %eax
jge 0x442bb
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x1a8(%rax), %rdx
movslq -0x4(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
movl %edx, -0x10(%rbp)
movq 0x20(%rcx), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x4a0, %rdx, %rdx      # imm = 0x4A0
addq %rdx, %rcx
movq 0x260(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x1b0(%rax), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x28(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x442a4
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edi
movq 0x260(%rcx), %rsi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x8(%rbp), %eax
imull 0x58(%rcx), %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
imull -0x1c(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rcx
movss 0x2cd81(%rip), %xmm0    # 0x7100c
movl $0x1, %r8d
movl %r8d, %edx
callq 0x2f680
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4423a
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x441d9
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/upsample_layer.c
// Function: forward_upsample_layer
void forward_upsample_layer(const layer l, network net)
{
    fill_cpu(l.outputs*l.batch, 0, l.output, 1);
    if(l.reverse){
        upsample_cpu(l.output, l.out_w, l.out_h, l.c, l.batch, l.stride, 0, l.scale, net.input);
    }else{
        upsample_cpu(net.input, l.w, l.h, l.c, l.batch, l.stride, 1, l.scale, l.output);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movl 0x58(%rax), %edi
imull 0x48(%rax), %edi
movq 0x268(%rax), %rsi
xorps %xmm0, %xmm0
movl $0x1, %edx
callq 0x2f740
movq -0x8(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x4474f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %r10
movq 0x268(%r10), %rdi
movl 0x7c(%r10), %esi
movl 0x78(%r10), %edx
movl 0x74(%r10), %ecx
movl 0x48(%r10), %r8d
movl 0x98(%r10), %r9d
movss 0x194(%r10), %xmm0
movq 0xd8(%rax), %rax
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x300e0
jmp 0x44792
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xd8(%rcx), %rdi
movl 0x70(%rax), %esi
movl 0x6c(%rax), %edx
movl 0x74(%rax), %ecx
movl 0x48(%rax), %r8d
movl 0x98(%rax), %r9d
movss 0x194(%rax), %xmm0
movq 0x268(%rax), %rax
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x300e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/upsample_layer.c
// Function: backward_upsample_layer
void backward_upsample_layer(const layer l, network net)
{
    if(l.reverse){
        upsample_cpu(l.delta, l.out_w, l.out_h, l.c, l.batch, l.stride, 1, l.scale, net.delta);
    }else{
        upsample_cpu(net.delta, l.w, l.h, l.c, l.batch, l.stride, 0, l.scale, l.delta);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4b0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, 0x9c(%rax)
je 0x4480d
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %r10
movq 0x260(%r10), %rdi
movl 0x7c(%r10), %esi
movl 0x78(%r10), %edx
movl 0x74(%r10), %ecx
movl 0x48(%r10), %r8d
movl 0x98(%r10), %r9d
movss 0x194(%r10), %xmm0
movq 0xe8(%rax), %rax
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x300e0
jmp 0x44853
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xe8(%rcx), %rdi
movl 0x70(%rax), %esi
movl 0x6c(%rax), %edx
movl 0x74(%rax), %ecx
movl 0x48(%rax), %r8d
movl 0x98(%rax), %r9d
movss 0x194(%rax), %xmm0
movq 0x260(%rax), %rax
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x300e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)