LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/topn.c
// Function: topn_sort
void topn_sort(topn_t* topn) {
    int i;
    int j;

    int origSize = topn->size;
    int origCapacity = topn->capacity;
    topn->capacity = topn->size;
    while (topn->size > 0) {
        swap(topn, 0, topn->size - 1);
        topn->size--;
        topn->capacity--;
        i = 0;
        j = minChild(topn, i);
        while (j != -1 && (topn->values[i] > topn->values[j] || (topn->values[i] == topn->values[j] && topn->keys[i] > topn->keys[j]))) {
            swap(topn, i, j);
            i = j;
            j = minChild(topn, i);
        }
    }
    topn->size = origSize;
    topn->capacity = origCapacity;
    reverse(topn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x24d9
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x2150
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x22b0
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x24a2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x10(%rbp), %rdx
movb $0x1, %al
ucomisd (%rcx,%rdx,8), %xmm0
movb %al, -0x1a(%rbp)
ja 0x249c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x10(%rbp), %rdx
xorl %eax, %eax
ucomisd (%rcx,%rdx,8), %xmm0
movb %al, -0x1b(%rbp)
jne 0x2496
jp 0x2496
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x10(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
setg %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x24ab
jmp 0x24d4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2150
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x22b0
movl %eax, -0x10(%rbp)
jmp 0x2411
jmp 0x23be
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x21f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/topn.c
// Function: topn_get_pairs
idpairs_t* topn_get_pairs(topn_t* topn) {
    idpairs_t* pairs = idpairs_create(topn_size(topn), malloc(topn_size(topn) * sizeof(int)), malloc(topn_size(topn) * sizeof(double)));
    memcpy(idpairs_keys(pairs), topn->keys, topn_size(topn) * sizeof(int));
    memcpy(idpairs_values(pairs), topn->values, topn_size(topn) * sizeof(double));
    
    return pairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2500
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2500
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x10b0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2500
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x10b0
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x2f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3000
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2500
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x3020
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2500
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x10a0
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender.c
// Function: recommender_recommend
idpairs_t* recommender_recommend(recommender_t* recommender, int uid, int n) {
    recdata_t* recdata;
    idpairs_t* pairs;
    idpairs_t* ud;
    int i;
    int iid;
    int jid;
    topn_t* topn;
    double* scores;
    
    recdata = recommender->recdata;
    
    scores = recommender->recommend(uid, recommender->recdata, recommender->args);

    ud = recdata_userdata(recdata, uid);
    for (i = 0; i < idpairs_size(ud); i++) {
        jid = idpairs_keys(ud)[i];
        scores[jid] = 0.0;
    }
    idpairs_close_shallow(ud);

    topn = topn_create(n);
    for (iid = 0; iid < recdata->N_items; iid++) {
        if (scores[iid] > 0) {
            topn_add(topn, iid, scores[iid]);
        }
    }
    
    free(scores);

    topn_sort(topn);
    pairs = topn_get_pairs(topn);
    idpairs_revert(pairs);
    
    topn_close(topn);

    return pairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdx
callq *%rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1310
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2ff0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x293b
movq -0x28(%rbp), %rdi
callq 0x3000
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movq -0x48(%rbp), %rax
movslq -0x34(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x28f5
movq -0x28(%rbp), %rdi
callq 0x2fd0
movl -0x10(%rbp), %edi
callq 0x2080
movq %rax, -0x40(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x299f
movq -0x48(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2992
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %esi
movq -0x48(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x2540
jmp 0x2994
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2957
movq -0x48(%rbp), %rdi
callq 0x1030
movq -0x40(%rbp), %rdi
callq 0x2390
movq -0x40(%rbp), %rdi
callq 0x27d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3150
movq -0x40(%rbp), %rdi
callq 0x20f0
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender_ub.c
// Function: recommender_ub_recommend
double* recommender_ub_recommend(int uid, recdata_t* recdata, void* args) {
    idpairs_t* neighbors;
    idpairs_t* vd;
    int i;
    int j;
    int vid;
    double s;
    int iid;
    similarity_t* similarity = ((recommender_ub_args_t*) args)->similarity;
    int k = ((recommender_ub_args_t*) args)->k;
    int binary = ((recommender_ub_args_t*) args)->binary;
    
    double* scores = calloc(recdata->N_items, sizeof(double));
    
    neighbors = similarity_calculate(similarity, uid, k);
    for (i = 0; i < idpairs_size(neighbors); i++) {
        vid = idpairs_keys(neighbors)[i];
        vd = recdata_userdata(recdata, vid);
        s = idpairs_values(neighbors)[i];
        for (j = 0; j < idpairs_size(vd); j++) {
            iid = idpairs_keys(vd)[j];
            scores[iid] += binary ? (s) : (s * idpairs_values(vd)[j]);
        }
        idpairs_close_shallow(vd);
    }
    idpairs_close_deep(neighbors);

    return scores;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdi
movl $0x8, %esi
callq 0x1090
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x54(%rbp), %edx
callq 0x1a20
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ff0
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jge 0x2b81
movq -0x20(%rbp), %rdi
callq 0x3000
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1310
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3020
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2ff0
movl %eax, %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
jge 0x2b6a
movq -0x28(%rbp), %rdi
callq 0x3000
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x58(%rbp)
je 0x2b1f
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
jmp 0x2b45
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3020
movsd -0x78(%rbp), %xmm0
movslq -0x30(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
movq -0x60(%rbp), %rax
movslq -0x44(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2ae2
movq -0x28(%rbp), %rdi
callq 0x2fd0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2a85
movq -0x20(%rbp), %rdi
callq 0x2f90
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender_ub.c
// Function: recommender_ub_create
recommender_t* recommender_ub_create(recdata_t* recdata, similarity_t* similarity, int k, int binary) {
    recommender_t* recommender;
    recommender_ub_args_t* args;
    
    recommender = malloc(sizeof(recommender_t));
    recommender->recommend = recommender_ub_recommend;
    recommender->close = recommender_ub_close;
    recommender->recdata = recdata;
    
    args = malloc(sizeof(recommender_ub_args_t));
    args->similarity = similarity;
    args->k = k;
    args->binary = binary;
    recommender->args = args;
    
    return recommender;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x20, %edi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq -0x1cf(%rip), %rcx      # 0x2a20
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
leaq -0x5d(%rip), %rcx       # 0x2ba0
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x10, %edi
callq 0x10b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender_ib.c
// Function: recommender_ib_recommend
double* recommender_ib_recommend(int uid, recdata_t* recdata, void* args) {
    idpairs_t* neighbors;
    idpairs_t* ud;
    int i;
    int j;
    double s;
    int iid;
    int jid;
    idpairs_t** cached_neighbors = ((recommender_ib_args_t*) args)->cached_neighbors;
    int binary = ((recommender_ib_args_t*) args)->binary;
    
    double* scores = calloc(recdata->N_items, sizeof(double));
    
    ud = recdata_userdata(recdata, uid);
    for (i = 0; i < idpairs_size(ud); i++) {
        jid = idpairs_keys(ud)[i];
        neighbors = cached_neighbors[jid];
        s = binary ? 1.0 : idpairs_values(ud)[i];
        for (j = 0; j < idpairs_size(neighbors); j++) {
            iid = idpairs_keys(neighbors)[j];
            scores[iid] += s * idpairs_values(neighbors)[j];
        }
    }
    idpairs_close_shallow(ud);

    return scores;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdi
movl $0x8, %esi
callq 0x1090
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x1310
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2ff0
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2da5
movq -0x28(%rbp), %rdi
callq 0x3000
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x2cfc
movsd 0x1313(%rip), %xmm0     # 0x4008
movsd %xmm0, -0x68(%rbp)
jmp 0x2d13
movq -0x28(%rbp), %rdi
callq 0x3020
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ff0
movl %eax, %ecx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2d95
movq -0x20(%rbp), %rdi
callq 0x3000
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3020
movsd -0x78(%rbp), %xmm0
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x58(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2d24
jmp 0x2d97
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2ca8
movq -0x28(%rbp), %rdi
callq 0x2fd0
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender_ib.c
// Function: recommender_ib_close
void recommender_ib_close(recdata_t* recdata, void* args) {
    int iid;
    int N_items;
    recommender_ib_args_t* a = args;
    
    N_items = recdata->N_items;
    for (iid = 0; iid < N_items; iid++) {
        idpairs_close_deep(a->cached_neighbors[iid]);
    }
    free(a->cached_neighbors);

    free(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2e10
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2f90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2de9
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender_ib.c
// Function: calculate_neighbors
idpairs_t** calculate_neighbors(int N_items, similarity_t* similarity, int k) {
    int iid;
    idpairs_t** idpairs;
    
    idpairs = malloc(N_items * sizeof(idpairs_t*));
    for (iid = 0; iid < N_items; iid++) {
        idpairs[iid] = similarity_calculate(similarity, iid, k);
    }
    
    return idpairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x10b0
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2e8b
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1a20
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2e5a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender_ib.c
// Function: recommender_ib_create
recommender_t* recommender_ib_create(recdata_t* recdata, similarity_t* similarity, int k, int binary) {
    recommender_t* recommender;
    recommender_ib_args_t* args;
    
    recommender = malloc(sizeof(recommender_t));
    recommender->recommend = recommender_ib_recommend;
    recommender->close = recommender_ib_close;
    recommender->recdata = recdata;
    
    args = malloc(sizeof(recommender_ib_args_t));
    args->cached_neighbors = calculate_neighbors(recdata->N_items, similarity, k);
    args->binary = binary;
    recommender->args = args;
    
    return recommender;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x20, %edi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq -0x27f(%rip), %rcx      # 0x2c50
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
leaq -0x11d(%rip), %rcx      # 0x2dc0
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x10, %edi
callq 0x10b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2e30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/idpairs.c
// Function: idpairs_create
idpairs_t* idpairs_create(int n, int* keys, double* values) {
    idpairs_t* pairs = malloc(sizeof(idpairs_t));
    
    pairs->n = n;
    pairs->keys = keys;
    pairs->values = values;
    
    return pairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x10b0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/idpairs.c
// Function: revert_int
void revert_int(int n, int* v) {
    int i;
    int x;
    for (i = 0; i < n / 2; i++) {
        x = v[i];
        v[i] = v[n - i - 1];
        v[n - i - 1] = x;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x30b9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3052
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/idpairs.c
// Function: revert_double
void revert_double(int n, double* v) {
    int i;
    double x;
    for (i = 0; i < n / 2; i++) {
        x = v[i];
        v[i] = v[n - i - 1];
        v[n - i - 1] = x;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x3145
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x30d2
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/aux.c
// Function: read_args
int read_args(int argc, char** argv, FILE** user_data, FILE** item_data, int* N_users, int* N_items, int* N_prefs, int* binary) {
    char* file;

    if (argc != 6) {
        return 0;
    }
    
    file = malloc((strlen(argv[1]) + 7) * sizeof(char));

    strcpy(file, argv[1]);
    strcat(file, ".u");
    *user_data = fopen(file, "r");

    strcpy(file, argv[1]);
    strcat(file, ".i");
    *item_data = fopen(file, "r");
    
    free(file);

    *N_users = atoi(argv[2]);
    *N_items = atoi(argv[3]);
    *N_prefs = atoi(argv[4]);
    *binary = atoi(argv[5]);
    
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x6, -0x8(%rbp)
je 0x31c9
movl $0x0, -0x4(%rbp)
jmp 0x32c4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x7, %rdi
shlq $0x0, %rdi
callq 0x10b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1040
movq -0x38(%rbp), %rdi
leaq 0xe0a(%rip), %rsi       # 0x4010
callq 0x10f0
movq -0x38(%rbp), %rdi
leaq 0xdfd(%rip), %rsi       # 0x4013
callq 0x10c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1040
movq -0x38(%rbp), %rdi
leaq 0xdd4(%rip), %rsi       # 0x4015
callq 0x10f0
movq -0x38(%rbp), %rdi
leaq 0xdc2(%rip), %rsi       # 0x4013
callq 0x10c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x10e0
movl %eax, %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10e0
movl %eax, %ecx
movq 0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender_pop.c
// Function: recommender_pop_recommend
double* recommender_pop_recommend(int uid, recdata_t* recdata, void* args) {
    int iid;
    double* scores;

    (void) uid;
    (void) args;

    scores = calloc(recdata->N_items, sizeof(double));
    for (iid = 0; iid < recdata->N_items; iid++) {
        scores[iid] = recdata_itemdata_size(recdata, iid);
    }

    return scores;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdi
movl $0x8, %esi
callq 0x1090
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3334
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x12e0
cvtsi2sd %eax, %xmm0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3300
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saulvargas[P]re-C-sys/recommender_pop.c
// Function: recommender_pop_create
recommender_t* recommender_pop_create(recdata_t* recdata) {
    recommender_t* recommender;
    
    recommender = malloc(sizeof(recommender_t));
    recommender->recommend = recommender_pop_recommend;
    recommender->close = recommender_pop_close;
    recommender->recdata = recdata;
    recommender->args = NULL;
    
    return recommender;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x10b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq -0xa5(%rip), %rcx       # 0x32d0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq -0x43(%rip), %rcx       # 0x3340
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/4-ProcessKernel/printf_example_slow.c
// Function: main
int main(void) {
	int i = 0;
	for(i = 0; i < MAX; i++) {
		printf("x\n");
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0xf4240, -0x8(%rbp)    # imm = 0xF4240
jge 0x117f
leaq 0xe97(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x115d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/copy.c
// Function: main
int main()
{
    int c;
    while ((c = getchar()) != EOF)
        putchar(c);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1040
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x1176
movl -0x8(%rbp), %edi
callq 0x1030
jmp 0x115f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/unlink2.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	int i;
	tmpdirs = (char(*)[sizeof(template)])malloc(sizeof(template) * nr_tasks);
	assert(tmpdirs);

	char tmpfile[PATH_MAX];
	int fd;

	for (i = 0; i < nr_tasks; i++) {
		strcpy(tmpdirs[i], template);
		char *tmpdir = tmpdirs[i];
		assert(mkdtemp(tmpdir) != NULL);
		sprintf(tmpfile, "%s/willitscale", tmpdir);
		fd = open(tmpfile, O_RDWR|O_CREAT, 0600);
		assert(fd >= 0);
		close(fd);
	}

	local_nr_tasks = nr_tasks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
imulq $0x18, -0x8(%rbp), %rdi
callq 0x21e0
movq %rax, 0xb130(%rip)      # 0xe1c0
cmpq $0x0, 0xb128(%rip)      # 0xe1c0
je 0x309c
jmp 0x30bb
leaq 0x11ee(%rip), %rdi      # 0x4291
leaq 0x11ef(%rip), %rsi      # 0x4299
movl $0x15, %edx
leaq 0x11f3(%rip), %rcx      # 0x42a9
callq 0x2140
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x31b7
movq 0xb0e9(%rip), %rdi      # 0xe1c0
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq 0x11e5(%rip), %rsi      # 0x42ce
callq 0x2090
movq 0xb0cb(%rip), %rax      # 0xe1c0
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x1020(%rbp)
movq -0x1020(%rbp), %rdi
callq 0x2210
cmpq $0x0, %rax
je 0x311b
jmp 0x313a
leaq 0x11c4(%rip), %rdi      # 0x42e6
leaq 0x1170(%rip), %rsi      # 0x4299
movl $0x1d, %edx
leaq 0x1174(%rip), %rcx      # 0x42a9
callq 0x2140
leaq -0x1010(%rbp), %rdi
movq -0x1020(%rbp), %rdx
leaq 0x11af(%rip), %rsi      # 0x42fe
movb $0x0, %al
callq 0x22a0
leaq -0x1010(%rbp), %rdi
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x2240
movl %eax, -0x1014(%rbp)
cmpl $0x0, -0x1014(%rbp)
jl 0x317f
jmp 0x319e
leaq 0x1187(%rip), %rdi      # 0x430d
leaq 0x110c(%rip), %rsi      # 0x4299
movl $0x20, %edx
leaq 0x1110(%rip), %rcx      # 0x42a9
callq 0x2140
movl -0x1014(%rbp), %edi
callq 0x2170
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x30c2
movq -0x8(%rbp), %rax
movq %rax, 0xb006(%rip)      # 0xe1c8
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/unlink2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[PATH_MAX];

	sprintf(tmpfile, "%s/willitscale", tmpdirs[nr]);

	while (1) {
		int fd = open(tmpfile, O_RDWR|O_CREAT, 0600);
		assert(fd >= 0);
		close(fd);
		unlink(tmpfile);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1010(%rbp), %rdi
movq 0xafcf(%rip), %rdx      # 0xe1c0
imulq $0x18, -0x10(%rbp), %rax
addq %rax, %rdx
leaq 0x10fe(%rip), %rsi      # 0x42fe
movb $0x0, %al
callq 0x22a0
leaq -0x1010(%rbp), %rdi
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x2240
movl %eax, -0x1014(%rbp)
cmpl $0x0, -0x1014(%rbp)
jl 0x3230
jmp 0x324f
leaq 0x10d6(%rip), %rdi      # 0x430d
leaq 0x105b(%rip), %rsi      # 0x4299
movl $0x30, %edx
leaq 0x10cb(%rip), %rcx      # 0x4315
callq 0x2140
movl -0x1014(%rbp), %edi
callq 0x2170
leaq -0x1010(%rbp), %rdi
callq 0x2080
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3207
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/unlink2.c
// Function: testcase_cleanup
void testcase_cleanup(void)
{
	int i;
	char tmpfile[PATH_MAX];

	for (i = 0; i < local_nr_tasks; i++) {
		sprintf(tmpfile, "%s/willitscale", tmpdirs[i]);
		unlink(tmpfile);
		rmdir(tmpdirs[i]);
	}
	free(tmpdirs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq 0xaf2b(%rip), %rax      # 0xe1c8
jae 0x32f4
leaq -0x1010(%rbp), %rdi
movq 0xaf13(%rip), %rdx      # 0xe1c0
movslq -0x4(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdx
leaq 0x103f(%rip), %rsi      # 0x42fe
movb $0x0, %al
callq 0x22a0
leaq -0x1010(%rbp), %rdi
callq 0x2080
movq 0xaee7(%rip), %rdi      # 0xe1c0
movslq -0x4(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x20f0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3292
movq 0xaec5(%rip), %rdi      # 0xe1c0
callq 0x2050
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/rra/rrainfo.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    int i;

    argIndex = processOptions(argc,argv);

    if (argIndex == argc)
        info("stdin",stdin);
    else
        {
        for (i = argIndex; i < argc; ++i)
            {
            FILE *fp = OpenFile(argv[i],"r");
            info(argv[i],OpenFile(argv[i],"r"));
            fclose(fp);
            }
        }

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x13e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x135c
movq 0x6c8d(%rip), %rax      # 0x7fd8
movq (%rax), %rsi
leaq 0x3d10(%rip), %rdi      # 0x5065
callq 0x1550
jmp 0x13d0
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x13ce
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x41a5(%rip), %rsi      # 0x5522
callq 0x17c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x4179(%rip), %rsi      # 0x5522
callq 0x17c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1550
movq -0x20(%rbp), %rdi
callq 0x1070
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1362
jmp 0x13d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/rra/rrainfo.c
// Function: info
static void
info(char *name,FILE *in)
    {
    RRA *h;

    h = newRRAHeader();
    readRRAHeader(in,h,0);

    printf("%s\n",name);
    if (channels)
        printf("    %d\n",h->channels);
    else if (sampleRate)
        printf("    %d\n",h->sampleRate);
    else if (samples)
        printf("    %d\n",h->samples);
    else if (bitsPerSample)
        printf("    %d\n",h->bitsPerSample);
    else
        {
        printf("    sampleRate: %d\n",h->sampleRate);
        printf("    bitsPerSample: %d\n",h->bitsPerSample);
        printf("    channels: %d\n",h->channels);
        printf("    samples: %d\n",h->samples);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1ca0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x21a0
movq -0x8(%rbp), %rsi
leaq 0x3eef(%rip), %rdi      # 0x5474
movb $0x0, %al
callq 0x1090
cmpl $0x0, 0x6bb5(%rip)      # 0x8148
je 0x15ae
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq 0x3ac9(%rip), %rdi      # 0x506b
movb $0x0, %al
callq 0x1090
jmp 0x166a
cmpl $0x0, 0x6b8b(%rip)      # 0x8140
je 0x15d1
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x3aa6(%rip), %rdi      # 0x506b
movb $0x0, %al
callq 0x1090
jmp 0x1668
cmpl $0x0, 0x6b64(%rip)      # 0x813c
je 0x15f1
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x3a83(%rip), %rdi      # 0x506b
movb $0x0, %al
callq 0x1090
jmp 0x1666
cmpl $0x0, 0x6b4c(%rip)      # 0x8144
je 0x1611
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x3a63(%rip), %rdi      # 0x506b
movb $0x0, %al
callq 0x1090
jmp 0x1664
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x3a54(%rip), %rdi      # 0x5073
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x3a53(%rip), %rdi      # 0x5087
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq 0x3a56(%rip), %rdi      # 0x509e
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x3a53(%rip), %rdi      # 0x50b0
movb $0x0, %al
callq 0x1090
jmp 0x1666
jmp 0x1668
jmp 0x166a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/micahstairs[P]ScrambleChecker/movedelta.cpp
// Function: mindelta(cubepos const&, cubepos const&)
int mindelta(const cubepos &cp, const cubepos &cp2 = identity_cube) {
   int s = 0 ;
   for (int i=0; i<12; i++)
      if (cp.e[i] != cp2.e[i])
         s++ ;
   int r = md_lookup[s] ;
   s = 0 ;
   for (int i=0; i<8; i++)
      if (cp.c[i] != cp2.c[i])
         s++ ;
   s = md_lookup[s] ;
   if (s > r)
      return s ;
   else
      return r ;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
cmpl $0xc, -0x20(%rsp)
jge 0x255d
movq -0x10(%rsp), %rax
movslq -0x20(%rsp), %rcx
movzbl 0x8(%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movslq -0x20(%rsp), %rdx
movzbl 0x8(%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x254e
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x2550
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x251a
movslq -0x1c(%rsp), %rcx
leaq 0xdbc7(%rip), %rax      # 0x10130
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x28(%rsp)
cmpl $0x8, -0x28(%rsp)
jge 0x25c1
movq -0x10(%rsp), %rax
movslq -0x28(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movslq -0x28(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x25b2
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x25b4
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x2580
movslq -0x1c(%rsp), %rcx
leaq 0xdb63(%rip), %rax      # 0x10130
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x24(%rsp), %eax
jle 0x25e8
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x25f0
movl -0x24(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/micahstairs[P]ScrambleChecker/movedelta.cpp
// Function: parseposition(cubepos&, char const*)
void parseposition(cubepos &cp, const char *s) {
  cp = identity_cube ;
  if (cp.parse_Singmaster(s) == 0) {
    cubepos cp2 ;
    cp.invert_into(cp2) ;
    cp = cp2 ;
    return ;
  }
  cp = identity_cube ;
  moveseq r = parsemoveseq(s) ;
  for (int i=0; i<r.size(); i++)
    cp.movepc(r[i]) ;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
leaq 0xdd8b(%rip), %rcx      # 0x10625
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x7080
cmpq $0x0, %rax
jne 0x2905
leaq 0x44(%rsp), %rdi
leaq 0xdd56(%rip), %rsi      # 0x10625
callq 0x3520
movq 0x60(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x6f80
movq 0x60(%rsp), %rax
movq 0x44(%rsp), %rcx
movq %rcx, (%rax)
movq 0x4c(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x54(%rsp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x29b5
movq 0x60(%rsp), %rax
leaq 0xdd14(%rip), %rcx      # 0x10625
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2600
movl $0x0, 0x24(%rsp)
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3550
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x29ab
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movslq 0x24(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3570
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x87f0
jmp 0x2982
jmp 0x2984
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x293c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x34c0
jmp 0x29ba
leaq 0x28(%rsp), %rdi
callq 0x34c0
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/micahstairs[P]ScrambleChecker/movedelta.cpp
// Function: solveit(cubepos const&, int, std::vector<int, std::allocator<int>>&, int)
int solveit(const cubepos &cp, int at, moveseq &r, int d) {
   cubepos cp2 ;
   if (d > 0) {
      for (int mv=0; mv<NMOVES; mv++) {
         cp2 = cp ;
         cp2.movepc(mv) ;
         int md = mindelta(cp2, scramble_pos[at]) ;
         if (md < d) {
            r.push_back(mv) ;
            if (solveit(cp2, at, r, d-1))
               return 1 ;
            r.pop_back() ;
         }
      }
   }
   if (at < scramble.size()) {
      cp2 = cp ;
      r.push_back(scramble[at]) ;
      cp2.movepc(scramble[at]) ;
      if (solveit(cp2, at+1, r, d))
         return 1 ;
      r.pop_back() ;
      return 0 ;
   }
   if (cp == identity_cube)
      return 1 ;
   else
      return 0 ;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xdc33(%rip), %rsi      # 0x10625
callq 0x3520
cmpl $0x0, 0x34(%rsp)
jle 0x2ac5
movl $0x0, 0x1c(%rsp)
cmpl $0x12, 0x1c(%rsp)
jge 0x2ac3
movq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x30(%rsp)
movl 0x1c(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x87f0
movslq 0x44(%rsp), %rsi
leaq 0xdb6c(%rip), %rdi      # 0x105b8
callq 0x3600
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x2500
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x2ab1
movq 0x38(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x3620
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
movl 0x34(%rsp), %ecx
subl $0x1, %ecx
leaq 0x20(%rsp), %rdi
callq 0x29d0
cmpl $0x0, %eax
je 0x2aa7
movl $0x1, 0x54(%rsp)
jmp 0x2bb4
movq 0x38(%rsp), %rdi
callq 0x3690
jmp 0x2ab3
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2a0a
jmp 0x2ac5
movslq 0x44(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xdaca(%rip), %rdi      # 0x105a0
callq 0x3550
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2b8b
movq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x44(%rsp), %rsi
leaq 0xda81(%rip), %rdi      # 0x105a0
callq 0x3570
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3620
movslq 0x44(%rsp), %rsi
leaq 0xda63(%rip), %rdi      # 0x105a0
callq 0x3570
movl (%rax), %esi
leaq 0x20(%rsp), %rdi
callq 0x87f0
movl 0x44(%rsp), %esi
addl $0x1, %esi
movq 0x38(%rsp), %rdx
movl 0x34(%rsp), %ecx
leaq 0x20(%rsp), %rdi
callq 0x29d0
cmpl $0x0, %eax
je 0x2b77
movl $0x1, 0x54(%rsp)
jmp 0x2bb4
movq 0x38(%rsp), %rdi
callq 0x3690
movl $0x0, 0x54(%rsp)
jmp 0x2bb4
movq 0x48(%rsp), %rdi
leaq 0xda8e(%rip), %rsi      # 0x10625
callq 0x36b0
testb $0x1, %al
jne 0x2ba2
jmp 0x2bac
movl $0x1, 0x54(%rsp)
jmp 0x2bb4
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/micahstairs[P]ScrambleChecker/movedelta.cpp
// Function: loadfile(char const*)
void loadfile(const char *fn) {
   FILE *f = fopen(fn, "r") ;
   if (f == 0)
      error("! could not open scramble set file") ;
   while (fgets(buf, 1000, f) != 0) {
      scramble = parsemoveseq(buf);
      scrambleset.push_back(scramble) ;
   }
   fclose(f) ;
   cout << "Parsed " << scrambleset.size() << " scrambles." << endl ;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x870b(%rip), %rsi      # 0xb2e0
callq 0x2170
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2bf3
leaq 0x8491(%rip), %rdi      # 0xb07f
callq 0x9430
jmp 0x2bf5
movq 0x28(%rsp), %rdx
leaq 0xd5af(%rip), %rdi      # 0x101b0
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x21c0
cmpq $0x0, %rax
je 0x2c52
leaq 0x10(%rsp), %rdi
leaq 0xd593(%rip), %rsi      # 0x101b0
callq 0x2600
leaq 0xd977(%rip), %rdi      # 0x105a0
leaq 0x10(%rsp), %rsi
callq 0x3750
leaq 0x10(%rsp), %rdi
callq 0x34c0
leaq 0xd9b4(%rip), %rdi      # 0x105f8
leaq 0xd955(%rip), %rsi      # 0x105a0
callq 0x3790
jmp 0x2bf5
movq 0x28(%rsp), %rdi
callq 0x2120
movq 0xd35d(%rip), %rdi      # 0xffc0
leaq 0x8438(%rip), %rsi      # 0xb0a2
callq 0x2110
movq %rax, 0x8(%rsp)
leaq 0xd97d(%rip), %rdi      # 0x105f8
callq 0x3800
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2030
movq %rax, %rdi
leaq 0x8413(%rip), %rsi      # 0xb0aa
callq 0x2110
movq %rax, %rdi
movq 0xd302(%rip), %rsi      # 0xffa8
callq 0x2150
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/micahstairs[P]ScrambleChecker/movedelta.cpp
// Function: setup_scramble(std::vector<int, std::allocator<int>>&)
void setup_scramble(moveseq &ms) {
   scramble_pos.clear() ;
   scramble = ms ;
   cubepos cp, cp2 ;
   cp = identity_cube ;
   scramble_pos.push_back(cp) ;
   for (int i=0; i<scramble.size(); i++) {
      cp.movepc(cubepos::inv_move[scramble[scramble.size()-1-i]]) ;
      scramble_pos.push_back(cp) ;
   }
   reverse(scramble_pos.begin(), scramble_pos.end()) ;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
leaq 0xd8f8(%rip), %rdi      # 0x105b8
callq 0x3820
movq 0x50(%rsp), %rsi
leaq 0xd8cf(%rip), %rdi      # 0x105a0
callq 0x3840
leaq 0x3c(%rsp), %rdi
leaq 0xd943(%rip), %rsi      # 0x10625
callq 0x3520
leaq 0x28(%rsp), %rdi
leaq 0xd932(%rip), %rsi      # 0x10625
callq 0x3520
leaq 0xd926(%rip), %rax      # 0x10625
movq (%rax), %rcx
movq %rcx, 0x3c(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x44(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x4c(%rsp)
leaq 0xd89a(%rip), %rdi      # 0x105b8
leaq 0x3c(%rsp), %rsi
callq 0x3b00
movl $0x0, 0x24(%rsp)
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xd85f(%rip), %rdi      # 0x105a0
callq 0x3550
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2db0
leaq 0xd846(%rip), %rdi      # 0x105a0
callq 0x3550
movq %rax, %rsi
subq $0x1, %rsi
movslq 0x24(%rsp), %rax
subq %rax, %rsi
leaq 0xd82b(%rip), %rdi      # 0x105a0
callq 0x3570
movslq (%rax), %rcx
leaq 0xdcac(%rip), %rax      # 0x10a30
movzbl (%rax,%rcx), %esi
leaq 0x3c(%rsp), %rdi
callq 0x87f0
leaq 0xd81f(%rip), %rdi      # 0x105b8
leaq 0x3c(%rsp), %rsi
callq 0x3b00
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2d30
leaq 0xd801(%rip), %rdi      # 0x105b8
callq 0x3bb0
movq %rax, 0x18(%rsp)
leaq 0xd7f0(%rip), %rdi      # 0x105b8
callq 0x3be0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3b70
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/server.c
// Function: main
int main(int argc, char *argv[]) {
   int bytescopied;
   char client[MAX_CANON];
   int communfd;
   int listenfd;
   u_port_t portnumber;
 
   if (argc != 2) {
      fprintf(stderr, "Usage: %s port\n", argv[0]);
      return 1;   
   }  
   portnumber = (u_port_t) atoi(argv[1]);
   if ((listenfd = u_open(portnumber)) == -1) {
      perror("Failed to create listening endpoint");
      return 1;
   }      
   fprintf(stderr, "[%ld]:waiting for the first connection on port %d\n",
                    (long)getpid(), (int)portnumber);
   for ( ; ; ) {
      if ((communfd = u_accept(listenfd, client, MAX_CANON)) == -1) {
         perror("Failed to accept connection");
         continue;
      }
      fprintf(stderr, "[%ld]:connected to %s\n", (long)getpid(), client);
      bytescopied = copyfile(communfd, STDOUT_FILENO);
      fprintf(stderr, "[%ld]:received %d bytes\n", (long)getpid(), bytescopied);
      if (r_close(communfd) == -1)
         perror("Failed to close communfd\n");
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x133a
movq 0x3ce2(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x1cdd(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x1110
movl $0x1, -0x4(%rbp)
jmp 0x147c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1190
movw %ax, -0x12a(%rbp)
movzwl -0x12a(%rbp), %edi
callq 0x2010
movl %eax, -0x128(%rbp)
cmpl $-0x1, %eax
jne 0x137d
leaq 0x1ca8(%rip), %rdi      # 0x3014
callq 0x1170
movl $0x1, -0x4(%rbp)
jmp 0x147c
movq 0x3c74(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x138(%rbp)
callq 0x1080
movq -0x138(%rbp), %rdi
movslq %eax, %rdx
movzwl -0x12a(%rbp), %ecx
leaq 0x1c8d(%rip), %rsi      # 0x3038
movb $0x0, %al
callq 0x1110
movl -0x128(%rbp), %edi
leaq -0x120(%rbp), %rsi
movl $0xff, %edx
callq 0x2170
movl %eax, -0x124(%rbp)
cmpl $-0x1, %eax
jne 0x13e2
leaq 0x1c90(%rip), %rdi      # 0x306b
callq 0x1170
jmp 0x13b2
movq 0x3c0f(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x148(%rbp)
callq 0x1080
movq -0x148(%rbp), %rdi
movslq %eax, %rdx
leaq -0x120(%rbp), %rcx
leaq 0x1c77(%rip), %rsi      # 0x3087
movb $0x0, %al
callq 0x1110
movl -0x124(%rbp), %edi
movl $0x1, %esi
callq 0x1840
movl %eax, -0x14(%rbp)
movq 0x3bc7(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x140(%rbp)
callq 0x1080
movq -0x140(%rbp), %rdi
movslq %eax, %rdx
movl -0x14(%rbp), %ecx
leaq 0x1c4a(%rip), %rsi      # 0x309e
movb $0x0, %al
callq 0x1110
movl -0x124(%rbp), %edi
callq 0x1490
cmpl $-0x1, %eax
jne 0x1477
leaq 0x1c45(%rip), %rdi      # 0x30b7
callq 0x1170
jmp 0x13b2
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: r_waitpid
pid_t r_waitpid(pid_t pid, int *stat_loc, int options) {
   pid_t retval;
   while (((retval = waitpid(pid, stat_loc, options)) == -1) &&
           (errno == EINTR)) ;
   return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1150
movl %eax, %ecx
movl %ecx, -0x18(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x19(%rbp)
jne 0x16ce
callq 0x1030
cmpl $0x4, (%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x16d7
jmp 0x16d9
jmp 0x16a2
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)