LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x4ef18
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)
movq %rdi, -0x18(%rsp)
notl %edi
movq %rax, -0x38(%rsp)
imull %eax, %edi
movl %edi, -0x60(%rsp)
movq %r9, -0x28(%rsp)
movl %r9d, %eax
imull %ecx, %eax
movl %eax, -0x40(%rsp)
movq $0x0, -0x50(%rsp)
testl %edx, %edx
jle 0x4eef8
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 0x4eede
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 0x4eeca
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 0x4eeb9
movl %r13d, %r12d
movq %r14, %r10
testl %r10d, %r10d
js 0x4eea9
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 0x4eeb9
incq %r10
incl %r12d
cmpl %ecx, %r10d
jl 0x4ee85
movslq %edi, %r10
cmpq %r10, %rbx
jle 0x4eeca
incl %edi
addl %ecx, %r13d
cmpl %edx, %edi
jl 0x4ee70
incq %r15
incl -0x58(%rsp)
incl -0x54(%rsp)
cmpq %rcx, %r15
jne 0x4ee2c
movq -0x48(%rsp), %rdi
incq %rdi
addl %ecx, -0x5c(%rsp)
movq %rdi, -0x48(%rsp)
cmpq %rdx, %rdi
jne 0x4edd0
movq -0x50(%rsp), %rdi
incq %rdi
movl -0x40(%rsp), %eax
addl %eax, -0x60(%rsp)
movq %rdi, -0x50(%rsp)
cmpq -0x30(%rsp), %rdi
jne 0x4eda9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/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 0x4f080
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x88(%rsp), %rax
leaq 0x70(%rsp), %r13
movq 0x10(%rax), %r12
leaq 0xa3e8(%rip), %rbp      # 0x5934d
movl (%r13), %esi
movl 0x4(%r13), %edx
movl 0x8(%r13), %ecx
leaq 0x20(%rsp), %rdi
callq 0x1529e
movq 0x10(%r13), %rax
movq %rax, 0xd8(%r15)
movq 0x30(%rsp), %rax
movq %rax, 0xe8(%r15)
movq %r14, 0xe0(%r15)
movq %r15, %rdi
callq 0x2fcff
movq %r15, %rdi
callq 0x2ff8b
movl 0x4(%r13), %edi
imull (%r13), %edi
imull 0x8(%r13), %edi
movq 0x30(%rsp), %rsi
movss 0x4044(%rip), %xmm0     # 0x53008
movl $0x1, %edx
movq %r12, %rcx
movl $0x1, %r8d
callq 0x285e9
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 0x285e9
movl 0x4(%r13), %edi
imull (%r13), %edi
imull 0x8(%r13), %edi
movss 0x1c(%rsp), %xmm0
movq %r12, %rsi
movl $0x1, %edx
callq 0x28619
movq 0x30(%rsp), %rdi
movl 0x4(%r13), %esi
imull (%r13), %esi
imull 0x8(%r13), %esi
callq 0xf121
cvtss2sd %xmm0, %xmm0
movq %rbp, %rdi
movb $0x1, %al
callq 0x3170
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
callq 0x17785
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x15b37
decl %ebx
jne 0x4ef65
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/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 0x4ebd
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0x302d4
xorl %eax, %eax
callq 0xdfdc
movsd %xmm0, (%rsp)
movl 0x94(%r14), %esi
movl 0x4(%r14), %ecx
movl 0x90(%r14), %edx
imull 0x98(%r14), %ecx
leaq 0x18(%rsp), %rdi
callq 0x1529e
testl %ebx, %ebx
jle 0x50cc0
movl %ebx, %ebp
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x307ea
decl %ebp
jne 0x50caf
xorl %eax, %eax
callq 0xdfdc
subsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x509eb
movq %rax, %r14
leaq 0x87c1(%rip), %rdi      # 0x594a4
movl %ebx, %esi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x3170
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x24ab(%rip), %xmm0     # 0x531b0
movsd %xmm0, 0x10(%rsp)
leaq 0x87a9(%rip), %rdi      # 0x594bb
movb $0x1, %al
callq 0x3170
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
divsd (%rsp), %xmm1
movapd %xmm1, %xmm0
leaq 0x879f(%rip), %rdi      # 0x594df
movb $0x1, %al
callq 0x3170
movsd (%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
leaq 0x8796(%rip), %rdi      # 0x594ef
movb $0x1, %al
callq 0x3170
movsd 0x8(%rsp), %xmm0
divsd (%rsp), %xmm0
leaq 0x8791(%rip), %rdi      # 0x59503
movb $0x1, %al
callq 0x3170
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19a36(%rip), %rax     # 0x6a7c0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
callq 0x4ebd
movq %rax, %rdi
callq 0x509eb
movq %rax, %rbx
leaq 0x876a(%rip), %rdi      # 0x59511
movq %rax, %rsi
xorl %eax, %eax
callq 0x3170
cvtsi2ss %rbx, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x23ee(%rip), %xmm0     # 0x531b0
leaq 0x86f2(%rip), %rdi      # 0x594bb
movb $0x1, %al
popq %rbx
jmp 0x3170
// File: /workspace/github_c_makefile_star2_O1/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 0x197de(%rip), %rax     # 0x6a7c0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
callq 0x4ebd
movq %rax, %r14
testq %r15, %r15
je 0x51015
movl (%r14), %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x66d4
movl (%r14), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x66d4
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 0x623e
// File: /workspace/github_c_makefile_star2_O1/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 0x1973d(%rip), %rax     # 0x6a7c0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x2f9e4
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 0x51126
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 0x8453(%rip), %rbx      # 0x59531
xorl %ebp, %ebp
testl %r15d, %r15d
jle 0x5110f
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 0x3170
incq %r14
cmpq %r14, %r15
jne 0x510f4
movl $0xa, %edi
callq 0x3060
incq %rbp
addl %r15d, %r13d
cmpq 0x10(%rsp), %rbp
jne 0x510e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/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 0x19677(%rip), %rax     # 0x6a7c0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x2f9e4
movq %rax, %r14
cmpl $0x0, (%rax)
jle 0x5119d
movq 0x20(%r14), %rsi
xorl %eax, %eax
cmpl $0x0, (%rsi)
je 0x5117d
incq %rax
movslq (%r14), %rcx
addq $0x4a0, %rsi            # imm = 0x4A0
cmpq %rcx, %rax
jl 0x51164
jmp 0x5119d
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movss 0x20d0(%rip), %xmm0     # 0x53260
movss 0x8308(%rip), %xmm1     # 0x594a0
callq 0x10bf2
movq %r14, %rdi
movq %rbx, %rsi
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r14
jmp 0x66cd
// File: /workspace/github_c_makefile_star2_O1/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 0x195fa(%rip), %rax     # 0x6a7c0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x2f9e4
movq %rax, %r14
cmpl $0x0, (%rax)
jle 0x5120a
movq 0x20(%r14), %rsi
xorl %eax, %eax
cmpl $0x0, (%rsi)
je 0x511fa
incq %rax
movslq (%r14), %rcx
addq $0x4a0, %rsi            # imm = 0x4A0
cmpq %rcx, %rax
jl 0x511e1
jmp 0x5120a
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x10b5e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r14
jmp 0x66cd
// File: /workspace/github_c_makefile_star2_O1/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 0x19586(%rip), %rax     # 0x6a7c0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x2f9e4
movq %rax, %r14
cmpl $0x0, (%rax)
jle 0x51387
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 0x32c0
cmpl $0x0, 0x4a8(%rsp)
jne 0x5129e
cmpl $0x0, 0x4e8(%rsp)
je 0x5129e
movl $0x94, %ecx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x10705
cmpl $0x2, 0x4a8(%rsp)
jne 0x512c5
cmpl $0x0, 0x4e8(%rsp)
je 0x512c5
movl $0x94, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3198b
cmpl $0x10, 0x4a8(%rsp)
jne 0x51371
cmpl $0x0, 0x4e8(%rsp)
je 0x51371
movq 0x898(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3198b
movq 0x8a8(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3198b
movq 0x8b8(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3198b
movq 0x8a0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3198b
movq 0x8b0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3198b
movq 0x8c0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3198b
incq %rbp
movslq (%r14), %rax
addq $0x4a0, %r13            # imm = 0x4A0
cmpq %rax, %rbp
jl 0x51260
movq %r14, %rdi
movq %rbx, %rsi
addq $0x948, %rsp            # imm = 0x948
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x66cd
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x1, 0x40(%r14)
movslq %esi, %r15
movl $0x4, %esi
movq %r15, %rdi
callq 0x3260
movq %rax, 0x240(%r14)
testl %r15d, %r15d
jle 0x513eb
movl %ebp, %ecx
xorl %edx, %edx
movl $0x3f800000, (%rax,%rdx,4) # imm = 0x3F800000
incq %rdx
cmpq %rdx, %rcx
jne 0x513dc
movl $0x4, %esi
movq %r15, %rdi
callq 0x3260
movq %rax, 0x2b0(%r14)
movl $0x4, %esi
movq %r15, %rdi
callq 0x3260
movq %rax, 0x2b8(%r14)
movl $0x4a0, %edx            # imm = 0x4A0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/SimpleDoger[P]Darknet_CPU_Only/darknet.c
// Function: statistics_net
void statistics_net(char *cfgfile, char *weightfile)
{
    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 == CONNECTED && l.batch_normalize) {
            printf("Connected Layer %d\n", i);
            statistics_connected_layer(l);
        }
        if (l.type == GRU && l.batch_normalize) {
            printf("GRU Layer %d\n", i);
            printf("Input Z\n");
            statistics_connected_layer(*l.input_z_layer);
            printf("Input R\n");
            statistics_connected_layer(*l.input_r_layer);
            printf("Input H\n");
            statistics_connected_layer(*l.input_h_layer);
            printf("State Z\n");
            statistics_connected_layer(*l.state_z_layer);
            printf("State R\n");
            statistics_connected_layer(*l.state_r_layer);
            printf("State H\n");
            statistics_connected_layer(*l.state_h_layer);
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x948, %rsp            # imm = 0x948
leaq 0x18ab2(%rip), %rax     # 0x6a7c0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x2f9e4
cmpl $0x0, (%rax)
jle 0x51eac
movq %rax, %rbx
leaq 0x4a8(%rsp), %r14
leaq 0x796e(%rip), %r13      # 0x596a4
leaq 0x796f(%rip), %rbp      # 0x596ac
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x20(%rbx), %rsi
addq %r12, %rsi
movl $0x4a0, %edx            # imm = 0x4A0
movq %r14, %rdi
callq 0x32c0
cmpl $0x2, 0x4a8(%rsp)
jne 0x51d8f
cmpl $0x0, 0x4e8(%rsp)
je 0x51d8f
leaq 0x77c3(%rip), %rdi      # 0x59535
movl %r15d, %esi
xorl %eax, %eax
callq 0x3170
movl $0x94, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x31ac8
cmpl $0x10, 0x4a8(%rsp)
jne 0x51e8c
cmpl $0x0, 0x4e8(%rsp)
je 0x51e8c
leaq 0x7797(%rip), %rdi      # 0x59549
movl %r15d, %esi
xorl %eax, %eax
callq 0x3170
leaq 0x78c1(%rip), %rdi      # 0x59684
callq 0x30c0
movq 0x898(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x31ac8
leaq 0x78a5(%rip), %rdi      # 0x5968c
callq 0x30c0
movq 0x8a8(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x31ac8
leaq 0x7889(%rip), %rdi      # 0x59694
callq 0x30c0
movq 0x8b8(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x31ac8
leaq 0x786d(%rip), %rdi      # 0x5969c
callq 0x30c0
movq 0x8a0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x31ac8
movq %r13, %rdi
callq 0x30c0
movq 0x8b0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x31ac8
movq %rbp, %rdi
callq 0x30c0
movq 0x8c0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x31ac8
movl $0xa, %edi
callq 0x3060
incq %r15
movslq (%rbx), %rax
addq $0x4a0, %r12            # imm = 0x4A0
cmpq %rax, %r15
jl 0x51d43
addq $0x948, %rsp            # imm = 0x948
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18c7
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 0x11c0
movslq %eax, %r13
shlq $0x1f, %r13
callq 0x11c0
cltq
addq %r13, %rax
cmpq %r12, %rax
jge 0x186a
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 0x185c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/aremmell[P]libsir/./plugins/sample/plugin_sample.c
// Function: sir_plugin_query
PLUGIN_EXPORT bool sir_plugin_query(sir_plugininfo* info) {
    info->iface_ver = SIR_PLUGIN_VCURRENT;
    info->maj_ver   = maj_ver;
    info->min_ver   = min_ver;
    info->bld_ver   = bld_ver;
    info->levels    = levels;
    info->opts      = opts;
    info->author    = author;
    info->desc      = desc;
    info->caps      = caps;

    (void)printf("\t" SIR_DGRAY("plugin_sample ('%s')") SIR_EOL, __func__);
    return true;
}

// Assembly:
pushq %rax
movl $0x101, (%rdi)          # imm = 0x101
movw $0xc0, 0x4(%rdi)
movl $0x4400, 0x8(%rdi)      # imm = 0x4400
leaq 0xf8c(%rip), %rax       # 0x20b3
movq %rax, 0x10(%rdi)
leaq 0xf95(%rip), %rax       # 0x20c7
movq %rax, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0xebb(%rip), %rsi       # 0x2000
leaq 0xedf(%rip), %rdx       # 0x202b
movl $0x1, %edi
xorl %eax, %eax
callq 0x1030
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x55ea
movq %rdi, %rbx
cmpb $0x0, 0x31(%rdi)
jne 0x55ea
movl %esi, %ebp
movl (%rbx), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x4dd7
testb %al, %al
je 0x55ea
movl (%rbx), %edi
callq 0x4cb7
movsbl %bpl, %eax
addl $-0x68, %eax
cmpl $0x4, %eax
ja 0x5578
leaq 0xbff(%rip), %rcx       # 0x6154
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addw $-0x20, 0x6(%rbx)
jmp 0x5578
addw $-0x20, 0x8(%rbx)
jmp 0x5578
addw $0x20, 0x8(%rbx)
jmp 0x5578
addw $0x20, 0x6(%rbx)
movq %rbx, %rdi
callq 0x5200
movswl 0x6(%rsp), %eax
movl 0x3ee5(%rip), %ecx      # 0x9470
movl %ecx, %edx
negl %edx
cmpl %edx, %eax
jle 0x55ea
movzwl 0xa(%rbx), %esi
addl %ecx, %esi
cmpl %eax, %esi
jle 0x55ea
movswl 0x4(%rsp), %r10d
cmpl %edx, %r10d
jle 0x55ea
movzwl 0xc(%rbx), %edx
addl %edx, %ecx
cmpl %r10d, %ecx
jle 0x55ea
movq 0x3ed6(%rip), %rdi      # 0x9490
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 0x3eb1(%rip), %rdi      # 0x9490
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2150
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3d26(%rip), %rax      # 0x94c0
testq %rax, %rax
je 0x5842
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x57b6
movzwl 0x10(%rcx), %ebp
movzwl 0x12(%rcx), %ebx
jmp 0x57ba
xorl %ebx, %ebx
xorl %ebp, %ebp
movl (%rax), %edi
callq 0x4cb7
movq 0x3cf8(%rip), %rax      # 0x94c0
movl (%rax), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x4dd7
testb %al, %al
je 0x5842
movq 0x3cdc(%rip), %rax      # 0x94c0
movw %bp, 0x6(%rax)
movw %bx, 0x8(%rax)
movl (%rax), %edi
movzwl %bp, %esi
movzwl %bx, %edx
callq 0x4320
movq 0x3c90(%rip), %rdi      # 0x9490
movq 0x3cb9(%rip), %rax      # 0x94c0
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 0x3c59(%rip), %rdi      # 0x9490
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2150
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3aa9(%rip), %rax      # 0x94c0
testq %rax, %rax
je 0x5af4
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x5a33
movzwl 0x10(%rcx), %ebp
movzwl 0x12(%rcx), %ebx
jmp 0x5a3e
xorl %ebx, %ebx
movq 0x3a5c(%rip), %rcx      # 0x9498
xorl %ebp, %ebp
movzwl 0x16(%rcx), %r14d
movzwl 0x14(%rcx), %r15d
movl (%rax), %edi
callq 0x4cb7
movq 0x3a6a(%rip), %rax      # 0x94c0
movl (%rax), %edi
leaq 0x6(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x4dd7
testb %al, %al
je 0x5af4
movq 0x3a4a(%rip), %rax      # 0x94c0
movzwl 0xa(%rax), %ecx
movl 0x39f0(%rip), %edx      # 0x9470
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 0x4320
movq 0x39e2(%rip), %rdi      # 0x9490
movq 0x3a0b(%rip), %rax      # 0x94c0
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 0x39ab(%rip), %rdi      # 0x9490
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
// File: /workspace/github_c_makefile_star2_O1/mchackorg[P]mcwm/mcwm.c
// Function: deletewin
void deletewin(void)
{
    xcb_get_property_cookie_t cookie;
    xcb_icccm_get_wm_protocols_reply_t protocols;
    bool use_delete = false;
    uint32_t i;

    if (NULL == focuswin)
    {
        return;
    }

    /* Check if WM_DELETE is supported.  */
    cookie = xcb_icccm_get_wm_protocols_unchecked(conn, focuswin->id,
                                                  wm_protocols);
    if (xcb_icccm_get_wm_protocols_reply(conn, cookie, &protocols, NULL) == 1)
    {
        for (i = 0; i < protocols.atoms_len; i++)
        {
            if (protocols.atoms[i] == wm_delete_window)
            {
                 use_delete = true;
            }
        }
    }

    xcb_icccm_get_wm_protocols_reply_wipe(&protocols);

    if (use_delete)
    {
        xcb_client_message_event_t ev = {
          .response_type = XCB_CLIENT_MESSAGE,
          .format = 32,
          .sequence = 0,
          .window = focuswin->id,
          .type = wm_protocols,
          .data.data32 = { wm_delete_window, XCB_CURRENT_TIME }
        };

        xcb_send_event(conn, false, focuswin->id,
                       XCB_EVENT_MASK_NO_EVENT, (char *) &ev);
    }
    else
    {
        xcb_kill_client(conn, focuswin->id);
    }

    xcb_flush(conn);
}

// Assembly:
movq 0x39ba(%rip), %rax      # 0x94c0
testq %rax, %rax
je 0x5c07
pushq %rbx
subq $0x40, %rsp
movq 0x3975(%rip), %rdi      # 0x9490
movl (%rax), %esi
movl 0x398d(%rip), %edx      # 0x94b0
callq 0x2460
movq 0x3961(%rip), %rdi      # 0x9490
leaq 0x8(%rsp), %rdx
movl %eax, %esi
xorl %ecx, %ecx
callq 0x2110
cmpb $0x1, %al
jne 0x5bd7
movl 0x8(%rsp), %eax
testq %rax, %rax
je 0x5bd7
movq 0x10(%rsp), %rcx
movl 0x3947(%rip), %edx      # 0x94a4
xorl %esi, %esi
movl $0x1, %edi
xorl %ebx, %ebx
cmpl %edx, (%rcx,%rsi,4)
movzbl %bl, %ebx
cmovel %edi, %ebx
incq %rsi
cmpq %rsi, %rax
jne 0x5b66
leaq 0x8(%rsp), %rdi
callq 0x20a0
testb $0x1, %bl
je 0x5be1
leaq 0x20(%rsp), %r8
movl $0x2021, (%r8)          # imm = 0x2021
movq 0x3927(%rip), %rax      # 0x94c0
movl (%rax), %ecx
movl %ecx, 0x4(%r8)
movl 0x390b(%rip), %ecx      # 0x94b0
movl %ecx, 0x8(%r8)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r8)
movl $0x0, 0x1c(%r8)
movl 0x38e5(%rip), %ecx      # 0x94a4
movl %ecx, 0xc(%r8)
movq 0x38c6(%rip), %rdi      # 0x9490
movl (%rax), %edx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x2450
jmp 0x5bf6
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x38a8(%rip), %rdi      # 0x9490
movq 0x38d1(%rip), %rax      # 0x94c0
movl (%rax), %esi
callq 0x2530
movq 0x3893(%rip), %rdi      # 0x9490
callq 0x2150
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mchackorg[P]mcwm/mcwm.c
// Function: prevscreen
void prevscreen(void)
{
    struct item *item;

    if (NULL == focuswin || NULL == focuswin->monitor)
    {
        return;
    }

    item = focuswin->monitor->item->prev;

    if (NULL == item)
    {
        return;
    }

    focuswin->monitor = item->data;

    raisewindow(focuswin->id);
    fitonscreen(focuswin);
    movelim(focuswin);

    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     0, 0);
    xcb_flush(conn);
}

// Assembly:
movq 0x38b1(%rip), %rax      # 0x94c0
testq %rax, %rax
je 0x5c8a
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x5c8a
movq 0x18(%rcx), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5c8a
pushq %rax
movq (%rcx), %rcx
movq %rcx, 0x38(%rax)
movl (%rax), %edi
callq 0x4cb7
movq 0x3880(%rip), %rdi      # 0x94c0
callq 0x283e
movq 0x3874(%rip), %rdi      # 0x94c0
callq 0x5200
movq 0x3838(%rip), %rdi      # 0x9490
movq 0x3861(%rip), %rax      # 0x94c0
movl (%rax), %edx
subq $0x8, %rsp
xorl %eax, %eax
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2050
addq $0x20, %rsp
movq 0x380c(%rip), %rdi      # 0x9490
popq %rax
jmp 0x2150
retq
// File: /workspace/github_c_makefile_star2_O1/mchackorg[P]mcwm/mcwm.c
// Function: nextscreen
void nextscreen(void)
{
    struct item *item;

    if (NULL == focuswin || NULL == focuswin->monitor)
    {
        return;
    }

    item = focuswin->monitor->item->next;

    if (NULL == item)
    {
        return;
    }

    focuswin->monitor = item->data;

    raisewindow(focuswin->id);
    fitonscreen(focuswin);
    movelim(focuswin);

    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     0, 0);
    xcb_flush(conn);
}

// Assembly:
movq 0x382e(%rip), %rax      # 0x94c0
testq %rax, %rax
je 0x5d0d
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x5d0d
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x5d0d
pushq %rax
movq (%rcx), %rcx
movq %rcx, 0x38(%rax)
movl (%rax), %edi
callq 0x4cb7
movq 0x37fd(%rip), %rdi      # 0x94c0
callq 0x283e
movq 0x37f1(%rip), %rdi      # 0x94c0
callq 0x5200
movq 0x37b5(%rip), %rdi      # 0x9490
movq 0x37de(%rip), %rax      # 0x94c0
movl (%rax), %edx
subq $0x8, %rsp
xorl %eax, %eax
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2050
addq $0x20, %rsp
movq 0x3789(%rip), %rdi      # 0x9490
popq %rax
jmp 0x2150
retq
// File: /workspace/github_c_makefile_star2_O1/mchackorg[P]mcwm/mcwm.c
// Function: hide
void hide(struct client *client)
{
    long data[] = { XCB_ICCCM_WM_STATE_ICONIC, XCB_NONE };

    /*
     * Unmap window and declare iconic.
     *
     * Unmapping will generate an UnmapNotify event so we can forget
     * about the window later.
     */
    xcb_unmap_window(conn, client->id);
    xcb_change_property(conn, XCB_PROP_MODE_REPLACE, client->id,
                        wm_state, wm_state, 32, 2, data);
    xcb_flush(conn);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0x8f1(%rip), %xmm0      # 0x6610
movq %rsp, %r14
movaps %xmm0, (%r14)
movq 0x3763(%rip), %rdi      # 0x9490
movl (%rbx), %esi
callq 0x20d0
movq 0x3755(%rip), %rdi      # 0x9490
movl (%rbx), %edx
movl 0x3769(%rip), %ecx      # 0x94ac
xorl %esi, %esi
movl %ecx, %r8d
movl $0x20, %r9d
pushq %r14
pushq $0x2
callq 0x2520
addq $0x10, %rsp
movq 0x372e(%rip), %rdi      # 0x9490
callq 0x2150
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aegis128/ref/encrypt.c
// Function: aegis128_initialization
void aegis128_initialization(const unsigned char *key, const unsigned char *iv, unsigned char *state)
{
        int i;
        unsigned char constant[32] = {0x0,0x1,0x01,0x02,0x03,0x05,0x08,0x0d,0x15,0x22,0x37,0x59,0x90,0xe9,0x79,0x62,0xdb,0x3d,0x18,0x55,0x6d,0xc2,0x2f,0xf1,0x20,0x11,0x31,0x42,0x73,0xb5,0x28,0xdd};

        unsigned char tmp[16];
        unsigned char keytmp[16];
        unsigned char ivtmp[16];

        memcpy(keytmp, key, 16);
        memcpy(ivtmp, iv, 16);

        memcpy(state, ivtmp, 16);
        memcpy(state+16, constant+16, 16);
        memcpy(state+32, constant+0,  16);

        XOR128(state+48, keytmp,  constant);
        XOR128(state+64, keytmp,  constant + 16);
        XOR128(state,    state,   keytmp);
        XOR128(keytmp,   keytmp,  ivtmp);

        for (i = 0; i < 10; i++)  {
             //state update function
             memcpy(tmp, state+64, 16);
             AESROUND(state+64, state+48, state+64);
             AESROUND(state+48, state+32, state+48);
             AESROUND(state+32, state+16, state+32);
             AESROUND(state+16, state+0,  state+16);
             AESROUND(state+0,  tmp,      state+0);

             //xor msg with state[0]
             XOR128(keytmp, keytmp, ivtmp);
             XOR128(state,  state,  keytmp);
        }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
leaq 0x10(%rdx), %r14
leaq 0x20(%rdx), %r15
leaq 0x30(%rdx), %r12
vmovdqu (%rsi), %xmm2
vmovaps 0x1d83(%rip), %ymm0     # 0x3000
vbroadcasti128 (%rdi), %ymm1   # ymm1 = mem[0,1,0,1]
vmovups %ymm0, 0x10(%rdx)
vpxor 0x1d91(%rip), %ymm1, %ymm0 # 0x3020
vmovdqu %ymm0, 0x30(%rdx)
leaq 0x40(%rdx), %r13
vmovdqa %xmm2, (%rsp)
vpxor %xmm1, %xmm2, %xmm1
vmovdqu %xmm1, (%rdx)
movl $0xa, %ebp
vmovdqa %xmm1, 0x10(%rsp)
vmovups (%r13), %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
vzeroupper
callq 0x1040
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1040
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1040
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1040
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x1040
vmovdqa 0x10(%rsp), %xmm1
vpxor (%rsp), %xmm1, %xmm1
vpxor (%rbx), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
decl %ebp
jne 0x12aa
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aegis128/ref/encrypt.c
// Function: aegis128_tag_generation
void aegis128_tag_generation(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, unsigned char *state)
{
       int i;

        unsigned char tmp[16];
        unsigned char msgtmp[16];

        ((unsigned long long*)msgtmp)[0] = adlen << 3;
        ((unsigned long long*)msgtmp)[1] = msglen << 3;

        XOR128(msgtmp, msgtmp, state+48);

        for (i = 0; i < 7; i++) {
             //state update function
             memcpy(tmp, state+64, 16);

             AESROUND(state+64, state+48, state+64);
             AESROUND(state+48, state+32, state+48);
             AESROUND(state+32, state+16, state+32);
             AESROUND(state+16, state+0,  state+16);
             AESROUND(state+0,  tmp,      state+0);

             //xor "msg" with state[0]
             XOR128(state, state, msgtmp);
        }

        XOR128(state+64, state+64, state+48);
        XOR128(state+64, state+64, state+32);
        XOR128(state+64, state+64, state+16);
        XOR128(state+64, state+64, state+0);

        //in this program, the mac length is assumed to be multiple of bytes
        memcpy(mac, state+64, maclen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, 0x8(%rsp)
movl %edx, 0x4(%rsp)
vmovq %rdi, %xmm0
vmovq %rsi, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vpsllq $0x3, %xmm0, %xmm0
vpxor 0x30(%r8), %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
leaq 0x30(%r8), %r12
leaq 0x40(%r8), %r15
leaq 0x20(%r8), %r13
leaq 0x10(%r8), %rbx
movl $0x7, %ebp
vmovups (%r15), %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1040
movq %r12, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1040
movq %r13, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1040
movq %rbx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1040
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x1040
vmovdqa 0x10(%rsp), %xmm0
vpxor (%r14), %xmm0, %xmm0
vmovdqu %xmm0, (%r14)
decl %ebp
jne 0x137b
vmovdqu 0x10(%r14), %xmm0
vmovdqu 0x20(%r14), %xmm1
vmovdqu 0x30(%r14), %xmm2
vpternlogq $0x96, 0x40(%r14), %xmm1, %xmm2
vpternlogq $0x96, (%r14), %xmm0, %xmm2
vmovdqu %xmm2, 0x40(%r14)
movzbl 0x4(%rsp), %edx
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x10a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/./haxsh.c
// Function: cmdCheckmem
int
cmdCheckmem(
    ClientData clientData,
    Hax_Interp *interp,
    int argc,
    char *argv[])
{
    if (argc != 1) {
	Hax_AppendResult(interp, "wrong # args: should be \"", argv[0],
		"\"", (char *) NULL);
	return HAX_ERROR;
    }
    quitFlag = 1;
    return HAX_OK;
}

// Assembly:
cmpl $0x1, %edx
jne 0x128e
movl $0x1, 0x2e4d(%rip)      # 0x40d8
xorl %eax, %eax
retq
pushq %rax
movq (%rcx), %rdx
leaq 0xd6b(%rip), %rax       # 0x2004
leaq 0xd7c(%rip), %rcx       # 0x201c
movq %rsi, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1120
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/haxlang[P]hax/./haxsh.c
// Function: cmdEcho
int
cmdEcho(
    ClientData clientData,
    Hax_Interp *interp,
    int argc,
    char *argv[])
{
    int i;

    for (i = 1; ; i++) {
	if (argv[i] == NULL) {
	    if (i != argc) {
		echoError:
		sprintf(interp->result,
		    "argument list wasn't properly NULL-terminated in \"%s\" command",
		    argv[0]);
	    }
	    break;
	}
	if (i >= argc) {
	    goto echoError;
	}
	fputs(argv[i], stdout);
	if (i < (argc-1)) {
	    printf(" ");
	}
    }
    printf("\n");
    return HAX_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, (%rsp)
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
je 0x1324
leal -0x1(%r15), %eax
movslq %eax, %r13
cmpl $0x2, %r15d
movl $0x1, %ebp
cmovgel %r15d, %ebp
movl $0x1, %r12d
movq 0x2cdf(%rip), %r14      # 0x3fd8
cmpq %r12, %rbp
je 0x132f
movq (%r14), %rsi
callq 0x1090
cmpq %r13, %r12
jge 0x1315
movl $0x20, %edi
callq 0x1040
movq 0x8(%rbx,%r12,8), %rdi
incq %r12
testq %rdi, %rdi
jne 0x12f9
jmp 0x132a
movl $0x1, %r12d
cmpl %r15d, %r12d
je 0x1347
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xcde(%rip), %rsi       # 0x201e
xorl %eax, %eax
callq 0x1130
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Keith-S-Thompson[P]kst-time-utils/timer.c
// Function: usage
static void usage(const char *prog_name, const char *message) {
    if (message != NULL) {
        puts(message);
    }
    printf("Usage: %s [options]\n", prog_name);
    puts("    -a : Absolute time (default is zero-based)");
    puts("    -A : Absolute local time, human-readable");
    puts("    -U : Absolute UTC time, human-readable");
    puts("    -r : Show time interval relative to previous line");
    puts("    -b : Buffered output (default is unbuffered)");
    puts("    -h : Help (show this message and exit)");
    puts("    -z : Zero-based time (redundant, this is the default)");
    puts("    -u : Unbuffered output (redundant, this is the default)");
    puts("    -o file : Print output to specified file");
    exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1514
movq %rsi, %rdi
callq 0x1030
leaq 0xb71(%rip), %rdi       # 0x208c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xb75(%rip), %rdi       # 0x20a1
callq 0x1030
leaq 0xb98(%rip), %rdi       # 0x20d0
callq 0x1030
leaq 0xbb9(%rip), %rdi       # 0x20fd
callq 0x1030
leaq 0xbd8(%rip), %rdi       # 0x2128
callq 0x1030
leaq 0xc02(%rip), %rdi       # 0x215e
callq 0x1030
leaq 0xc27(%rip), %rdi       # 0x218f
callq 0x1030
leaq 0xc46(%rip), %rdi       # 0x21ba
callq 0x1030
leaq 0xc74(%rip), %rdi       # 0x21f4
callq 0x1030
leaq 0xca4(%rip), %rdi       # 0x2230
callq 0x1030
xorl %edi, %edi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O1/Keith-S-Thompson[P]kst-time-utils/timer.c
// Function: show_time
static void show_time(FILE *stream, bool real_time_too) {
    struct timeval tv;
    int result = gettimeofday(&tv, NULL);
    if (result == 0) {
        if (! t0_initialized) {
            t0 = tv;
            t0_initialized = true;
        }
        if (absolute || absolute_readable) {
            show_timeval(stream, tv);
        }
        else {
            show_timeval(stream, diff(tv, t0));
            if (real_time_too) {
                fprintf(stream, " [");
                show_timeval(stream, tv);
                fprintf(stream, "]");
            }
        }
        if (relative) {
            t0 = tv;
        }
    }
    else {
        fprintf(stream, "---------.------");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1070
testl %eax, %eax
je 0x15da
leaq 0xca2(%rip), %rdi       # 0x2260
movl $0x10, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1130
cmpb $0x0, 0x2adc(%rip)      # 0x40bd
jne 0x15f6
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x2ad1(%rip)     # 0x40c0
movb $0x1, 0x2ac7(%rip)      # 0x40bd
cmpb $0x0, 0x2abb(%rip)      # 0x40b8
jne 0x1608
cmpb $0x1, 0x2ab3(%rip)      # 0x40b9
jne 0x163a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x16b6
cmpb $0x1, 0x2a9a(%rip)      # 0x40bb
jne 0x162f
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x2a91(%rip)     # 0x40c0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r14
movq %r14, %rax
subq 0x2a77(%rip), %rax      # 0x40c0
movq 0x10(%rsp), %r15
movq %r15, %rcx
subq 0x2a70(%rip), %rcx      # 0x40c8
leaq 0xf4240(%rcx), %rdx
movq %rcx, %rsi
sarq $0x3f, %rsi
addq %rax, %rsi
testq %rcx, %rcx
cmovnsq %rcx, %rdx
movq %rbx, %rdi
callq 0x16b6
testb %bpl, %bpl
je 0x161a
leaq 0xbd9(%rip), %rdi       # 0x225d
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1130
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x16b6
movl $0x5d, %edi
movq %rbx, %rsi
callq 0x1090
jmp 0x161a
// File: /workspace/github_c_makefile_star2_O1/Keith-S-Thompson[P]kst-time-utils/timer.c
// Function: show_timeval
static void show_timeval(FILE *stream, struct timeval tv) {
    if (absolute_readable) {
        // YYYY-MM-DD-HH:MM:SS-mmmmmm
        struct tm *ltime = (utc ? gmtime : localtime)(&tv.tv_sec);
        char format[100];
        sprintf(format, "%%F-%%T.%06ld%s", tv.tv_usec, utc ? "Z" : "");
        char buf[100];
        strftime(buf, sizeof buf, format, ltime);
        fputs(buf, stream);
    }
    else {
        fprintf(stream, absolute ? "%10ld.%06ld" : "%8ld.%06ld",
                        (long)tv.tv_sec,
                        (long)tv.tv_usec);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rcx
movq %rdi, %rbx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpb $0x1, 0x29df(%rip)      # 0x40b9
jne 0x16ee
cmpb $0x0, 0x29d7(%rip)      # 0x40ba
je 0x1722
movq 0x28fc(%rip), %rax      # 0x3fe8
jmp 0x1729
movq %rsi, %rdx
leaq 0xb8b(%rip), %rax       # 0x2283
cmpb $0x0, 0x29b9(%rip)      # 0x40b8
leaq 0xb89(%rip), %rsi       # 0x228f
cmovneq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10d0
movq 0x288f(%rip), %rax      # 0x3fb8
movq %rsp, %r14
movq %r14, %rdi
callq *%rax
movq %rax, %r15
movq 0x8(%r14), %rdx
leaq 0xb42(%rip), %rax       # 0x2281
leaq 0x95a(%rip), %rcx       # 0x20a0
cmpb $0x0, 0x296d(%rip)      # 0x40ba
cmovneq %rax, %rcx
leaq 0xb19(%rip), %rsi       # 0x2271
leaq 0x80(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x1110
leaq 0x10(%rsp), %r12
movl $0x64, %esi
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x10e0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1080
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq