LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x40(%rsp), %eax
movslq 0x3c(%rsp), %rcx
movslq 0x38(%rsp), %rdx
movq 0x48(%rsp), %rsi
movq 0x60(%rsp), %r8
movslq %edi, %r9
movq %r9, -0x48(%rsp)
negl %edi
movl %edi, -0x58(%rsp)
xorl %r9d, %r9d
testl %edx, %edx
movl $0x0, %edi
cmovgl %edx, %edi
movq %rdi, -0x8(%rsp)
testl %ecx, %ecx
movl $0x0, %edi
cmovgl %ecx, %edi
movq %rdi, -0x28(%rsp)
testl %eax, %eax
movl $0x0, %edi
movq %rdi, -0x50(%rsp)
cmovlel %r9d, %eax
movq %rax, -0x40(%rsp)
leaq (,%rdx,4), %r14
xorl %eax, %eax
cmpq -0x40(%rsp), %rax
je 0x485bc
movq %rax, %rdi
imulq %rcx, %rdi
movq %rdi, -0x38(%rsp)
xorl %edi, %edi
movl -0x58(%rsp), %r9d
movq %rax, -0x30(%rsp)
cmpq -0x28(%rsp), %rdi
je 0x485af
movl %r9d, -0x54(%rsp)
movslq %r9d, %r9
movq -0x50(%rsp), %rax
movq %r9, -0x10(%rsp)
leaq (%rax,%r9), %r11
imulq %r14, %r11
addq %rsi, %r11
movq -0x38(%rsp), %rax
addq %rdi, %rax
imulq %rdx, %rax
movq %rax, -0x18(%rsp)
movq -0x48(%rsp), %rax
movq %rdi, -0x20(%rsp)
addq %rax, %rdi
xorl %ebx, %ebx
movl -0x58(%rsp), %r12d
cmpq -0x8(%rsp), %rbx
je 0x48595
movslq %r12d, %r10
movq -0x18(%rsp), %rax
leaq (%rax,%rbx), %r13
movq -0x48(%rsp), %rax
leaq (%rbx,%rax), %r9
movq %r11, %r15
movq -0x10(%rsp), %rax
cmpq %rdi, %rax
jg 0x4858d
cmpq %rcx, %rax
jge 0x4858d
testq %rax, %rax
js 0x48585
movq %r10, %rbp
cmpq %r9, %rbp
jg 0x48585
cmpq %rdx, %rbp
jge 0x48585
testq %rbp, %rbp
js 0x48580
movss (%r15,%rbp,4), %xmm1
subss (%rsi,%r13,4), %xmm1
mulss %xmm0, %xmm1
addss (%r8,%r13,4), %xmm1
movss %xmm1, (%r8,%r13,4)
incq %rbp
jmp 0x48555
incq %rax
addq %r14, %r15
jmp 0x48543
incq %rbx
incl %r12d
jmp 0x4851f
movq -0x20(%rsp), %rdi
incq %rdi
movl -0x54(%rsp), %r9d
incl %r9d
movq -0x30(%rsp), %rax
jmp 0x484d2
incq %rax
addq %rcx, -0x50(%rsp)
jmp 0x484af
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsp), %r12
movq 0x98(%rsp), %r15
xorl %r13d, %r13d
testl %ecx, %ecx
cmovgl %ecx, %r13d
pushq $0x1
popq %rbp
subl $0x1, %r13d
jb 0x48724
movl (%r12), %esi
movl 0x4(%r12), %edx
movl 0x8(%r12), %ecx
leaq 0x20(%rsp), %rdi
callq 0xb45a
movq 0x10(%r12), %rax
movq %rax, 0xd8(%r14)
movq 0x30(%rsp), %rax
movq %rax, 0xe8(%r14)
movq %rbx, 0xe0(%r14)
movq %r14, %rdi
callq 0x2294b
movq %r14, %rdi
callq 0x22bd7
movl 0x4(%r12), %edi
imull (%r12), %edi
imull 0x8(%r12), %edi
movq 0x30(%rsp), %rsi
movss 0x399a(%rip), %xmm0     # 0x4c008
movl %ebp, %edx
movq %r15, %rcx
movl %ebp, %r8d
callq 0x1b3ed
movl 0x4(%r12), %edi
imull (%r12), %edi
imull 0x8(%r12), %edi
movq 0x10(%r12), %rcx
movss 0x18(%rsp), %xmm0
movq %r15, %rsi
movl %ebp, %edx
movl %ebp, %r8d
callq 0x1b3ed
movl 0x4(%r12), %edi
imull (%r12), %edi
imull 0x8(%r12), %edi
movss 0x1c(%rsp), %xmm0
movq %r15, %rsi
movl %ebp, %edx
callq 0x1b423
movq 0x30(%rsp), %rdi
movl 0x4(%r12), %esi
imull (%r12), %esi
imull 0x8(%r12), %esi
callq 0x4b4c
cvtss2sd %xmm0, %xmm0
leaq 0x9c85(%rip), %rdi      # 0x5236d
movb $0x1, %al
callq 0x3160
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0xd231
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0xba88
jmp 0x48600
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27071
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x22f00
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x3bc0
movsd %xmm0, (%rsp)
movl 0x94(%r14), %esi
movl 0x4(%r14), %ecx
movl 0x90(%r14), %edx
imull 0x98(%r14), %ecx
leaq 0x18(%rsp), %rdi
callq 0xb45a
testl %ebx, %ebx
cmovgl %ebx, %ebp
subl $0x1, %ebp
jb 0x4a256
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x233e2
jmp 0x4a242
xorl %eax, %eax
callq 0x3bc0
subsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x49f8e
movq %rax, %r14
leaq 0x824b(%rip), %rdi      # 0x524c4
movl %ebx, %esi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x3160
cvtsi2ss %r14, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x1f18(%rip), %xmm0     # 0x4c1b0
movsd %xmm0, 0x10(%rsp)
leaq 0x8236(%rip), %rdi      # 0x524db
movb $0x1, %al
callq 0x3160
cvtsi2sd %ebx, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
divsd (%rsp), %xmm1
movapd %xmm1, %xmm0
leaq 0x822f(%rip), %rdi      # 0x524ff
movb $0x1, %al
callq 0x3160
movsd (%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
leaq 0x8226(%rip), %rdi      # 0x5250f
movb $0x1, %al
callq 0x3160
movsd 0x8(%rsp), %xmm0
divsd (%rsp), %xmm0
leaq 0x8221(%rip), %rdi      # 0x52523
movb $0x1, %al
callq 0x3160
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a4a6(%rip), %rax     # 0x647c0
orl $-0x1, (%rax)
callq 0x27071
movq %rax, %rdi
callq 0x49f8e
movq %rax, %rbx
leaq 0x81fd(%rip), %rdi      # 0x52531
movq %rax, %rsi
xorl %eax, %eax
callq 0x3160
cvtsi2ss %rbx, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x1e61(%rip), %xmm0     # 0x4c1b0
leaq 0x8185(%rip), %rdi      # 0x524db
movb $0x1, %al
popq %rbx
jmp 0x3160
// File: /workspace/github_c_makefile_star2_O2/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 0x1a248(%rip), %rax     # 0x647c0
orl $-0x1, (%rax)
callq 0x27071
movq %rax, %r14
testq %r15, %r15
je 0x4a5a8
movl (%r14), %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x28f72
movl (%r14), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x28f72
movq 0x8(%r14), %rax
andq $0x0, (%rax)
movl (%r14), %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x285e9
// File: /workspace/github_c_makefile_star2_O2/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 0x1a1b2(%rip), %rax     # 0x647c0
orl $-0x1, (%rax)
pushq $0x1
popq %rdx
callq 0x22658
movq 0x20(%rax), %rax
movslq %ebx, %rcx
imulq $0x4a0, %rcx, %rcx      # imm = 0x4A0
movl 0x90(%rax,%rcx), %edx
imull %edx, %edx
imull 0x74(%rax,%rcx), %edx
xorl %r15d, %r15d
testl %edx, %edx
movl $0x0, %r12d
movl %edx, 0x4(%rsp)
cmovgl %edx, %r12d
movl 0x84(%rax,%rcx), %edx
testl %edx, %edx
cmovlel %r15d, %edx
movq %rdx, 0x10(%rsp)
movq 0x250(%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
leaq 0x7ee2(%rip), %r14      # 0x52551
xorl %ebp, %ebp
cmpq 0x10(%rsp), %rbp
je 0x4a6b3
movslq %r15d, %rax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax,4), %rbx
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x4a6a1
cvtss2sd (%rbx,%r13,4), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x3160
incq %r13
jmp 0x4a687
pushq $0xa
popq %rdi
callq 0x3060
incq %rbp
addl 0x4(%rsp), %r15d
jmp 0x4a671
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x4a0, %rsp            # imm = 0x4A0
movq %rdx, %rbx
leaq 0x1a0e8(%rip), %rax     # 0x647c0
orl $-0x1, (%rax)
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x22658
movq %rax, %r14
movslq (%rax), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x4a72c
movq 0x20(%r14), %rsi
cmpl $0x0, (%rsi,%r15)
je 0x4a709
incq %rcx
addq $0x4a0, %r15            # imm = 0x4A0
jmp 0x4a6ed
addq %r15, %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movss 0x1b3d(%rip), %xmm0     # 0x4c25c
movss 0x7d99(%rip), %xmm1     # 0x524c0
callq 0x6f4e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x4a0, %rsp            # imm = 0x4A0
popq %rbx
popq %r14
popq %r15
jmp 0x28aed
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x4a0, %rsp            # imm = 0x4A0
movq %rdx, %rbx
leaq 0x1a067(%rip), %rax     # 0x647c0
orl $-0x1, (%rax)
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x22658
movq %rax, %r14
movslq (%rax), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x4a79d
movq 0x20(%r14), %rsi
cmpl $0x0, (%rsi,%r15)
je 0x4a78a
incq %rcx
addq $0x4a0, %r15            # imm = 0x4A0
jmp 0x4a76e
addq %r15, %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6ea0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x4a0, %rsp            # imm = 0x4A0
popq %rbx
popq %r14
popq %r15
jmp 0x28aed
// File: /workspace/github_c_makefile_star2_O2/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 0x19ff1(%rip), %rax     # 0x647c0
orl $-0x1, (%rax)
xorl %r13d, %r13d
xorl %edx, %edx
callq 0x22658
movq %rax, %r14
leaq 0x4a8(%rsp), %r15
xorl %ebp, %ebp
movslq (%r14), %rax
cmpq %rax, %rbp
jge 0x4a935
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 0x4a84f
movl $0x94, %ecx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6a33
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 0x4a885
movl $0x94, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x24823
movl 0x4a8(%rsp), %ecx
movl 0x4e8(%rsp), %eax
cmpl $0x10, %ecx
jne 0x4a926
testl %eax, %eax
je 0x4a926
movq 0x898(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x24823
movq 0x8a8(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x24823
movq 0x8b8(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x24823
movq 0x8a0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x24823
movq 0x8b0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x24823
movq 0x8c0(%rsp), %rsi
movl $0x94, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x24823
incq %rbp
addq $0x4a0, %r13            # imm = 0x4A0
jmp 0x4a7e9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x948, %rsp            # imm = 0x948
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28aed
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x1, 0x40(%r14)
movslq %esi, %r15
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x3250
movq %rax, 0x240(%r14)
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
cmpq %rcx, %rdx
je 0x4a99d
movl $0x3f800000, (%rax,%rcx,4) # imm = 0x3F800000
incq %rcx
jmp 0x4a98c
pushq $0x4
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3250
movq %rax, 0x2b0(%r14)
movq %r15, %rdi
movq %r12, %rsi
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_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movabsq $0x3fffffffffffffff, %r14 # imm = 0x3FFFFFFFFFFFFFFF
cmpq $0x2, %r15
jl 0x1380
movq %r14, %rax
xorl %edx, %edx
divq %r15
movq %rdx, %r12
xorq %r14, %r12
callq 0x11b0
movslq %eax, %r13
shlq $0x1f, %r13
callq 0x11b0
cltq
addq %r13, %rax
cmpq %r12, %rax
jge 0x1337
leaq -0x1(%r15), %rcx
cqto
idivq %r15
shlq $0x4, %rdx
movups (%rbx,%rdx), %xmm0
movaps %xmm0, (%rsp)
movq %rcx, %r15
shlq $0x4, %rcx
movups (%rbx,%rcx), %xmm0
movups %xmm0, (%rbx,%rdx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx,%rcx)
jmp 0x1323
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x20(%rdi)
leaq 0xebe(%rip), %rsi       # 0x2000
leaq 0xee2(%rip), %rdx       # 0x202b
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1030
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x28, %rsp
testq %rdi, %rdi
je 0x5a8a
movq %rdi, %rbx
cmpb $0x0, 0x31(%rdi)
jne 0x5a8a
movl %esi, %ebp
movl (%rbx), %edi
leaq 0x26(%rsp), %rsi
leaq 0x24(%rsp), %rdx
callq 0x5249
testb %al, %al
je 0x5a8a
movl (%rbx), %edi
callq 0x5122
movsbl %bpl, %eax
addl $-0x68, %eax
cmpl $0x4, %eax
ja 0x5a1c
leaq 0x75b(%rip), %rcx       # 0x6154
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addw $-0x20, 0x6(%rbx)
jmp 0x5a1c
addw $-0x20, 0x8(%rbx)
jmp 0x5a1c
addw $0x20, 0x8(%rbx)
jmp 0x5a1c
addw $0x20, 0x6(%rbx)
movq %rbx, %rdi
callq 0x5685
movswl 0x26(%rsp), %eax
movl 0x3a41(%rip), %ecx      # 0x9470
movl %ecx, %edx
negl %edx
cmpl %edx, %eax
jle 0x5a8a
movzwl 0xa(%rbx), %esi
addl %ecx, %esi
cmpl %eax, %esi
jle 0x5a8a
movswl 0x24(%rsp), %esi
cmpl %edx, %esi
jle 0x5a8a
movzwl 0xc(%rbx), %edx
addl %edx, %ecx
cmpl %esi, %ecx
jle 0x5a8a
movq 0x3a35(%rip), %rdi      # 0x9490
movl (%rbx), %edx
andl $0x0, (%rsp)
movl %esi, 0x10(%rsp)
movl %eax, 0x8(%rsp)
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2050
movq 0x3a11(%rip), %rdi      # 0x9490
addq $0x28, %rsp
popq %rbx
popq %rbp
jmp 0x2150
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mchackorg[P]mcwm/mcwm.c
// Function: unmax
void unmax(struct client *client)
{
    uint32_t values[5];
    uint32_t mask = 0;

    if (NULL == client)
    {
        PDEBUG("unmax: client was NULL!\n");
        return;
    }

    client->x = client->origsize.x;
    client->y = client->origsize.y;
    client->width = client->origsize.width;
    client->height = client->origsize.height;

    /* Restore geometry. */
    if (client->maxed)
    {
        values[0] = client->x;
        values[1] = client->y;
        values[2] = client->width;
        values[3] = client->height;

        /* Set borders again. */
        values[4] = conf.borderwidth;

        mask =
            XCB_CONFIG_WINDOW_X
            | XCB_CONFIG_WINDOW_Y
            | XCB_CONFIG_WINDOW_WIDTH
            | XCB_CONFIG_WINDOW_HEIGHT
            | XCB_CONFIG_WINDOW_BORDER_WIDTH;
    }
    else
    {
        values[0] = client->y;
        values[1] = client->width;
        values[2] = client->height;

        mask = XCB_CONFIG_WINDOW_Y
            | XCB_CONFIG_WINDOW_WIDTH
            | XCB_CONFIG_WINDOW_HEIGHT;
    }

    xcb_configure_window(conn, client->id, mask, values);

    /* Warp pointer to window or we might lose it. */
    xcb_warp_pointer(conn, XCB_NONE, client->id, 0, 0, 0, 0,
                     client->width / 2, client->height / 2);

    xcb_flush(conn);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0xe(%rdi), %rax
movq %rax, %xmm0
movq %rax, 0x6(%rdi)
cmpb $0x1, 0x31(%rdi)
jne 0x5ad4
pextrw $0x1, %xmm0, %eax
pextrw $0x3, %xmm0, %ecx
cwtl
movl %ecx, 0x2c(%rsp)
movl 0x39af(%rip), %ecx      # 0x9470
movl %ecx, 0x30(%rsp)
movd %xmm0, %ecx
pextrw $0x2, %xmm0, %esi
movw $0x1f, %dx
jmp 0x5ae7
pextrw $0x2, %xmm0, %eax
pextrw $0x1, %xmm0, %ecx
pextrw $0x3, %xmm0, %esi
movw $0xe, %dx
movzwl %si, %esi
movswl %cx, %edi
leaq 0x20(%rsp), %rcx
movl %edi, (%rcx)
movl %eax, 0x4(%rcx)
movl %esi, 0x8(%rcx)
movq 0x398f(%rip), %rdi      # 0x9490
movl (%rbx), %esi
movzwl %dx, %edx
callq 0x2200
movq 0x397e(%rip), %rdi      # 0x9490
movl (%rbx), %edx
movzwl 0xa(%rbx), %eax
shrl %eax
movzwl 0xc(%rbx), %ecx
shrl %ecx
andl $0x0, (%rsp)
movl %ecx, 0x10(%rsp)
movl %eax, 0x8(%rsp)
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2050
movq 0x394e(%rip), %rdi      # 0x9490
callq 0x2150
addq $0x40, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0xd63(%rip), %ymm0      # 0x2000
vbroadcasti128 (%rdi), %ymm1   # ymm1 = mem[0,1,0,1]
vmovups %ymm0, 0x10(%rdx)
vpxor 0xd71(%rip), %ymm1, %ymm0 # 0x2020
vmovdqu %ymm0, 0x30(%rdx)
leaq 0x40(%rdx), %r13
vmovdqa %xmm2, (%rsp)
vpxor %xmm1, %xmm2, %xmm1
vmovdqu %xmm1, (%rdx)
pushq $0xa
popq %rbp
subl $0x1, %ebp
jb 0x133f
vmovups (%r13), %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
vmovdqa %xmm1, 0x10(%rsp)
vzeroupper
callq 0x1050
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1050
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1050
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x1050
vmovdqa 0x10(%rsp), %xmm1
vpxor (%rsp), %xmm1, %xmm1
vpxor (%rbx), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
jmp 0x12c8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x7
popq %rbp
subl $0x1, %ebp
jb 0x1407
vmovups (%r15), %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1050
movq %r12, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1050
movq %r13, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1050
movq %rbx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1050
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x1050
vmovdqa 0x10(%rsp), %xmm0
vpxor (%r14), %xmm0, %xmm0
vmovdqu %xmm0, (%r14)
jmp 0x139d
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 0x10c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, 0x10(%rsp)
leal -0x1(%rdx), %eax
movq %rdx, 0x8(%rsp)
movslq %edx, %r13
movslq %eax, %r14
pushq $0x1
popq %r12
movq 0x2cf1(%rip), %r15      # 0x3fd8
pushq $0x20
popq %rbp
movq (%rbx,%r12,8), %rdi
testq %rdi, %rdi
je 0x1311
cmpq %r13, %r12
jge 0x1318
movq (%r15), %rsi
callq 0x1090
cmpq %r14, %r12
jge 0x130c
movl %ebp, %edi
callq 0x1040
incq %r12
jmp 0x12ea
cmpl %r12d, 0x8(%rsp)
je 0x1331
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xcf4(%rip), %rsi       # 0x201e
xorl %eax, %eax
callq 0x1130
pushq $0xa
popq %rdi
callq 0x1040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1470
movq %rsi, %rdi
callq 0x1030
leaq 0xbfa(%rip), %rdi       # 0x2071
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xbfe(%rip), %rdi       # 0x2086
callq 0x1030
leaq 0xc21(%rip), %rdi       # 0x20b5
callq 0x1030
leaq 0xc42(%rip), %rdi       # 0x20e2
callq 0x1030
leaq 0xc61(%rip), %rdi       # 0x210d
callq 0x1030
leaq 0xc8b(%rip), %rdi       # 0x2143
callq 0x1030
leaq 0xcb0(%rip), %rdi       # 0x2174
callq 0x1030
leaq 0xccf(%rip), %rdi       # 0x219f
callq 0x1030
leaq 0xcfd(%rip), %rdi       # 0x21d9
callq 0x1030
leaq 0xd2d(%rip), %rdi       # 0x2215
callq 0x1030
xorl %edi, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/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 0x1532
leaq 0xd2b(%rip), %rdi       # 0x2245
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1120
cmpb $0x0, 0x2b7c(%rip)      # 0x40b5
jne 0x154e
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x2b71(%rip)     # 0x40b8
movb $0x1, 0x2b67(%rip)      # 0x40b5
cmpb $0x0, 0x2b5b(%rip)      # 0x40b0
jne 0x1560
cmpb $0x1, 0x2b53(%rip)      # 0x40b1
jne 0x1592
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1608
cmpb $0x1, 0x2b3a(%rip)      # 0x40b3
jne 0x1587
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x2b31(%rip)     # 0x40b8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r14
movq %r14, %rax
subq 0x2b17(%rip), %rax      # 0x40b8
movq 0x10(%rsp), %r15
movq %r15, %rcx
subq 0x2b10(%rip), %rcx      # 0x40c0
leaq 0xf4240(%rcx), %rdx
movq %rcx, %rsi
sarq $0x3f, %rsi
addq %rax, %rsi
testq %rcx, %rcx
cmovnsq %rcx, %rdx
movq %rbx, %rdi
callq 0x1608
testb %bpl, %bpl
je 0x1572
leaq 0xc66(%rip), %rdi       # 0x2242
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1120
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1608
pushq $0x5d
popq %rdi
movq %rbx, %rsi
callq 0x1090
jmp 0x1572
// File: /workspace/github_c_makefile_star2_O2/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, 0x2a85(%rip)      # 0x40b1
jne 0x1640
cmpb $0x0, 0x2a7d(%rip)      # 0x40b2
je 0x1674
movq 0x29aa(%rip), %rax      # 0x3fe8
jmp 0x167b
movq %rsi, %rdx
leaq 0xc1e(%rip), %rax       # 0x2268
cmpb $0x0, 0x2a5f(%rip)      # 0x40b0
leaq 0xc1c(%rip), %rsi       # 0x2274
cmovneq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10c0
movq 0x293d(%rip), %rax      # 0x3fb8
movq %rsp, %r14
movq %r14, %rdi
callq *%rax
movq %rax, %r15
movq 0x8(%r14), %rdx
leaq 0xbd5(%rip), %rax       # 0x2266
leaq 0x9ed(%rip), %rcx       # 0x2085
cmpb $0x0, 0x2a13(%rip)      # 0x40b2
cmovneq %rax, %rcx
leaq 0xbac(%rip), %rsi       # 0x2256
leaq 0x80(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x10(%rsp), %r12
pushq $0x64
popq %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x10d0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1080
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_04/unlink.c
// Function: main
int main(int argc, char *argv[])
{
	int ret;

	if (argc < 2) {
		fprintf(stderr, "usage: %s <file>\n",
			argv[0]);
		return -1;
	}

	printf("unlinking %s\n", argv[1]);
	ret = unlink(argv[1]);
	if (ret < 0) {
		perror("link");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0x1, %edi
jle 0x11a3
movq 0x8(%r14), %rsi
leaq 0xe93(%rip), %rdi       # 0x2016
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1040
movq 0x8(%r14), %rdi
callq 0x1030
testl %eax, %eax
js 0x11c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2e4e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xe4d(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1050
jmp 0x11cc
leaq 0xe5d(%rip), %rdi       # 0x2024
callq 0x1060
pushq $-0x1
popq %rbx
jmp 0x1199
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/readfile.c
// Function: read_ushort
unsigned short
read_ushort(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    unsigned char rbuf[2];
    unsigned long curoffset;
    unsigned short value = 0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
        {
            printred(" SEEK FAILED to read unsigned short at offset ");
            printf("%lu",offset);
        }
        else if(fread(rbuf,1,sizeof(unsigned short),inptr) == sizeof(unsigned short))
            value = to_ushort(rbuf,byteorder);
        else
        {
            printred(" FAILED to read unsigned short value at offset ");
            if(offset == HERE)
                offset = curoffset;
            chpr += printf("%lu",offset);
        }
        if(ferror(inptr))
        {
            chpr += printf(" (");
            setcharsprinted(chpr);
            chpr = 0;
            printred(strerror(errno));
            chpr += printf(")");
            chpr = newline(chpr);
        }
        else if(feof(inptr))
        {
            printred(" (EOF)");
            chpr = newline(chpr);
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x41e3
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x31b0
movq %r14, %rdi
callq 0x3190
movq %rax, %r12
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
je 0x41b2
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x421b
leaq 0xe(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rcx
callq 0x30d0
cmpq $0x2, %rax
jne 0x41ec
movzwl 0xe(%rsp), %eax
movl %eax, %ebx
rolw $0x8, %bx
cmpw $0x4d4d, %r15w          # imm = 0x4D4D
cmovnel %eax, %ebx
xorl %ebp, %ebp
jmp 0x423a
xorl %ebx, %ebx
xorl %ebp, %ebp
jmp 0x42a4
leaq 0x3afe5(%rip), %rdi     # 0x3f1d8
callq 0x56e2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
cmovneq %rbx, %r12
leaq 0x426da(%rip), %rdi     # 0x468e5
xorl %ebx, %ebx
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x423a
leaq 0x3af87(%rip), %rdi     # 0x3f1a9
callq 0x56e2
leaq 0x426b7(%rip), %rdi     # 0x468e5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3120
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x4283
leaq 0x3afbb(%rip), %rdi     # 0x3f208
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x16a4f
callq 0x3070
movl (%rax), %edi
callq 0x32c0
movq %rax, %rdi
callq 0x56e2
leaq 0x428ed(%rip), %rdi     # 0x46b65
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x429b
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
je 0x42a4
leaq 0x3af75(%rip), %rdi     # 0x3f20b
callq 0x56e2
movl %ebp, %edi
callq 0x160f7
movl %eax, %ebp
movl %ebp, %edi
callq 0x16a4f
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/readfile.c
// Function: read_ulong
unsigned long
read_ulong(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    unsigned char rbuf[4];
    unsigned long curoffset;
    unsigned long value = 0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
        {
            printred(" SEEK FAILED to read unsigned 32bit integer at offset ");
            printf("%lu",offset);
        }
        else if(fread(rbuf,1,4,inptr) == 4)
            value = to_ulong(rbuf,byteorder);
        else
        {
            printred(" FAILED to read unsigned 32bit integer at offset ");
            if(offset == HERE)
                offset = curoffset;
            chpr += printf("%lu",offset);
        }
        if(ferror(inptr))
        {
            chpr += printf(" (");
            setcharsprinted(chpr);
            chpr = 0;
            printred(strerror(errno));
            chpr += printf(")");
            chpr = newline(chpr);
        }
        else if(feof(inptr))
        {
            printred(" (EOF)");
            chpr = newline(chpr);
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4330
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x31b0
movq %r14, %rdi
callq 0x3190
movq %rax, %r12
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
je 0x4302
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x436a
leaq 0xc(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movq %r14, %rcx
callq 0x30d0
cmpq $0x4, %rax
jne 0x433a
movl 0xc(%rsp), %eax
cmpw $0x4d4d, %bp            # imm = 0x4D4D
movl %eax, %ebx
bswapl %ebx
cmovnel %eax, %ebx
xorl %r15d, %r15d
jmp 0x4389
xorl %ebx, %ebx
xorl %r15d, %r15d
jmp 0x43f8
leaq 0x3af04(%rip), %rdi     # 0x3f245
callq 0x56e2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
cmovneq %rbx, %r12
leaq 0x4258c(%rip), %rdi     # 0x468e5
xorl %ebx, %ebx
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
jmp 0x4389
leaq 0x3aecf(%rip), %rdi     # 0x3f240
callq 0x56e2
leaq 0x42568(%rip), %rdi     # 0x468e5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3120
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x43d5
leaq 0x3ae6c(%rip), %rdi     # 0x3f208
xorl %eax, %eax
callq 0x3120
addl %eax, %r15d
movl %r15d, %edi
callq 0x16a4f
callq 0x3070
movl (%rax), %edi
callq 0x32c0
movq %rax, %rdi
callq 0x56e2
leaq 0x4279c(%rip), %rdi     # 0x46b65
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
jmp 0x43ed
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
je 0x43f8
leaq 0x3ae23(%rip), %rdi     # 0x3f20b
callq 0x56e2
movl %r15d, %edi
callq 0x160f7
movl %eax, %r15d
movl %r15d, %edi
callq 0x16a4f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/readfile.c
// Function: read_ubyte
unsigned short
read_ubyte(FILE *inptr,unsigned long offset)
{
    unsigned char rbuf[1];
    unsigned long curoffset;
    unsigned short value = 0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
        {
            printred(" SEEK FAILED to read unsigned byte at offset ");
            chpr += printf("%lu",offset);
        }
        else if(fread(rbuf,1,1,inptr) == 1)
            value = rbuf[0] & 0xff;
        else
        {
            if(offset == HERE)
                offset = curoffset;
            printred(" FAILED to read unsigned byte at offset ");
            chpr += printf("%lu",offset);
        }
        if(ferror(inptr))
        {
            chpr += printf(" (");
            setcharsprinted(chpr);
            chpr = 0;
            printred(strerror(errno));
            chpr += printf(")");
            chpr = newline(chpr);
        }
        else if(feof(inptr))
        {
            printred(" (EOF)");
            chpr = newline(chpr);
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4943
movq %rsi, %r15
movq %rdi, %r14
callq 0x31b0
movq %r14, %rdi
callq 0x3190
movq %rax, %r12
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r15
je 0x4921
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x4972
leaq 0xf(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rdx, %rsi
movq %r14, %rcx
callq 0x30d0
cmpq $0x1, %rax
jne 0x494c
movzbl 0xf(%rsp), %ebx
xorl %ebp, %ebp
jmp 0x4993
xorl %ebx, %ebx
xorl %ebp, %ebp
jmp 0x49fd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r15
cmovneq %r15, %r12
leaq 0x3a8b8(%rip), %rdi     # 0x3f217
callq 0x56e2
leaq 0x41f7a(%rip), %rdi     # 0x468e5
xorl %ebx, %ebx
movq %r12, %rsi
jmp 0x498a
leaq 0x3a899(%rip), %rdi     # 0x3f212
callq 0x56e2
leaq 0x41f60(%rip), %rdi     # 0x468e5
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x49dc
leaq 0x3a862(%rip), %rdi     # 0x3f208
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x16a4f
callq 0x3070
movl (%rax), %edi
callq 0x32c0
movq %rax, %rdi
callq 0x56e2
leaq 0x42194(%rip), %rdi     # 0x46b65
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x49f4
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
je 0x49fd
leaq 0x3a81c(%rip), %rdi     # 0x3f20b
callq 0x56e2
movl %ebp, %edi
callq 0x160f7
movl %eax, %ebp
movl %ebp, %edi
callq 0x16a4f
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/readfile.c
// Function: read_ulong64
unsigned long long
read_ulong64(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    unsigned char rbuf[sizeof(double)];
    unsigned long curoffset;
    unsigned long long value = 0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
            chpr += printf(" seek failed to offset %lu to read unsigned long\n",
                    offset);
        else if(fread(rbuf,1,sizeof(long long),inptr) == sizeof(long long))
            value = to_ulong64(rbuf,byteorder);
        else
        {
            printred(" FAILED to read unsigned 64bit integer at offset ");
            if(offset == HERE)
                offset = curoffset;
            chpr += printf("%lu\n",offset);
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x4a96
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
callq 0x31b0
movq %r12, %rdi
callq 0x3190
movq %rax, %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x4a6b
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x4ac2
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x8
popq %rdx
movq %r12, %rcx
callq 0x30d0
cmpq $0x8, %rax
jne 0x4a9b
movzwl %bp, %esi
leaq 0x8(%rsp), %rdi
callq 0x4aef
movq %rax, %r12
jmp 0x4ad8
xorl %r12d, %r12d
jmp 0x4ad8
leaq 0x3a807(%rip), %rdi     # 0x3f2a9
callq 0x56e2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
cmovneq %r14, %r15
leaq 0x3ed50(%rip), %rdi     # 0x4380a
xorl %r12d, %r12d
movq %r15, %rsi
jmp 0x4acf
leaq 0x3a7ae(%rip), %rdi     # 0x3f277
xorl %r12d, %r12d
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
movl %ebx, %edi
callq 0x16a4f
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq