LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/go.c
// Function: stdin_ready
int stdin_ready()
{
    fd_set readfds;
    FD_ZERO(&readfds);

    struct timeval timeout;
    timeout.tv_sec = 0;
    timeout.tv_usec = 0;
    FD_SET(STDIN_FILENO, &readfds);

    if (select(1, &readfds, NULL, NULL, &timeout)){
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
cmpq $0x10, %rax
jae 0x5b6a5
movq -0x98(%rbp), %rax
movl -0x8c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x5b673
jmp 0x5b6a7
movq $0x0, -0xa8(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0x88(%rbp), %rax
orq $0x1, %rax
movq %rax, -0x88(%rbp)
movl $0x1, %edi
leaq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa8(%rbp), %r8
movq %rcx, %rdx
callq 0x32a0
cmpl $0x0, %eax
je 0x5b6fc
movl $0x1, -0x4(%rbp)
jmp 0x5b703
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/go.c
// Function: ponder
mcts_tree *ponder(mcts_tree *tree, network *net, float *b, float *ko, int player, float cpuct)
{
    double t = what_time_is_it_now();
    int count = 0;
    if (tree) count = tree->total_count;
    while(!stdin_ready()){
        if (what_time_is_it_now() - t > 120) break;
        tree = run_mcts(tree, net, b, ko, player, 100000, cpuct, .1);
    }
    fprintf(stderr, "Pondered %d moves...\n", tree->total_count - count);
    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movss %xmm0, -0x28(%rbp)
movb $0x0, %al
callq 0x3f10
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5b755
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x5b757
callq 0x5b650
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5b76a
jmp 0x5b7b8
movb $0x0, %al
callq 0x3f10
subsd -0x30(%rbp), %xmm0
movsd 0x1a45a(%rip), %xmm1    # 0x75bd8
ucomisd %xmm1, %xmm0
jbe 0x5b786
jmp 0x5b7b8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movss -0x28(%rbp), %xmm0
movl $0x186a0, %r9d          # imm = 0x186A0
movss 0x15a87(%rip), %xmm1    # 0x71234
callq 0x5a860
movq %rax, -0x8(%rbp)
jmp 0x5b757
movq 0x27839(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %edx
subl -0x34(%rbp), %edx
leaq 0x1a56e(%rip), %rsi     # 0x75d41
movb $0x0, %al
callq 0x3240
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/go.c
// Function: score_game
float score_game(float *board)
{
    int i;
    FILE *f = fopen("game.txt", "w");
    int count = print_game(board, f);
    fprintf(f, "final_score\n");
    fclose(f);
    FILE *p = popen("./gnugo --mode gtp < game.txt", "r");
    for(i = 0; i < count; ++i){
        free(fgetl(p));
        free(fgetl(p));
    }
    char *l = 0;
    float score = 0;
    char player = 0;
    while((l = fgetl(p))){
        fprintf(stderr, "%s  \t", l);
        int n = sscanf(l, "= %c+%f", &player, &score);
        free(l);
        if (n == 2) break;
    }
    if(player == 'W') score = -score;
    pclose(p);
    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x18e6f(%rip), %rdi     # 0x76062
leaq 0x19871(%rip), %rsi     # 0x76a6b
callq 0x3360
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b510
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x18f06(%rip), %rsi     # 0x76124
movb $0x0, %al
callq 0x3240
movq -0x18(%rbp), %rdi
callq 0x3100
leaq 0x18e18(%rip), %rdi     # 0x7604d
leaq 0x19331(%rip), %rsi     # 0x7656d
callq 0x3350
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5d281
movq -0x28(%rbp), %rdi
callq 0x4140
movq %rax, %rdi
callq 0x3030
movq -0x28(%rbp), %rdi
callq 0x4140
movq %rax, %rdi
callq 0x3030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5d24c
movq $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movb $0x0, -0x35(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4140
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5d2f4
movq 0x25d49(%rip), %rax     # 0x82ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
leaq 0x18e74(%rip), %rsi     # 0x76131
movb $0x0, %al
callq 0x3240
movq -0x30(%rbp), %rdi
leaq 0x18e68(%rip), %rsi     # 0x76137
leaq -0x35(%rbp), %rdx
leaq -0x34(%rbp), %rcx
movb $0x0, %al
callq 0x32f0
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3030
cmpl $0x2, -0x3c(%rbp)
jne 0x5d2f2
jmp 0x5d2f4
jmp 0x5d295
movsbl -0x35(%rbp), %eax
cmpl $0x57, %eax
jne 0x5d314
movss -0x34(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3140
movss -0x34(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/go.c
// Function: propagate_liberty
static void propagate_liberty(float *board, int *lib, int *visited, int row, int col, int side)
{
    if (row < 0 || row > 18 || col < 0 || col > 18) return;
    int index = row*19 + col;
    if (occupied(board,index) != side) return;
    if (visited[index]) return;
    visited[index] = 1;
    lib[index] += 1;
    propagate_liberty(board, lib, visited, row+1, col, side);
    propagate_liberty(board, lib, visited, row-1, col, side);
    propagate_liberty(board, lib, visited, row, col+1, side);
    propagate_liberty(board, lib, visited, row, col-1, side);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x5dd27
cmpl $0x12, -0x1c(%rbp)
jg 0x5dd27
cmpl $0x0, -0x20(%rbp)
jl 0x5dd27
cmpl $0x12, -0x20(%rbp)
jle 0x5dd2c
jmp 0x5ddfd
imull $0x13, -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x58d60
cmpl -0x24(%rbp), %eax
je 0x5dd4c
jmp 0x5ddfd
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x5dd5f
jmp 0x5ddfd
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x5dcf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x5dcf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
addl $0x1, %r8d
movl -0x24(%rbp), %r9d
callq 0x5dcf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
subl $0x1, %r8d
movl -0x24(%rbp), %r9d
callq 0x5dcf0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/rnn.c
// Function: load_files
unsigned char **load_files(char *filename, int *n)
{
    list *paths = get_paths(filename);
    *n = paths->size;
    unsigned char **contents = calloc(*n, sizeof(char *));
    int i;
    node *x = paths->front;
    for(i = 0; i < *n; ++i){
        contents[i] = read_file((char *)x->val);
        x = x->next;
    }
    return contents;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31450
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5de9e
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x4c90
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5de61
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/rnn.c
// Function: read_tokenized_data
int *read_tokenized_data(char *filename, size_t *read)
{
    size_t size = 512;
    size_t count = 0;
    FILE *fp = fopen(filename, "r");
    int *d = calloc(size, sizeof(int));
    int n, one;
    one = fscanf(fp, "%d", &n);
    while(one == 1){
        ++count;
        if(count > size){
            size = size*2;
            d = realloc(d, size*sizeof(int));
        }
        d[count-1] = n;
        one = fscanf(fp, "%d", &n);
    }
    fclose(fp);
    d = realloc(d, count*sizeof(int));
    *read = count;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x200, -0x18(%rbp)     # imm = 0x200
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18692(%rip), %rsi     # 0x7656d
callq 0x3360
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x185b8(%rip), %rsi     # 0x764b9
leaq -0x34(%rbp), %rdx
movb $0x0, %al
callq 0x3080
movl %eax, -0x38(%rbp)
cmpl $0x1, -0x38(%rbp)
jne 0x5df78
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x5df4b
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %edx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rdi
leaq 0x18551(%rip), %rsi     # 0x764b9
leaq -0x34(%rbp), %rdx
movb $0x0, %al
callq 0x3080
movl %eax, -0x38(%rbp)
jmp 0x5df0f
movq -0x28(%rbp), %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq $0x2, %rsi
callq 0x3310
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/rnn.c
// Function: read_tokens
char **read_tokens(char *filename, size_t *read)
{
    size_t size = 512;
    size_t count = 0;
    FILE *fp = fopen(filename, "r");
    char **d = calloc(size, sizeof(char *));
    char *line;
    while((line=fgetl(fp)) != 0){
        ++count;
        if(count > size){
            size = size*2;
            d = realloc(d, size*sizeof(char *));
        }
        if(0==strcmp(line, "<NEWLINE>")) line = "\n";
        d[count-1] = line;
    }
    fclose(fp);
    d = realloc(d, count*sizeof(char *));
    *read = count;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x200, -0x18(%rbp)     # imm = 0x200
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x18592(%rip), %rsi     # 0x7656d
callq 0x3360
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x3220
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4140
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x5e07b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x5e03f
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3310
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x1818e(%rip), %rsi     # 0x761d8
callq 0x3230
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x5e062
leaq 0x17d50(%rip), %rax     # 0x75dae
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x5dff6
movq -0x28(%rbp), %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0x3310
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/rnn.c
// Function: print_symbol
void print_symbol(int n, char **tokens){
    if(tokens){
        printf("%s ", tokens[n]);
    } else {
        printf("%c", n);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5ebd2
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x173f4(%rip), %rdi     # 0x75fbd
movb $0x0, %al
callq 0x3130
jmp 0x5ebe3
movl -0x4(%rbp), %esi
leaq 0x15796(%rip), %rdi     # 0x74372
movb $0x0, %al
callq 0x3130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/classifier.c
// Function: get_regression_values
float *get_regression_values(char **labels, int n)
{
    float *v = calloc(n, sizeof(float));
    int i;
    for(i = 0; i < n; ++i){
        char *p = strchr(labels[i], ' ');
        *p = 0;
        v[i] = atof(p+1);
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x618ca
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x20, %esi
callq 0x3120
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x30c0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x61878
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/detector.c
// Function: get_coco_image_id
static int get_coco_image_id(char *filename)
{
    char *p = strrchr(filename, '/');
    char *c = strrchr(filename, '_');
    if(c) p = c;
    return atoi(p+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x3160
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5f, %esi
callq 0x3160
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6c32f
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x33d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/nightmare.c
// Function: abs_mean
float abs_mean(float *x, int n)
{
    int i;
    float sum = 0;
    for (i = 0; i < n; ++i){
        sum += fabs(x[i]);
    }
    return sum/n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6c3af
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x4da6(%rip), %xmm0     # 0x71130
pand %xmm0, %xmm1
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6c36a
movss -0x14(%rbp), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/SimpleDoger[P]Darknet_CPU_Only/nightmare.c
// Function: calculate_loss
void calculate_loss(float *output, float *delta, int n, float thresh)
{
    int i;
    float mean = mean_array(output, n); 
    float var = variance_array(output, n);
    for(i = 0; i < n; ++i){
        if(delta[i] > mean + thresh*sqrt(var)) delta[i] = output[i];
        else delta[i] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x54d0
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5640
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6c4a9
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3430
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x30(%rbp), %xmm0
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6c489
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x6c499
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x6c49b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c401
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6ee0c
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
movq -0x8(%rbp), %rdi
callq 0x400e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x3a9b0
movb $0x0, %al
callq 0x3f10
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x94(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x90(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x98(%rax), %ecx
movq -0x18(%rbp), %rax
imull 0x4(%rax), %ecx
leaq -0x40(%rbp), %rdi
callq 0xe3e0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6ee89
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3b160
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6ee69
movb $0x0, %al
callq 0x3f10
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6ea80
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
movsd -0x48(%rbp), %xmm0
leaq 0x7d4a(%rip), %rdi      # 0x76c00
movb $0x1, %al
callq 0x3130
cvtsi2ssq -0x50(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x22b1(%rip), %xmm1     # 0x71180
divsd %xmm1, %xmm0
leaq 0x7d3d(%rip), %rdi      # 0x76c17
movb $0x1, %al
callq 0x3130
cvtsi2ssq -0x50(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x228d(%rip), %xmm1     # 0x71180
divsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x48(%rbp), %xmm0
leaq 0x7d2f(%rip), %rdi      # 0x76c3b
movb $0x1, %al
callq 0x3130
movsd -0x48(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
leaq 0x7d23(%rip), %rdi      # 0x76c4b
movb $0x1, %al
callq 0x3130
cvtsi2sdl -0xc(%rbp), %xmm0
divsd -0x48(%rbp), %xmm0
leaq 0x7d1f(%rip), %rdi      # 0x76c5f
movb $0x1, %al
callq 0x3130
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x14edd(%rip), %rax     # 0x83e40
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x400e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ea80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x7cdf(%rip), %rdi      # 0x76c6d
movb $0x0, %al
callq 0x3130
cvtsi2ssq -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x21d9(%rip), %xmm1     # 0x71180
divsd %xmm1, %xmm0
leaq 0x7c65(%rip), %rdi      # 0x76c17
movb $0x1, %al
callq 0x3130
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x14a92(%rip), %rax     # 0x83e40
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x400e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6f3f3
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movl (%rax), %ecx
xorl %edx, %edx
callq 0x41f10
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
callq 0x41f10
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movl (%rax), %edx
callq 0x413c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x149b3(%rip), %rax     # 0x83e40
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x39a70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x14(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4c0(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
movl $0x0, -0x4c4(%rbp)
movl -0x4c4(%rbp), %eax
cmpl -0x43c(%rbp), %eax
jge 0x6f589
movl $0x0, -0x4c8(%rbp)
movl -0x4c8(%rbp), %eax
movl -0x430(%rbp), %ecx
imull -0x430(%rbp), %ecx
imull -0x44c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6f567
movq -0x270(%rbp), %rax
movl -0x4c4(%rbp), %ecx
imull -0x430(%rbp), %ecx
imull -0x430(%rbp), %ecx
imull -0x44c(%rbp), %ecx
addl -0x4c8(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x773e(%rip), %rdi      # 0x76c8d
movb $0x1, %al
callq 0x3130
movl -0x4c8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c8(%rbp)
jmp 0x6f4f6
leaq 0x6840(%rip), %rdi      # 0x75dae
movb $0x0, %al
callq 0x3130
movl -0x4c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c4(%rbp)
jmp 0x6f4da
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x970, %rsp            # imm = 0x970
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x14882(%rip), %rax     # 0x83e40
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x39a70
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6f64f
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x24(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4c8(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpl $0x0, -0x4c8(%rbp)
jne 0x6f642
movq %rsp, %rdi
movl $0x94, %ecx
leaq -0x4c8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movss 0x1bdd(%rip), %xmm0     # 0x71210
movss 0x75c1(%rip), %xmm1     # 0x76bfc
callq 0x8b20
jmp 0x6f64f
jmp 0x6f644
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6f5de
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41980
addq $0x970, %rsp            # imm = 0x970
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x970, %rsp            # imm = 0x970
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x147b2(%rip), %rax     # 0x83e40
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x39a70
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6f70f
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x24(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4c8(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpl $0x0, -0x4c8(%rbp)
jne 0x6f702
movq %rsp, %rdi
movl $0x94, %ecx
leaq -0x4c8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x8a90
jmp 0x6f70f
jmp 0x6f704
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6f6ae
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41980
addq $0x970, %rsp            # imm = 0x970
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x970, %rsp            # imm = 0x970
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x146f2(%rip), %rax     # 0x83e40
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x39a70
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6f8aa
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x24(%rbp), %rax
imulq $0x4a0, %rax, %rax      # imm = 0x4A0
addq %rax, %rsi
leaq -0x4c8(%rbp), %rdi
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
cmpl $0x0, -0x4c8(%rbp)
jne 0x6f7cd
cmpl $0x0, -0x488(%rbp)
je 0x6f7cd
movq %rsp, %rdi
movl $0x94, %ecx
leaq -0x4c8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x84e0
cmpl $0x2, -0x4c8(%rbp)
jne 0x6f7f6
cmpl $0x0, -0x488(%rbp)
je 0x6f7f6
movq %rsp, %rdi
movl $0x94, %ecx
leaq -0x4c8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x3cb70
cmpl $0x10, -0x4c8(%rbp)
jne 0x6f89a
cmpl $0x0, -0x488(%rbp)
je 0x6f89a
movq -0xd8(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x3cb70
movq -0xc8(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x3cb70
movq -0xb8(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x3cb70
movq -0xd0(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x3cb70
movq -0xc0(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x3cb70
movq -0xb0(%rbp), %rsi
movq %rsp, %rdi
movl $0x94, %ecx
rep  movsq (%rsi), %es:(%rdi)
callq 0x3cb70
jmp 0x6f89c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6f76e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41980
addq $0x970, %rsp            # imm = 0x970
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl %esi, -0x4(%rbp)
movl $0x1, 0x40(%rax)
movslq -0x4(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x240(%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6f934
movq -0x10(%rbp), %rax
movq 0x240(%rax), %rax
movslq -0x8(%rbp), %rcx
movss 0x16e8(%rip), %xmm0     # 0x7100c
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6f905
movslq -0x4(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movslq -0x4(%rbp), %rdi
movl $0x4, %esi
callq 0x3220
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, 0x2b8(%rsi)
movl $0x4a0, %edx            # imm = 0x4A0
callq 0x3280
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x13d1
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x13e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x133c
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/shuffle.c
// Function: rand_long
static long rand_long(long n) {
    long limit = LRAND_MAX - LRAND_MAX % n;
    long rnd;
    do {
        rnd = ((long)RAND_MAX + 1) * (long)rand() + (long)rand();
    } while (rnd >= limit);
    return rnd % n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cqto
idivq -0x8(%rbp)
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
subq %rdx, %rax
movq %rax, -0x10(%rbp)
callq 0x11a0
cltq
shlq $0x1f, %rax
movq %rax, -0x20(%rbp)
callq 0x11a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x140d
movq -0x18(%rbp), %rax
cqto
idivq -0x8(%rbp)
movq %rdx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, (%rsp)
movq (%rsp), %rax
movb $0x1, (%rax)
movq (%rsp), %rax
movb $0x1, 0x1(%rax)
movq (%rsp), %rax
movb $0x0, 0x2(%rax)
movq (%rsp), %rax
movb $0x0, 0x3(%rax)
movq (%rsp), %rax
movw $0xc0, 0x4(%rax)
movq (%rsp), %rax
movl $0x4400, 0x8(%rax)      # imm = 0x4400
movq 0x2ed8(%rip), %rcx      # 0x4028
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x2ed1(%rip), %rcx      # 0x4030
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
leaq 0xe86(%rip), %rdi       # 0x2000
leaq 0xeaa(%rip), %rsi       # 0x202b
movb $0x0, %al
callq 0x1030
movb $0x1, %al
andb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
cmpq 0x4e0f(%rip), %rax      # 0xc4c0
jne 0x76b8
jmp 0x77b5
movq 0x4e01(%rip), %rcx      # 0xc4c0
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
jne 0x76d5
movw $0x0, -0x6(%rbp)
movw $0x0, -0x8(%rbp)
jmp 0x76fb
movq 0x4de4(%rip), %rax      # 0xc4c0
movq 0x38(%rax), %rax
movw 0x10(%rax), %ax
movw %ax, -0x6(%rbp)
movq 0x4dd1(%rip), %rax      # 0xc4c0
movq 0x38(%rax), %rax
movw 0x12(%rax), %ax
movw %ax, -0x8(%rbp)
movq 0x4dbe(%rip), %rax      # 0xc4c0
movl (%rax), %edi
callq 0x5460
movq 0x4db0(%rip), %rax      # 0xc4c0
movl (%rax), %edi
leaq -0x2(%rbp), %rsi
leaq -0x4(%rbp), %rdx
callq 0x5af0
testb $0x1, %al
jne 0x7728
jmp 0x77b5
movw -0x6(%rbp), %cx
movq 0x4d8d(%rip), %rax      # 0xc4c0
movw %cx, 0x6(%rax)
movw -0x8(%rbp), %cx
movq 0x4d7e(%rip), %rax      # 0xc4c0
movw %cx, 0x8(%rax)
movq 0x4d73(%rip), %rax      # 0xc4c0
movl (%rax), %edi
movq 0x4d6a(%rip), %rax      # 0xc4c0
movw 0x6(%rax), %cx
movq 0x4d5f(%rip), %rax      # 0xc4c0
movzwl %cx, %esi
movzwl 0x8(%rax), %edx
callq 0x42a0
movq 0x4d1c(%rip), %rdi      # 0xc490
movq 0x4d45(%rip), %rax      # 0xc4c0
movl (%rax), %edx
movw -0x2(%rbp), %ax
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
cwtl
movl %eax, 0x8(%rsp)
movswl -0x4(%rbp), %eax
movl %eax, 0x10(%rsp)
callq 0x2050
movl %eax, -0xc(%rbp)
movq 0x4ce0(%rip), %rdi      # 0xc490
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb $0x0, -0x21(%rbp)
xorl %eax, %eax
cmpq 0x488b(%rip), %rax      # 0xc4c0
jne 0x7c3c
jmp 0x7d48
movq 0x484d(%rip), %rdi      # 0xc490
movq 0x4876(%rip), %rax      # 0xc4c0
movl (%rax), %esi
movl 0x485e(%rip), %edx      # 0xc4b0
callq 0x2460
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movq 0x4829(%rip), %rdi      # 0xc490
movl -0x4(%rbp), %esi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2100
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x7cb3
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x7cb1
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x4806(%rip), %eax      # 0xc4a4
jne 0x7ca4
movb $0x1, -0x21(%rbp)
jmp 0x7ca6
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7c86
jmp 0x7cb3
leaq -0x20(%rbp), %rdi
callq 0x20a0
testb $0x1, -0x21(%rbp)
je 0x7d24
movb $0x21, -0x4c(%rbp)
movb $0x20, -0x4b(%rbp)
movw $0x0, -0x4a(%rbp)
movq 0x47e9(%rip), %rax      # 0xc4c0
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movl 0x47ce(%rip), %eax      # 0xc4b0
movl %eax, -0x44(%rbp)
leaq -0x4c(%rbp), %rdi
addq $0xc, %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x21c0
movl 0x47a5(%rip), %eax      # 0xc4a4
movl %eax, -0x40(%rbp)
movq 0x4787(%rip), %rdi      # 0xc490
movq 0x47b0(%rip), %rax      # 0xc4c0
movl (%rax), %edx
xorl %ecx, %ecx
leaq -0x4c(%rbp), %r8
movl %ecx, %esi
callq 0x2450
movl %eax, -0x50(%rbp)
jmp 0x7d3c
movq 0x4765(%rip), %rdi      # 0xc490
movq 0x478e(%rip), %rax      # 0xc4c0
movl (%rax), %esi
callq 0x2520
movl %eax, -0x54(%rbp)
movq 0x474d(%rip), %rdi      # 0xc490
callq 0x2140
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
cmpq 0x475f(%rip), %rax      # 0xc4c0
je 0x7d72
movq 0x4756(%rip), %rcx      # 0xc4c0
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
jne 0x7d77
jmp 0x7e17
movq 0x4742(%rip), %rax      # 0xc4c0
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x7d98
jmp 0x7e17
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq 0x471a(%rip), %rax      # 0xc4c0
movq %rcx, 0x38(%rax)
movq 0x470f(%rip), %rax      # 0xc4c0
movl (%rax), %edi
callq 0x5460
movq 0x4701(%rip), %rdi      # 0xc4c0
callq 0x26f0
movq 0x46f5(%rip), %rdi      # 0xc4c0
callq 0x6a70
movq 0x46b9(%rip), %rdi      # 0xc490
movq 0x46e2(%rip), %rax      # 0xc4c0
movl (%rax), %edx
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x2050
movl %eax, -0xc(%rbp)
movq 0x467e(%rip), %rdi      # 0xc490
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
cmpq 0x468f(%rip), %rax      # 0xc4c0
je 0x7e42
movq 0x4686(%rip), %rcx      # 0xc4c0
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
jne 0x7e47
jmp 0x7ee7
movq 0x4672(%rip), %rax      # 0xc4c0
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x7e68
jmp 0x7ee7
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq 0x464a(%rip), %rax      # 0xc4c0
movq %rcx, 0x38(%rax)
movq 0x463f(%rip), %rax      # 0xc4c0
movl (%rax), %edi
callq 0x5460
movq 0x4631(%rip), %rdi      # 0xc4c0
callq 0x26f0
movq 0x4625(%rip), %rdi      # 0xc4c0
callq 0x6a70
movq 0x45e9(%rip), %rdi      # 0xc490
movq 0x4612(%rip), %rax      # 0xc4c0
movl (%rax), %edx
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x2050
movl %eax, -0xc(%rbp)
movq 0x45ae(%rip), %rdi      # 0xc490
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x12ab
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0xd75(%rip), %rsi       # 0x2004
leaq 0xd86(%rip), %rcx       # 0x201c
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, -0x4(%rbp)
jmp 0x12bc
movl $0x1, 0x2e13(%rip)      # 0x40c8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1325
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1323
jmp 0x1307
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0xd02(%rip), %rsi       # 0x201e
movb $0x0, %al
callq 0x1110
jmp 0x1375
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x132f
jmp 0x1307
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x2c96(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1070
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1365
leaq 0xd1d(%rip), %rdi       # 0x207b
movb $0x0, %al
callq 0x1060
jmp 0x1367
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x12ee
leaq 0xd14(%rip), %rdi       # 0x2090
movb $0x0, %al
callq 0x1060
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1610
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rsi
leaq 0xa71(%rip), %rdi       # 0x208c
movb $0x0, %al
callq 0x1060
leaq 0xa78(%rip), %rdi       # 0x20a1
callq 0x1030
leaq 0xa9b(%rip), %rdi       # 0x20d0
callq 0x1030
leaq 0xabc(%rip), %rdi       # 0x20fd
callq 0x1030
leaq 0xadb(%rip), %rdi       # 0x2128
callq 0x1030
leaq 0xb05(%rip), %rdi       # 0x215e
callq 0x1030
leaq 0xb2a(%rip), %rdi       # 0x218f
callq 0x1030
leaq 0xb49(%rip), %rdi       # 0x21ba
callq 0x1030
leaq 0xb77(%rip), %rdi       # 0x21f4
callq 0x1030
leaq 0xba7(%rip), %rdi       # 0x2230
callq 0x1030
xorl %edi, %edi
callq 0x1110
nopw %cs:(%rax,%rax)