LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/rnn.c
// Function: get_rnn_data
float_pair get_rnn_data(unsigned char *text, size_t *offsets, int characters, size_t len, int batch, int steps)
{
    float *x = calloc(batch * steps * characters, sizeof(float));
    float *y = calloc(batch * steps * characters, sizeof(float));
    int i,j;
    for(i = 0; i < batch; ++i){
        for(j = 0; j < steps; ++j){
            unsigned char curr = text[(offsets[i])%len];
            unsigned char next = text[(offsets[i] + 1)%len];

            x[(j*batch + i)*characters + curr] = 1;
            y[(j*batch + i)*characters + next] = 1;

            offsets[i] = (offsets[i] + 1) % len;

            if(curr > 255 || curr <= 0 || next > 255 || next <= 0){
                /*text[(index+j+2)%len] = 0;
                printf("%ld %d %d %d %d\n", index, j, len, (int)text[index+j], (int)text[index+j+1]);
                printf("%s", text+index);
                */
                error("Bad char");
            }
        }
    }
    float_pair p;
    p.x = x;
    p.y = y;
    return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %r8d, %eax
movl %edx, 0x18(%rsp)
imull %edx, %eax
movl %eax, 0x1c(%rsp)
movl %r9d, 0xc(%rsp)
imull %r9d, %eax
movslq %eax, %rbp
movl $0x4, %esi
movq %rbp, %rdi
callq 0x3250
movq %rax, 0x20(%rsp)
movl $0x4, %esi
movq %rbp, %rdi
callq 0x3250
movq %rax, %r9
testl %ebx, %ebx
jle 0x4990e
movl %ebx, %eax
movq %rax, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x3f800000, %r10d      # imm = 0x3F800000
xorl %r13d, %r13d
movq %r12, 0x30(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x498f2
movq 0x10(%rsp), %rax
movl %eax, %ebp
movl 0xc(%rsp), %ebx
movq (%r15,%r13,8), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r14
movzbl (%r12,%rdx), %esi
testl %esi, %esi
setne %dil
incq %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r14
movzbl (%r12,%rdx), %eax
testl %eax, %eax
setne %cl
addl %ebp, %esi
movslq %esi, %rsi
movq 0x20(%rsp), %r8
movl %r10d, (%r8,%rsi,4)
addl %ebp, %eax
cltq
movl %r10d, (%r9,%rax,4)
movq %rdx, (%r15,%r13,8)
testb %cl, %dil
jne 0x498ea
leaq 0x111d2(%rip), %rdi     # 0x5aa9a
movq %r15, %r12
movq %r14, %r15
movq %r9, %r14
callq 0xf141
movl $0x3f800000, %r10d      # imm = 0x3F800000
movq %r14, %r9
movq %r15, %r14
movq %r12, %r15
movq 0x30(%rsp), %r12
addl 0x1c(%rsp), %ebp
decl %ebx
jne 0x49876
incq %r13
movq 0x10(%rsp), %rax
addl 0x18(%rsp), %eax
movq %rax, 0x10(%rsp)
cmpq 0x28(%rsp), %r13
jne 0x49860
movq 0x20(%rsp), %rax
movq %r9, %rdx
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/regressor.c
// Function: predict_regressor
void predict_regressor(char *cfgfile, char *weightfile, char *filename)
{
    network *net = load_network(cfgfile, weightfile, 0);
    set_batch_network(net, 1);
    srand(2222222);

    clock_t time;
    char buff[256];
    char *input = buff;
    while(1){
        if(filename){
            strncpy(input, filename, 256);
        }else{
            printf("Enter Image Path: ");
            fflush(stdout);
            input = fgets(input, 256, stdin);
            if(!input) return;
            strtok(input, "\n");
        }
        image im = load_image_color(input, 0, 0);
        image sized = letterbox_image(im, net->w, net->h);

        float *X = sized.data;
        time=clock();
        float *predictions = network_predict(net, X);
        printf("Predicted: %f\n", predictions[0]);
        printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
        free_image(im);
        free_image(sized);
        if (filename) break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdx, %rbx
xorl %edx, %edx
callq 0x316bc
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0x320a7
movl $0x21e88e, %edi         # imm = 0x21E88E
callq 0x3220
leaq 0x50(%rsp), %r13
leaq 0xf036(%rip), %rbp      # 0x5a11c
testq %rbx, %rbx
je 0x4b0fd
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3080
jmp 0x4b14c
leaq 0xf03e(%rip), %rdi      # 0x5a142
xorl %eax, %eax
callq 0x3160
movq 0x20ebe(%rip), %rax     # 0x6bfd0
movq (%rax), %rdi
callq 0x3310
movq 0x20eb7(%rip), %rax     # 0x6bfd8
movq (%rax), %rdx
movq %r13, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x3230
testq %rax, %rax
je 0x4b20f
movq %rax, %r13
movq %rax, %rdi
leaq 0xf51a(%rip), %rsi      # 0x5a661
callq 0x33b0
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x16ac9
movl 0x90(%r14), %edx
movl 0x94(%r14), %esi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x19916
movq 0x48(%rsp), %r12
callq 0x3120
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x32690
xorps %xmm0, %xmm0
cvtss2sd (%rax), %xmm0
leaq 0xfadd(%rip), %rdi      # 0x5ac8b
movb $0x1, %al
callq 0x3160
callq 0x3120
subq %r15, %rax
movq %rax, %rdi
callq 0xf0bf
cvtss2sd %xmm0, %xmm0
movq %rbp, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x3160
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x1657b
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x1657b
testq %rbx, %rbx
je 0x4b0e6
addq $0x158, %rsp            # imm = 0x158
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/regressor.c
// Function: run_regressor
void run_regressor(int argc, char **argv)
{
    if(argc < 4){
        fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
        return;
    }

    char *gpu_list = find_char_arg(argc, argv, "-gpus", 0);
    int *gpus = 0;
    int gpu = 0;
    int ngpus = 0;
    if(gpu_list){
        printf("%s\n", gpu_list);
        int len = strlen(gpu_list);
        ngpus = 1;
        int i;
        for(i = 0; i < len; ++i){
            if (gpu_list[i] == ',') ++ngpus;
        }
        gpus = calloc(ngpus, sizeof(int));
        for(i = 0; i < ngpus; ++i){
            gpus[i] = atoi(gpu_list);
            gpu_list = strchr(gpu_list, ',')+1;
        }
    } else {
        gpu = gpu_index;
        gpus = &gpu;
        ngpus = 1;
    }

    int cam_index = find_int_arg(argc, argv, "-c", 0);
    int clear = find_arg(argc, argv, "-clear");
    char *data = argv[3];
    char *cfg = argv[4];
    char *weights = (argc > 5) ? argv[5] : 0;
    char *filename = (argc > 6) ? argv[6]: 0;
    if(0==strcmp(argv[2], "test")) predict_regressor(data, cfg, weights);
    else if(0==strcmp(argv[2], "train")) train_regressor(data, cfg, weights, gpus, ngpus, clear);
    else if(0==strcmp(argv[2], "demo")) demo_regressor(data, cfg, weights, cam_index, filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x3, %edi
jle 0x4b356
movl %edi, %r14d
leaq 0xf7d1(%rip), %rdx      # 0x5aa14
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xee68
testq %rax, %rax
je 0x4b29c
movq %rax, %r15
movq %rax, %rdi
callq 0x30b0
movq %r15, %rdi
callq 0x3140
movl $0x1, %ecx
movl $0x1, %ebp
testl %eax, %eax
jle 0x4b28f
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %esi, %esi
cmpb $0x2c, (%r15,%rdx)
sete %sil
addl %esi, %ebp
incq %rdx
cmpq %rdx, %rax
jne 0x4b27a
cmpl $0x2, %ebp
cmovgel %ebp, %ecx
decq %rcx
jne 0x4b295
jmp 0x4b2a1
movl $0x1, %ebp
leaq 0xef97(%rip), %rdx      # 0x5a23f
xorl %r15d, %r15d
movl %r14d, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xed18
leaq 0xee96(%rip), %rdx      # 0x5a155
movl %r14d, %edi
movq %rbx, %rsi
callq 0xeca2
movl %eax, %r12d
cmpl $0x6, %r14d
jl 0x4b2d7
movq 0x28(%rbx), %r15
movq 0x18(%rbx), %r13
movq 0x20(%rbx), %r14
movq 0x10(%rbx), %rbx
leaq 0xff6b(%rip), %rsi      # 0x5b255
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x4b318
leaq 0xf117(%rip), %rsi      # 0x5a414
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x4b334
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b0a5
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %r8d
movl %r12d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4aa6c
movq %rbx, %rdi
callq 0xb423
jmp 0x4b309
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/classifier.c
// Function: get_regression_values
float *get_regression_values(char **labels, int n)
{
    float *v = calloc(n, sizeof(float));
    int i;
    for(i = 0; i < n; ++i){
        char *p = strchr(labels[i], ' ');
        *p = 0;
        v[i] = atof(p+1);
    }
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x3250
movq %rax, %r14
testl %r15d, %r15d
jle 0x4b3b7
movl %ebp, %r15d
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
movl $0x20, %esi
callq 0x3150
movb $0x0, (%rax)
leaq 0x1(%rax), %rdi
callq 0x30f0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r14,%r12,4)
incq %r12
cmpq %r12, %r15
jne 0x4b38b
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/yolo.c
// Function: print_yolo_detections
void print_yolo_detections(FILE **fps, char *id, int total, int classes, int w, int h, detection *dets)
{
    int i, j;
    for(i = 0; i < total; ++i){
        float xmin = dets[i].bbox.x - dets[i].bbox.w/2.;
        float xmax = dets[i].bbox.x + dets[i].bbox.w/2.;
        float ymin = dets[i].bbox.y - dets[i].bbox.h/2.;
        float ymax = dets[i].bbox.y + dets[i].bbox.h/2.;

        if (xmin < 0) xmin = 0;
        if (ymin < 0) ymin = 0;
        if (xmax > w) xmax = w;
        if (ymax > h) ymax = h;

        for(j = 0; j < classes; ++j){
            if (dets[i].prob[j]) fprintf(fps[j], "%s %f %f %f %f %f\n", id, dets[i].prob[j],
                    xmin, ymin, xmax, ymax);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x4(%rsp)
testl %edx, %edx
jle 0x4f32d
movq %rsi, %r14
movq %rdi, %r15
movd %r9d, %xmm0
movd %r8d, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
movaps %xmm0, 0x30(%rsp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, 0x40(%rsp)
movl %edx, %eax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %r13d
xorl %ebx, %ebx
cmpl $0x0, 0x4(%rsp)
jle 0x4f31f
leaq (%rbx,%rbx,2), %rbp
shlq $0x4, %rbp
movq 0x90(%rsp), %rax
cvtps2pd 0x8(%rax,%rbp), %xmm1
mulpd 0x60a7(%rip), %xmm1     # 0x552e0
cvtps2pd (%rax,%rbp), %xmm0
movapd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm3
movaps 0x30(%rsp), %xmm2
cmpltps %xmm3, %xmm2
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
movmskpd %xmm2, %eax
movaps 0x40(%rsp), %xmm2
testb $0x2, %al
jne 0x4f269
movaps %xmm3, %xmm2
shufps $0x55, %xmm3, %xmm2     # xmm2 = xmm2[1,1],xmm3[1,1]
movaps 0x30(%rsp), %xmm4
testb $0x1, %al
jne 0x4f275
movaps %xmm3, %xmm4
addq 0x90(%rsp), %rbp
subpd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movhlps %xmm0, %xmm0            # xmm0 = xmm0[1,1]
cvtsd2ss %xmm0, %xmm0
xorps %xmm3, %xmm3
maxss %xmm0, %xmm3
xorps %xmm0, %xmm0
maxss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm3, %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm4, %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r12d, %r12d
movq 0x18(%rbp), %rax
movss (%rax,%r12,4), %xmm0
ucomiss 0x5dbe(%rip), %xmm0     # 0x550a0
jne 0x4f2e6
jnp 0x4f317
movq (%r15,%r12,8), %rdi
cvtss2sd %xmm0, %xmm0
leaq 0xbf19(%rip), %rsi      # 0x5b20e
movq %r14, %rdx
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
movsd 0x10(%rsp), %xmm4
movb $0x5, %al
callq 0x3270
incq %r12
cmpq %r12, %r13
jne 0x4f2d1
incq %rbx
cmpq 0x8(%rsp), %rbx
jne 0x4f211
addq $0x58, %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/detector.c
// Function: print_detector_detections
void print_detector_detections(FILE **fps, char *id, detection *dets, int total, int classes, int w, int h)
{
    int i, j;
    for(i = 0; i < total; ++i){
        float xmin = dets[i].bbox.x - dets[i].bbox.w/2. + 1;
        float xmax = dets[i].bbox.x + dets[i].bbox.w/2. + 1;
        float ymin = dets[i].bbox.y - dets[i].bbox.h/2. + 1;
        float ymax = dets[i].bbox.y + dets[i].bbox.h/2. + 1;

        if (xmin < 1) xmin = 1;
        if (ymin < 1) ymin = 1;
        if (xmax > w) xmax = w;
        if (ymax > h) ymax = h;

        for(j = 0; j < classes; ++j){
            if (dets[i].prob[j]) fprintf(fps[j], "%s %f %f %f %f %f\n", id, dets[i].prob[j],
                    xmin, ymin, xmax, ymax);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
testl %ecx, %ecx
jle 0x50087
movq %rsi, %r15
movq %rdi, %r12
movd 0xa0(%rsp), %xmm0
movd %r9d, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
movaps %xmm0, 0x40(%rsp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, 0x50(%rsp)
movl %ecx, %eax
movq %rax, 0x18(%rsp)
movl 0xc(%rsp), %ebx
xorl %ebp, %ebp
cmpl $0x0, 0xc(%rsp)
jle 0x50079
leaq (,%rbp,2), %r14
addq %rbp, %r14
shlq $0x4, %r14
movq 0x10(%rsp), %rax
cvtps2pd 0x8(%rax,%r14), %xmm1
cvtps2pd (%rax,%r14), %xmm0
mulpd 0x536b(%rip), %xmm1     # 0x552e0
movapd %xmm1, %xmm2
addpd %xmm0, %xmm2
addpd 0xa4bb(%rip), %xmm2     # 0x5a440
cvtpd2ps %xmm2, %xmm4
movaps 0x40(%rsp), %xmm2
cmpltps %xmm4, %xmm2
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
movmskpd %xmm2, %eax
movaps 0x50(%rsp), %xmm2
testb $0x2, %al
jne 0x4ffa9
movaps %xmm4, %xmm2
shufps $0x55, %xmm4, %xmm2     # xmm2 = xmm2[1,1],xmm4[1,1]
movaps 0x40(%rsp), %xmm3
testb $0x1, %al
jne 0x4ffb5
movaps %xmm4, %xmm3
addq 0x10(%rsp), %r14
subpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
movsd 0x5182(%rip), %xmm5     # 0x55150
addsd %xmm5, %xmm1
cvtsd2ss %xmm1, %xmm1
movss 0x502a(%rip), %xmm6     # 0x55008
movaps %xmm6, %xmm4
addsd %xmm5, %xmm0
cvtsd2ss %xmm0, %xmm0
maxss %xmm1, %xmm4
movaps %xmm6, %xmm1
maxss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm4, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm3, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %r13d, %r13d
movq 0x18(%r14), %rax
movss (%rax,%r13,4), %xmm0
ucomiss 0x5064(%rip), %xmm0     # 0x550a0
jne 0x50040
jnp 0x50071
movq (%r12,%r13,8), %rdi
cvtss2sd %xmm0, %xmm0
leaq 0xb1bf(%rip), %rsi      # 0x5b20e
movq %r15, %rdx
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
movsd 0x20(%rsp), %xmm4
movb $0x5, %al
callq 0x3270
incq %r13
cmpq %r13, %rbx
jne 0x5002b
incq %rbp
cmpq 0x18(%rsp), %rbp
jne 0x4ff43
addq $0x68, %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/detector.c
// Function: print_imagenet_detections
void print_imagenet_detections(FILE *fp, int id, detection *dets, int total, int classes, int w, int h)
{
    int i, j;
    for(i = 0; i < total; ++i){
        float xmin = dets[i].bbox.x - dets[i].bbox.w/2.;
        float xmax = dets[i].bbox.x + dets[i].bbox.w/2.;
        float ymin = dets[i].bbox.y - dets[i].bbox.h/2.;
        float ymax = dets[i].bbox.y + dets[i].bbox.h/2.;

        if (xmin < 0) xmin = 0;
        if (ymin < 0) ymin = 0;
        if (xmax > w) xmax = w;
        if (ymax > h) ymax = h;

        for(j = 0; j < classes; ++j){
            int class = j;
            if (dets[i].prob[class]) fprintf(fp, "%d %d %f %f %f %f %f\n", id, j+1, dets[i].prob[class],
                    xmin, ymin, xmax, ymax);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
testl %ecx, %ecx
jle 0x5020e
movl %esi, %ebp
movq %rdi, %r15
movd 0xa0(%rsp), %xmm0
movd %r9d, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
movaps %xmm0, 0x40(%rsp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, 0x50(%rsp)
movl %ecx, %eax
movq %rax, 0x18(%rsp)
movl 0xc(%rsp), %ebx
xorl %r13d, %r13d
cmpl $0x0, 0xc(%rsp)
jle 0x50200
leaq (,%r13,2), %r14
addq %r13, %r14
shlq $0x4, %r14
movq 0x10(%rsp), %rax
cvtps2pd 0x8(%rax,%r14), %xmm1
mulpd 0x51c7(%rip), %xmm1     # 0x552e0
cvtps2pd (%rax,%r14), %xmm0
movapd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm3
movaps 0x40(%rsp), %xmm2
cmpltps %xmm3, %xmm2
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
movmskpd %xmm2, %eax
movaps 0x50(%rsp), %xmm2
testb $0x2, %al
jne 0x5014a
movaps %xmm3, %xmm2
shufps $0x55, %xmm3, %xmm2     # xmm2 = xmm2[1,1],xmm3[1,1]
movaps 0x40(%rsp), %xmm4
testb $0x1, %al
jne 0x50156
movaps %xmm3, %xmm4
addq 0x10(%rsp), %r14
subpd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movhlps %xmm0, %xmm0            # xmm0 = xmm0[1,1]
cvtsd2ss %xmm0, %xmm0
xorps %xmm3, %xmm3
maxss %xmm0, %xmm3
xorps %xmm0, %xmm0
maxss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm3, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm4, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %r12d, %r12d
movq 0x18(%r14), %rax
movss (%rax,%r12,4), %xmm0
ucomiss 0x4ee0(%rip), %xmm0     # 0x550a0
jne 0x501c4
jnp 0x501f8
cvtss2sd %xmm0, %xmm0
leal 0x1(%r12), %ecx
movq %r15, %rdi
leaq 0xb0bf(%rip), %rsi      # 0x5b296
movl %ebp, %edx
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
movsd 0x20(%rsp), %xmm4
movb $0x5, %al
callq 0x3270
incq %r12
cmpq %r12, %rbx
jne 0x501af
incq %r13
cmpq 0x18(%rsp), %r13
jne 0x500ec
addq $0x68, %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/nightmare.c
// Function: abs_mean
float abs_mean(float *x, int n)
{
    int i;
    float sum = 0;
    for (i = 0; i < n; ++i){
        sum += fabs(x[i]);
    }
    return sum/n;
}

// Assembly:
testl %esi, %esi
jle 0x50a5c
movl %esi, %eax
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movaps 0x471a(%rip), %xmm1     # 0x55160
movss (%rdi,%rcx,4), %xmm2
andps %xmm1, %xmm2
addss %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x50a46
jmp 0x50a5f
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
divss %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/nightmare.c
// Function: calculate_loss
void calculate_loss(float *output, float *delta, int n, float thresh)
{
    int i;
    float mean = mean_array(output, n); 
    float var = variance_array(output, n);
    for(i = 0; i < n; ++i){
        if(delta[i] > mean + thresh*sqrt(var)) delta[i] = output[i];
        else delta[i] = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movss %xmm0, 0x10(%rsp)
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
callq 0xf5f0
movss %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0xf77b
testl %ebp, %ebp
jle 0x50b43
cvtss2sd 0x8(%rsp), %xmm2
cvtss2sd 0x10(%rsp), %xmm3
cvtss2sd %xmm0, %xmm4
movl %ebp, %r15d
xorl %r12d, %r12d
sqrtsd %xmm4, %xmm5
xorpd %xmm6, %xmm6
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, 0x28(%rsp)
movsd %xmm4, 0x20(%rsp)
movsd %xmm5, 0x18(%rsp)
xorps %xmm7, %xmm7
cvtss2sd (%rbx,%r12,4), %xmm7
ucomisd %xmm6, %xmm4
movapd %xmm5, %xmm0
jae 0x50b1e
movapd %xmm4, %xmm0
movsd %xmm7, 0x10(%rsp)
callq 0x3460
movsd 0x10(%rsp), %xmm7
xorpd %xmm6, %xmm6
movsd 0x18(%rsp), %xmm5
movsd 0x20(%rsp), %xmm4
movsd 0x28(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm0, %xmm7
jbe 0x50b35
movss (%r14,%r12,4), %xmm1
movss %xmm1, (%rbx,%r12,4)
incq %r12
cmpq %r12, %r15
jne 0x50ada
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/nightmare.c
// Function: smooth
void smooth(image recon, image update, float lambda, int num)
{
    int i, j, k;
    int ii, jj;
    for(k = 0; k < recon.c; ++k){
        for(j = 0; j < recon.h; ++j){
            for(i = 0; i < recon.w; ++i){
                int out_index = i + recon.w*(j + recon.h*k);
                for(jj = j-num; jj <= j + num && jj < recon.h; ++jj){
                    if (jj < 0) continue;
                    for(ii = i-num; ii <= i + num && ii < recon.w; ++ii){
                        if (ii < 0) continue;
                        int in_index = ii + recon.w*(jj + recon.h*k);
                        update.data[out_index] += lambda * (recon.data[in_index] - recon.data[out_index]);
                    }
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x40(%rsp), %rax
movq %rax, -0x30(%rsp)
testq %rax, %rax
jle 0x5118a
leaq 0x50(%rsp), %rax
leaq 0x38(%rsp), %rsi
movl (%rsi), %ecx
movl 0x4(%rsi), %edx
movq 0x10(%rsi), %rsi
movq 0x10(%rax), %r8
movslq %edi, %rax
movslq %ecx, %rdi
movslq %edx, %r9
movl %eax, %r10d
negl %r10d
movl %r10d, -0x3c(%rsp)
movl %edi, %r10d
notl %r10d
movq %rax, -0x38(%rsp)
imull %eax, %r10d
movl %r10d, -0x60(%rsp)
movq %r9, -0x28(%rsp)
movl %r9d, %eax
movq %rdi, -0x18(%rsp)
imull %edi, %eax
movl %eax, -0x40(%rsp)
movq $0x0, -0x50(%rsp)
testl %edx, %edx
jle 0x5116a
movq -0x50(%rsp), %rax
imulq %rdx, %rax
movq %rax, -0x20(%rsp)
movl -0x60(%rsp), %eax
movl %eax, -0x5c(%rsp)
movq $0x0, -0x48(%rsp)
testl %ecx, %ecx
jle 0x51150
movq -0x20(%rsp), %rax
movq -0x48(%rsp), %rdi
addq %rdi, %rax
imulq %rcx, %rax
movq %rax, -0x8(%rsp)
movq %rdi, %r9
movq -0x38(%rsp), %rax
subq %rax, %r9
leaq (%rdi,%rax), %rbx
cmpq %rbx, %r9
setle %al
movq %r9, -0x10(%rsp)
cmpq -0x28(%rsp), %r9
setl %dil
andb %al, %dil
movb %dil, -0x61(%rsp)
movl -0x5c(%rsp), %eax
movl %eax, -0x54(%rsp)
movl -0x3c(%rsp), %eax
movl %eax, -0x58(%rsp)
xorl %r15d, %r15d
cmpb $0x0, -0x61(%rsp)
je 0x5113c
movslq -0x58(%rsp), %r14
movq -0x8(%rsp), %rax
leaq (%rax,%r15), %r9
movq %r15, %rax
movq -0x38(%rsp), %rdi
subq %rdi, %rax
leaq (%r15,%rdi), %rbp
cmpq %rbp, %rax
setg %dil
cmpq -0x18(%rsp), %rax
setge %al
orb %dil, %al
movl -0x54(%rsp), %r13d
movq -0x10(%rsp), %rdi
testl %edi, %edi
sets %r10b
orb %al, %r10b
testb $0x1, %r10b
jne 0x5112b
movl %r13d, %r12d
movq %r14, %r10
testl %r10d, %r10d
js 0x5111b
movl %r12d, %r11d
movss (%rsi,%r11,4), %xmm1
subss (%rsi,%r9,4), %xmm1
mulss %xmm0, %xmm1
addss (%r8,%r9,4), %xmm1
movss %xmm1, (%r8,%r9,4)
cmpq %r10, %rbp
jle 0x5112b
incq %r10
incl %r12d
cmpl %ecx, %r10d
jl 0x510f7
movslq %edi, %r10
cmpq %r10, %rbx
jle 0x5113c
incl %edi
addl %ecx, %r13d
cmpl %edx, %edi
jl 0x510e2
incq %r15
incl -0x58(%rsp)
incl -0x54(%rsp)
cmpq %rcx, %r15
jne 0x5109e
movq -0x48(%rsp), %rdi
incq %rdi
addl %ecx, -0x5c(%rsp)
movq %rdi, -0x48(%rsp)
cmpq %rdx, %rdi
jne 0x51042
movq -0x50(%rsp), %rdi
incq %rdi
movl -0x40(%rsp), %eax
addl %eax, -0x60(%rsp)
movq %rdi, -0x50(%rsp)
cmpq -0x30(%rsp), %rdi
jne 0x5101b
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/nightmare.c
// Function: reconstruct_picture
void reconstruct_picture(network *net, float *features, image recon, image update, float rate, float momentum, float lambda, int smooth_size, int iters)
{
    int iter = 0;
    for (iter = 0; iter < iters; ++iter) {
        image delta = make_image(recon.w, recon.h, recon.c);

        net->input = recon.data;
        net->delta = delta.data;
        net->truth = features;

        forward_network(net);
        backward_network(net);

        //normalize_array(delta.data, delta.w*delta.h*delta.c);
        axpy_cpu(recon.w*recon.h*recon.c, 1, delta.data, 1, update.data, 1);
        //smooth(recon, update, lambda, smooth_size);

        axpy_cpu(recon.w*recon.h*recon.c, rate, update.data, 1, recon.data, 1);
        scal_cpu(recon.w*recon.h*recon.c, momentum, update.data, 1);

        float mag = mag_array(delta.data, recon.w*recon.h*recon.c);
        printf("mag: %f\n", mag);
        //scal_cpu(recon.w*recon.h*recon.c, 600/mag, recon.data, 1);

        constrain_image(recon);
        free_image(delta);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm1, 0x1c(%rsp)
movss %xmm0, 0x18(%rsp)
testl %ecx, %ecx
jle 0x512f2
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x88(%rsp), %rax
leaq 0x70(%rsp), %r13
movq 0x10(%rax), %r12
leaq 0xa2d6(%rip), %rbp      # 0x5b4ad
movl (%r13), %esi
movl 0x4(%r13), %edx
movl 0x8(%r13), %ecx
leaq 0x20(%rsp), %rdi
callq 0x15d43
movq 0x10(%r13), %rax
movq %rax, 0xd8(%r15)
movq 0x30(%rsp), %rax
movq %rax, 0xe8(%r15)
movq %r14, 0xe0(%r15)
movq %r15, %rdi
callq 0x319d7
movq %r15, %rdi
callq 0x31c65
movl 0x4(%r13), %edi
imull (%r13), %edi
imull 0x8(%r13), %edi
movq 0x30(%rsp), %rsi
movss 0x3dd2(%rip), %xmm0     # 0x55008
movl $0x1, %edx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x29d31
movl 0x4(%r13), %edi
imull (%r13), %edi
imull 0x8(%r13), %edi
movq 0x10(%r13), %rcx
movss 0x18(%rsp), %xmm0
movq %r12, %rsi
movl $0x1, %edx
movl $0x1, %r8d
callq 0x29d31
movl 0x4(%r13), %edi
imull (%r13), %edi
imull 0x8(%r13), %edi
movss 0x1c(%rsp), %xmm0
movq %r12, %rsi
movl $0x1, %edx
callq 0x29d61
movq 0x30(%rsp), %rdi
movl 0x4(%r13), %esi
imull (%r13), %esi
imull 0x8(%r13), %esi
callq 0xf92d
cvtss2sd %xmm0, %xmm0
movq %rbp, %rdi
movb $0x1, %al
callq 0x3160
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
callq 0x18031
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x1657b
decl %ebx
jne 0x511d7
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/darknet.c
// Function: speed
void speed(char *cfgfile, int tics)
{
    if (tics == 0) tics = 1000;
    network *net = parse_network_cfg(cfgfile);
    set_batch_network(net, 1);
    int i;
    double time=what_time_is_it_now();
    image im = make_image(net->w, net->h, net->c*net->batch);
    for(i = 0; i < tics; ++i){
        network_predict(net, im.data);
    }
    double t = what_time_is_it_now() - time;
    long ops = numops(net);
    printf("\n%d evals, %f Seconds\n", tics, t);
    printf("Floating Point Operations: %.2f Bn\n", (float)ops/1000000000.);
    printf("FLOPS: %.2f Bn\n", (float)ops/1000000000.*tics/t);
    printf("Speed: %f sec/eval\n", t/tics);
    printf("Speed: %f Hz\n", tics/t);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
testl %esi, %esi
movl $0x3e8, %ebx            # imm = 0x3E8
cmovnel %esi, %ebx
callq 0x5145
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0x320a7
xorl %eax, %eax
callq 0xe79c
movsd %xmm0, (%rsp)
movl 0x94(%r14), %esi
movl 0x4(%r14), %ecx
movl 0x90(%r14), %edx
imull 0x98(%r14), %ecx
leaq 0x18(%rsp), %rdi
callq 0x15d43
testl %ebx, %ebx
jle 0x52e6d
movl %ebx, %ebp
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x32690
decl %ebp
jne 0x52e5c
xorl %eax, %eax
callq 0xe79c
subsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x52b98
movq %rax, %r14
leaq 0x8774(%rip), %rdi      # 0x5b604
movl %ebx, %esi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x3160
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x232e(%rip), %xmm0     # 0x551e0
movsd %xmm0, 0x10(%rsp)
leaq 0x875c(%rip), %rdi      # 0x5b61b
movb $0x1, %al
callq 0x3160
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
divsd (%rsp), %xmm1
movapd %xmm1, %xmm0
leaq 0x8752(%rip), %rdi      # 0x5b63f
movb $0x1, %al
callq 0x3160
movsd (%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
leaq 0x8749(%rip), %rdi      # 0x5b64f
movb $0x1, %al
callq 0x3160
movsd 0x8(%rsp), %xmm0
divsd (%rsp), %xmm0
leaq 0x8744(%rip), %rdi      # 0x5b663
movb $0x1, %al
callq 0x3160
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/darknet.c
// Function: operations
void operations(char *cfgfile)
{
    gpu_index = -1;
    network *net = parse_network_cfg(cfgfile);
    long ops = numops(net);
    printf("Floating Point Operations: %ld\n", ops);
    printf("Floating Point Operations: %.2f Bn\n", (float)ops/1000000000.);
}

// Assembly:
pushq %rbx
leaq 0x19879(%rip), %rax     # 0x6c7b0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
callq 0x5145
movq %rax, %rdi
callq 0x52b98
movq %rax, %rbx
leaq 0x871d(%rip), %rdi      # 0x5b671
movq %rax, %rsi
xorl %eax, %eax
callq 0x3160
cvtsi2ss %rbx, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x2271(%rip), %xmm0     # 0x551e0
leaq 0x86a5(%rip), %rdi      # 0x5b61b
movb $0x1, %al
popq %rbx
jmp 0x3160
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/darknet.c
// Function: oneoff2
void oneoff2(char *cfgfile, char *weightfile, char *outfile, int l)
{
    gpu_index = -1;
    network *net = parse_network_cfg(cfgfile);
    if(weightfile){
        load_weights_upto(net, weightfile, 0, net->n);
        load_weights_upto(net, weightfile, l, net->n);
    }
    *net->seen = 0;
    save_weights_upto(net, outfile, net->n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x195ee(%rip), %rax     # 0x6c7b0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
callq 0x5145
movq %rax, %r14
testq %r15, %r15
je 0x531f5
movl (%r14), %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6880
movl (%r14), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x6880
movq 0x8(%r14), %rax
movq $0x0, (%rax)
movl (%r14), %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x63e0
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/darknet.c
// Function: print_weights
void print_weights(char *cfgfile, char *weightfile, int n)
{
    gpu_index = -1;
    network *net = load_network(cfgfile, weightfile, 1);
    layer l = net->layers[n];
    int i, j;
    //printf("[");
    for(i = 0; i < l.n; ++i){
        //printf("[");
        for(j = 0; j < l.size*l.size*l.c; ++j){
            //if(j > 0) printf(",");
            printf("%g ", l.weights[i*l.size*l.size*l.c + j]);
        }
        printf("\n");
        //printf("]%s\n", (i == l.n-1)?"":",");
    }
    //printf("]");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
leaq 0x1954d(%rip), %rax     # 0x6c7b0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x316bc
movq 0x20(%rax), %rax
movslq %ebx, %rcx
imulq $0x4a0, %rcx, %rcx      # imm = 0x4A0
movslq 0x84(%rax,%rcx), %rdx
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
jle 0x53306
leaq (%rax,%rcx), %rdx
movl 0x90(%rdx), %r15d
imull %r15d, %r15d
imull 0x74(%rdx), %r15d
movq 0x250(%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x83d3(%rip), %rbx      # 0x5b691
xorl %ebp, %ebp
testl %r15d, %r15d
jle 0x532ef
movslq %r13d, %rax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax,4), %r12
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtss2sd (%r12,%r14,4), %xmm0
movq %rbx, %rdi
movb $0x1, %al
callq 0x3160
incq %r14
cmpq %r14, %r15
jne 0x532d4
movl $0xa, %edi
callq 0x3060
incq %rbp
addl %r15d, %r13d
cmpq 0x10(%rsp), %rbp
jne 0x532c0
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/darknet.c
// Function: rescale_net
void rescale_net(char *cfgfile, char *weightfile, char *outfile)
{
    gpu_index = -1;
    network *net = load_network(cfgfile, weightfile, 0);
    int i;
    for(i = 0; i < net->n; ++i){
        layer l = net->layers[i];
        if(l.type == CONVOLUTIONAL){
            rescale_weights(l, 2, -.5);
            break;
        }
    }
    save_weights(net, outfile);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
movq %rdx, %rbx
leaq 0x19487(%rip), %rax     # 0x6c7b0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x316bc
movq %rax, %r14
movslq (%rax), %rax
testq %rax, %rax
jle 0x5337d
movq 0x20(%r14), %rsi
xorl %ecx, %ecx
cmpl $0x0, (%rsi)
je 0x5335d
incq %rcx
addq $0x4a0, %rsi            # imm = 0x4A0
cmpq %rax, %rcx
jb 0x53347
jmp 0x5337d
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movss 0x1f1c(%rip), %xmm0     # 0x5528c
movss 0x8288(%rip), %xmm1     # 0x5b600
callq 0x1157a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r14
jmp 0x6879
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/darknet.c
// Function: rgbgr_net
void rgbgr_net(char *cfgfile, char *weightfile, char *outfile)
{
    gpu_index = -1;
    network *net = load_network(cfgfile, weightfile, 0);
    int i;
    for(i = 0; i < net->n; ++i){
        layer l = net->layers[i];
        if(l.type == CONVOLUTIONAL){
            rgbgr_weights(l);
            break;
        }
    }
    save_weights(net, outfile);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
movq %rdx, %rbx
leaq 0x1940a(%rip), %rax     # 0x6c7b0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x316bc
movq %rax, %r14
movslq (%rax), %rax
testq %rax, %rax
jle 0x533ea
movq 0x20(%r14), %rsi
xorl %ecx, %ecx
cmpl $0x0, (%rsi)
je 0x533da
incq %rcx
addq $0x4a0, %rsi            # imm = 0x4A0
cmpq %rax, %rcx
jb 0x533c4
jmp 0x533ea
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x114e6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r14
jmp 0x6879
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/darknet.c
// Function: reset_normalize_net
void reset_normalize_net(char *cfgfile, char *weightfile, char *outfile)
{
    gpu_index = -1;
    network *net = load_network(cfgfile, weightfile, 0);
    int i;
    for (i = 0; i < net->n; ++i) {
        layer l = net->layers[i];
        if (l.type == CONVOLUTIONAL && l.batch_normalize) {
            denormalize_convolutional_layer(l);
        }
        if (l.type == CONNECTED && l.batch_normalize) {
            denormalize_connected_layer(l);
        }
        if (l.type == GRU && l.batch_normalize) {
            denormalize_connected_layer(*l.input_z_layer);
            denormalize_connected_layer(*l.input_r_layer);
            denormalize_connected_layer(*l.input_h_layer);
            denormalize_connected_layer(*l.state_z_layer);
            denormalize_connected_layer(*l.state_r_layer);
            denormalize_connected_layer(*l.state_h_layer);
        }
    }
    save_weights(net, outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x948, %rsp            # imm = 0x948
movq %rdx, %rbx
leaq 0x19396(%rip), %rax     # 0x6c7b0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x316bc
movq %rax, %r14
cmpl $0x0, (%rax)
jle 0x53587
xorl %r13d, %r13d
leaq 0x4a8(%rsp), %r15
xorl %ebp, %ebp
movq 0x20(%r14), %r12
addq %r13, %r12
movl $0x4a0, %edx            # imm = 0x4A0
movq %r15, %rdi
movq %r12, %rsi
callq 0x32b0
movl 0x4a8(%rsp), %ecx
movl 0x4e8(%rsp), %eax
testl %ecx, %ecx
sete %dl
testl %eax, %eax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x5349a
movl $0x94, %ecx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x1108d
movl 0x4a8(%rsp), %ecx
movl 0x4e8(%rsp), %eax
cmpl $0x2, %ecx
sete %dl
testl %eax, %eax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x534d0
movl $0x94, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x33949
movl 0x4a8(%rsp), %ecx
movl 0x4e8(%rsp), %eax
cmpl $0x10, %ecx
jne 0x53571
testl %eax, %eax
je 0x53571
movq 0x898(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x33949
movq 0x8a8(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x33949
movq 0x8b8(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x33949
movq 0x8a0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x33949
movq 0x8b0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x33949
movq 0x8c0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x33949
incq %rbp
movslq (%r14), %rax
addq $0x4a0, %r13            # imm = 0x4A0
cmpq %rax, %rbp
jl 0x53440
movq %r14, %rdi
movq %rbx, %rsi
addq $0x948, %rsp            # imm = 0x948
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6879
// File: /workspace/github_c_makefile_star2_O3/SimpleDoger[P]Darknet_CPU_Only/darknet.c
// Function: normalize_layer
layer normalize_layer(layer l, int n)
{
    int j;
    l.batch_normalize=1;
    l.scales = calloc(n, sizeof(float));
    for(j = 0; j < n; ++j){
        l.scales[j] = 1;
    }
    l.rolling_mean = calloc(n, sizeof(float));
    l.rolling_variance = calloc(n, sizeof(float));
    return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x1, 0x40(%r14)
movslq %esi, %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x3250
movq %rax, 0x240(%r14)
testl %r15d, %r15d
jle 0x536db
movl %r12d, %ecx
addl $0x3, %r12d
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %r12d
shlq $0x4, %r12
movdqa 0x1b6e(%rip), %xmm1     # 0x55170
movdqa 0x1a76(%rip), %xmm2     # 0x55080
xorl %ecx, %ecx
movdqa 0x1a7c(%rip), %xmm3     # 0x55090
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x1b5c(%rip), %xmm5     # 0x55180
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edx
notl %edx
testb $0x1, %dl
je 0x5365f
movl $0x3f800000, (%rax,%rcx) # imm = 0x3F800000
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x53675
movl $0x3f800000, 0x4(%rax,%rcx) # imm = 0x3F800000
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %edx
testb $0x1, %dl
je 0x536b4
movl $0x3f800000, 0x8(%rax,%rcx) # imm = 0x3F800000
pextrw $0x4, %xmm6, %edx
testb $0x1, %dl
je 0x536c6
movl $0x3f800000, 0xc(%rax,%rcx) # imm = 0x3F800000
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x10, %rcx
cmpq %rcx, %r12
jne 0x53624
movl $0x4, %esi
movq %r15, %rdi
callq 0x3250
movq %rax, 0x2b0(%r14)
movl $0x4, %esi
movq %r15, %rdi
callq 0x3250
movq %rax, 0x2b8(%r14)
movl $0x4a0, %edx            # imm = 0x4A0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/shuffle.c
// Function: shuffle
void shuffle(CREC *array, long n) {
    long i, j;
    CREC tmp;
    for (i = n - 1; i > 0; i--) {
        j = rand_long(i + 1);
        tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }
}

// Assembly:
cmpq $0x2, %rsi
jl 0x18a7
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x3fffffffffffffff, %r15 # imm = 0x3FFFFFFFFFFFFFFF
movq %r15, %rax
xorl %edx, %edx
divq %r14
movq %rdx, %r12
xorq %r15, %r12
callq 0x11b0
movslq %eax, %r13
shlq $0x1f, %r13
callq 0x11b0
cltq
addq %r13, %rax
cmpq %r12, %rax
jge 0x184a
leaq -0x1(%r14), %rcx
cqto
idivq %r14
shlq $0x4, %rdx
movups (%rbx,%rdx), %xmm0
movaps %xmm0, (%rsp)
movq %rcx, %rax
shlq $0x4, %rax
movups (%rbx,%rax), %xmm0
movups %xmm0, (%rbx,%rdx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx,%rax)
cmpq $0x2, %r14
movq %rcx, %r14
jg 0x183c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mchackorg[P]mcwm/mcwm.c
// Function: movestep
void movestep(struct client *client, char direction)
{
    int16_t start_x;
    int16_t start_y;

    if (NULL == client)
    {
        return;
    }

    if (client->maxed)
    {
        /* We can't move a fully maximized window. */
        return;
    }

    /* Save pointer position so we can warp pointer here later. */
    if (!getpointer(client->id, &start_x, &start_y))
    {
        return;
    }

    raisewindow(client->id);
    switch (direction)
    {
    case 'h':
        client->x = client->x - MOVE_STEP;
        break;

    case 'j':
        client->y = client->y + MOVE_STEP;
        break;

    case 'k':
        client->y = client->y - MOVE_STEP;
        break;

    case 'l':
        client->x = client->x + MOVE_STEP;
        break;

    default:
        PDEBUG("movestep: Moving in unknown direction.\n");
        break;
    } /* switch direction */

    movelim(client);

    /*
     * If the pointer was inside the window to begin with, move
     * pointer back to where it was, relative to the window.
     */
    if (start_x > 0 - conf.borderwidth && start_x < client->width
        + conf.borderwidth && start_y > 0 - conf.borderwidth && start_y
        < client->height + conf.borderwidth)
    {
        xcb_warp_pointer(conn, XCB_NONE, client->id, 0, 0, 0, 0,
                         start_x, start_y);
        xcb_flush(conn);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x568a
movq %rdi, %rbx
cmpb $0x0, 0x31(%rdi)
jne 0x568a
movl %esi, %ebp
movl (%rbx), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x4e4d
testb %al, %al
je 0x568a
movl (%rbx), %edi
callq 0x4d2d
movsbl %bpl, %eax
addl $-0x68, %eax
cmpl $0x4, %eax
ja 0x5618
leaq 0x1b5f(%rip), %rcx      # 0x7154
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addw $-0x20, 0x6(%rbx)
jmp 0x5618
addw $-0x20, 0x8(%rbx)
jmp 0x5618
addw $0x20, 0x8(%rbx)
jmp 0x5618
addw $0x20, 0x6(%rbx)
movq %rbx, %rdi
callq 0x5279
movswl 0x6(%rsp), %eax
movl 0x4e45(%rip), %ecx      # 0xa470
movl %ecx, %edx
negl %edx
cmpl %edx, %eax
jle 0x568a
movzwl 0xa(%rbx), %esi
addl %ecx, %esi
cmpl %eax, %esi
jle 0x568a
movswl 0x4(%rsp), %r10d
cmpl %edx, %r10d
jle 0x568a
movzwl 0xc(%rbx), %edx
addl %edx, %ecx
cmpl %r10d, %ecx
jle 0x568a
movq 0x4e36(%rip), %rdi      # 0xa490
movl (%rbx), %edx
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x2050
addq $0x20, %rsp
movq 0x4e11(%rip), %rdi      # 0xa490
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2150
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mchackorg[P]mcwm/mcwm.c
// Function: topleft
void topleft(void)
{
    int16_t pointx;
    int16_t pointy;
    int16_t mon_x;
    int16_t mon_y;

    if (NULL == focuswin)
    {
        return;
    }

    if (NULL == focuswin->monitor)
    {
        mon_x = 0;
        mon_y = 0;
    }
    else
    {
        mon_x = focuswin->monitor->x;
        mon_y = focuswin->monitor->y;
    }

    raisewindow(focuswin->id);

    if (!getpointer(focuswin->id, &pointx, &pointy))
    {
        return;
    }

    focuswin->x = mon_x;
    focuswin->y = mon_y;
    movewindow(focuswin->id, focuswin->x, focuswin->y);
    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     pointx, pointy);
    xcb_flush(conn);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x4c80(%rip), %rax      # 0xa4c0
testq %rax, %rax
je 0x58e8
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x585c
movzwl 0x10(%rcx), %ebp
movzwl 0x12(%rcx), %ebx
jmp 0x5860
xorl %ebx, %ebx
xorl %ebp, %ebp
movl (%rax), %edi
callq 0x4d2d
movq 0x4c52(%rip), %rax      # 0xa4c0
movl (%rax), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x4e4d
testb %al, %al
je 0x58e8
movq 0x4c36(%rip), %rax      # 0xa4c0
movw %bp, 0x6(%rax)
movw %bx, 0x8(%rax)
movl (%rax), %edi
movzwl %bp, %esi
movzwl %bx, %edx
callq 0x4393
movq 0x4bea(%rip), %rdi      # 0xa490
movq 0x4c13(%rip), %rax      # 0xa4c0
movl (%rax), %edx
movswl 0x6(%rsp), %eax
movswl 0x4(%rsp), %r10d
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x2050
addq $0x20, %rsp
movq 0x4bb3(%rip), %rdi      # 0xa490
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2150
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mchackorg[P]mcwm/mcwm.c
// Function: botright
void botright(void)
{
    int16_t pointx;
    int16_t pointy;
    int16_t mon_x;
    int16_t mon_y;
    uint16_t mon_width;
    uint16_t mon_height;

    if (NULL == focuswin)
    {
        return;
    }

    if (NULL == focuswin->monitor)
    {
        mon_x = 0;
        mon_y = 0;
        mon_width = screen->width_in_pixels;;
        mon_height = screen->height_in_pixels;
    }
    else
    {
        mon_x = focuswin->monitor->x;
        mon_y = focuswin->monitor->y;
        mon_width = focuswin->monitor->width;
        mon_height = focuswin->monitor->height;
    }

    raisewindow(focuswin->id);

    if (!getpointer(focuswin->id, &pointx, &pointy))
    {
        return;
    }

    focuswin->x = mon_x + mon_width - (focuswin->width + conf.borderwidth * 2);
    focuswin->y =  mon_y + mon_height - (focuswin->height + conf.borderwidth
                                         * 2);
    movewindow(focuswin->id, focuswin->x, focuswin->y);
    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     pointx, pointy);
    xcb_flush(conn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x4a03(%rip), %rax      # 0xa4c0
testq %rax, %rax
je 0x5b9a
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x5ad9
movzwl 0x10(%rcx), %ebp
movzwl 0x12(%rcx), %ebx
jmp 0x5ae4
xorl %ebx, %ebx
movq 0x49b6(%rip), %rcx      # 0xa498
xorl %ebp, %ebp
movzwl 0x16(%rcx), %r14d
movzwl 0x14(%rcx), %r15d
movl (%rax), %edi
callq 0x4d2d
movq 0x49c4(%rip), %rax      # 0xa4c0
movl (%rax), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x4e4d
testb %al, %al
je 0x5b9a
movq 0x49a4(%rip), %rax      # 0xa4c0
movzwl 0xa(%rax), %ecx
movl 0x494a(%rip), %edx      # 0xa470
addl %edx, %edx
addl %r15d, %ebp
subl %ecx, %ebp
subl %edx, %ebp
movw %bp, 0x6(%rax)
addl %r14d, %ebx
subl %edx, %ebx
subw 0xc(%rax), %bx
movw %bx, 0x8(%rax)
movl (%rax), %edi
movzwl %bp, %esi
movzwl %bx, %edx
callq 0x4393
movq 0x493c(%rip), %rdi      # 0xa490
movq 0x4965(%rip), %rax      # 0xa4c0
movl (%rax), %edx
movswl 0x6(%rsp), %eax
movswl 0x4(%rsp), %r10d
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x2050
addq $0x20, %rsp
movq 0x4905(%rip), %rdi      # 0xa490
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2150
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq