LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliConnect
static int cliConnect(int force) {
    if (context == NULL || force) {
        if (context != NULL)
            redisFree(context);

        if (config.hostsocket == NULL) {
            context = redisConnect(config.hostip,config.hostport);
        } else {
            context = redisConnectUnix(config.hostsocket);
        }

        if (context->err) {
            fprintf(stderr,"Could not connect to Discnt at ");
            if (config.hostsocket == NULL)
                fprintf(stderr,"%s:%d: %s\n",config.hostip,config.hostport,context->errstr);
            else
                fprintf(stderr,"%s: %s\n",config.hostsocket,context->errstr);
            redisFree(context);
            context = NULL;
            return REDIS_ERR;
        }

        /* Set aggressive KEEP_ALIVE socket option in the Discnt context socket
         * in order to prevent timeouts caused by the execution of long
         * commands. At the same time this improves the detection of real
         * errors. */
        anetKeepAlive(NULL, context->fd, DISCNT_CLI_KEEPALIVE_INTERVAL);

        /* Do AUTH and select the right DB. */
        if (cliAuth() != REDIS_OK)
            return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbx
movl %edi, %eax
movq 0x37bdc(%rip), %rdi     # 0x4cc98
testq %rdi, %rdi
setne %cl
testl %eax, %eax
sete %al
xorl %ebx, %ebx
testb %cl, %al
jne 0x1515c
testq %rdi, %rdi
je 0x150db
callq 0x182ba
movq 0x37ab6(%rip), %rdi     # 0x4cb98
testq %rdi, %rdi
je 0x150ee
callq 0x18436
jmp 0x15100
movq 0x37a93(%rip), %rdi     # 0x4cb88
movl 0x37a95(%rip), %esi     # 0x4cb90
callq 0x18312
movq %rax, 0x37b91(%rip)     # 0x4cc98
cmpl $0x0, (%rax)
jne 0x15152
movl 0x84(%rax), %esi
xorl %ebx, %ebx
xorl %edi, %edi
movl $0xf, %edx
callq 0x1041e
movq 0x37ab9(%rip), %rdx     # 0x4cbe0
testq %rdx, %rdx
je 0x1515c
movq 0x37b65(%rip), %rdi     # 0x4cc98
leaq 0x25adc(%rip), %rsi     # 0x3ac16
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x18b8c
testq %rax, %rax
je 0x15157
movq %rax, %rdi
callq 0x16fac
jmp 0x1515c
callq 0xc855
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliVersion
static sds cliVersion(void) {
    sds version;
    version = sdscatprintf(sdsempty(), "%s", DISCNT_VERSION);

    /* Add git commit and working tree status when available */
    if (strtoll(discntGitSHA1(),NULL,16)) {
        version = sdscatprintf(version, " (git:%s", discntGitSHA1());
        if (strtoll(discntGitDirty(),NULL,10))
            version = sdscatprintf(version, "-dirty");
        version = sdscat(version, ")");
    }
    return version;
}

// Assembly:
pushq %rbx
callq 0x1139e
leaq 0x23e8a(%rip), %rsi     # 0x39032
leaq 0x24c42(%rip), %rdx     # 0x39df1
movq %rax, %rdi
xorl %eax, %eax
callq 0x12042
movq %rax, %rbx
callq 0x163f0
movq %rax, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xc350
testq %rax, %rax
je 0x1522e
callq 0x163f0
leaq 0x259f2(%rip), %rsi     # 0x3abd3
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x12042
movq %rax, %rbx
callq 0x163f8
movq %rax, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0xc350
testq %rax, %rax
je 0x1521e
leaq 0x259cb(%rip), %rsi     # 0x3abdc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12042
movq %rax, %rbx
leaq 0x244f6(%rip), %rsi     # 0x3971b
movq %rbx, %rdi
popq %rbx
jmp 0x11cb1
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliRefreshPrompt
static void cliRefreshPrompt(void) {
    int len;

    if (config.hostsocket != NULL)
        len = snprintf(config.prompt,sizeof(config.prompt),"discnt %s",
                       config.hostsocket);
    else
        len = snprintf(config.prompt,sizeof(config.prompt),
                       strchr(config.hostip,':') ? "[%s]:%d" : "%s:%d",
                       config.hostip, config.hostport);
    snprintf(config.prompt+len,sizeof(config.prompt)-len,"> ");
}

// Assembly:
pushq %rbx
movq 0x37789(%rip), %rcx     # 0x4cb98
testq %rcx, %rcx
je 0x15430
leaq 0x377dd(%rip), %rdi     # 0x4cbf8
leaq 0x25b55(%rip), %rdx     # 0x3af77
movl $0x80, %esi
xorl %eax, %eax
callq 0xc1f0
jmp 0x15476
movq 0x37751(%rip), %rbx     # 0x4cb88
movq %rbx, %rdi
movl $0x3a, %esi
callq 0xc1d0
testq %rax, %rax
leaq 0x23cae(%rip), %rax     # 0x390fc
leaq 0x23c9f(%rip), %rdx     # 0x390f4
cmoveq %rax, %rdx
movl 0x37730(%rip), %r8d     # 0x4cb90
leaq 0x37791(%rip), %rdi     # 0x4cbf8
movl $0x80, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xc1f0
cltq
leaq 0x37709(%rip), %rcx     # 0x4cb88
leaq (%rax,%rcx), %rdi
addq $0x70, %rdi
movl $0x80, %esi
subq %rax, %rsi
leaq 0x25ab7(%rip), %rdx     # 0x3af4d
xorl %eax, %eax
popq %rbx
jmp 0xc1f0
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/discnt-cli.c
// Function: cliFormatReplyRaw
static sds cliFormatReplyRaw(redisReply *r) {
    sds out = sdsempty(), tmp;
    size_t i;

    switch (r->type) {
    case REDIS_REPLY_NIL:
        /* Nothing... */
        break;
    case REDIS_REPLY_ERROR:
        out = sdscatlen(out,r->str,r->len);
        out = sdscatlen(out,"\n",1);
        break;
    case REDIS_REPLY_STATUS:
    case REDIS_REPLY_STRING:
        out = sdscatlen(out,r->str,r->len);
        break;
    case REDIS_REPLY_INTEGER:
        out = sdscatprintf(out,"%lld",r->integer);
        break;
    case REDIS_REPLY_ARRAY:
        for (i = 0; i < r->elements; i++) {
            if (i > 0) out = sdscat(out,config.mb_delim);
            tmp = cliFormatReplyRaw(r->element[i]);
            out = sdscatlen(out,tmp,sdslen(tmp));
            sdsfree(tmp);
        }
        break;
    default:
        fprintf(stderr,"Unknown reply type: %d\n", r->type);
        exit(1);
    }
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x1139e
movq %rax, %rbx
movl (%r14), %edi
leal -0x1(%rdi), %eax
cmpl $0x5, %eax
ja 0x15c1c
leaq 0x23cf9(%rip), %rcx     # 0x39810
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%r14), %rsi
movslq 0x10(%r14), %rdx
movq %rbx, %rdi
jmp 0x15bf0
cmpq $0x0, 0x20(%r14)
je 0x15bc4
xorl %r12d, %r12d
leaq 0x23ce3(%rip), %r13     # 0x39828
testq %r12, %r12
je 0x15b5c
movq 0x3709f(%rip), %rsi     # 0x4cbf0
movq %rbx, %rdi
callq 0x11cb1
movq %rax, %rbx
movq 0x28(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x15aed
movq %rax, %r15
movzbl -0x1(%rax), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x15ba3
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x15ba5
movq -0x11(%r15), %rdx
jmp 0x15ba5
movzwl -0x5(%r15), %edx
jmp 0x15ba5
movl -0x9(%r15), %edx
jmp 0x15ba5
movzbl -0x3(%r15), %edx
jmp 0x15ba5
xorl %edx, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11be6
movq %rax, %rbx
movq %r15, %rdi
callq 0x11441
incq %r12
cmpq 0x20(%r14), %r12
jb 0x15b45
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%r14), %rsi
movslq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x11be6
leaq 0x24fe9(%rip), %rsi     # 0x3abd1
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x11be6
movq 0x8(%r14), %rdx
leaq 0x2550f(%rip), %rsi     # 0x3b118
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x12042
callq 0xc8d8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/examples/gff3validator.c
// Function: main
int main(int argc, const char *argv[])
{
  GtNodeStream *gff3_in_stream;
  GtGenomeNode *gn;
  GtError *err;
  int had_err;

  if (gt_version_check(GT_MAJOR_VERSION, GT_MINOR_VERSION, GT_MICRO_VERSION)) {
    fprintf(stderr, "error: %s\n", gt_version_check(GT_MAJOR_VERSION,
                                                    GT_MINOR_VERSION,
                                                    GT_MICRO_VERSION));
    return EXIT_FAILURE;
  }

  /* initialize */
  gt_lib_init();

  /* create error object */
  err = gt_error_new();

  /* create GFF3 input stream (with ID attribute checking) */
  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc-1, argv+1);
  gt_gff3_in_stream_check_id_attributes((GtGFF3InStream*) gff3_in_stream);

  /* pull the features through the stream and free them afterwards */
  while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn)
    gt_genome_node_delete(gn);

  /* handle error */
  if (had_err)
    fprintf(stderr, "%s: error: %s\n", argv[0], gt_error_get(err));
  else
    printf("input is valid GFF3\n");

  /* free */
  gt_node_stream_delete(gff3_in_stream);
  gt_error_delete(err);

  if (had_err)
    return EXIT_FAILURE;
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, %r14d
movl $0x1, %edi
movl $0x6, %esi
movl $0x6, %edx
callq 0x208a4
testq %rax, %rax
jne 0x18702
callq 0x188d8
callq 0x18718
movq %rax, %r14
decl %ebp
leaq 0x8(%rbx), %rsi
movl %ebp, %edi
callq 0x220af
movq %rax, %r15
movq %rax, %rdi
callq 0x21ef2
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x28854
testl %eax, %eax
sete %bpl
movq (%r12), %rdi
testq %rdi, %rdi
setne %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x186c9
leaq 0x8(%rsp), %r12
callq 0x21be4
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x28854
testl %eax, %eax
sete %bpl
jne 0x186c9
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x186a4
testb %bpl, %bpl
je 0x18709
leaq 0x6493e(%rip), %rdi     # 0x7d013
callq 0x77d0
movq %r15, %rdi
callq 0x287da
movq %r14, %rdi
callq 0x18899
xorb $0x1, %bpl
movzbl %bpl, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x7a20
jmp 0x186f2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a4d
jmp 0x186da
nop
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/clee.c
// Function: clee_init
void clee_init() {
    tracing = false;
    list_init(&children);
    event_handlers.syscall_entry = NULL;
    event_handlers.syscall_exit = NULL;
    event_handlers.exited = NULL;
    event_handlers.terminated = NULL;
    event_handlers.continued = NULL;
    event_handlers.stopped = NULL;
    event_handlers.new_process = NULL;
    event_handlers.syscall_clone = NULL;
    event_handlers.syscall_fork = NULL;
    event_handlers.syscall_vfork = NULL;
    event_handlers.syscall_seccomp = NULL;
    event_handlers.successful_exec = NULL;
    if (signal(SIGTERM, clee_signal_handler) == SIG_ERR) {
        CLEE_ERROR;
    }
}

// Assembly:
pushq %rax
movb $0x0, 0x6e1c(%rip)      # 0xa110
leaq 0x6e1d(%rip), %rdi      # 0xa118
callq 0x3cdc
xorl %eax, %eax
movq %rax, 0x6e87(%rip)      # 0xa190
movq %rax, 0x6e88(%rip)      # 0xa198
movq %rax, 0x6e89(%rip)      # 0xa1a0
movq %rax, 0x6e8a(%rip)      # 0xa1a8
movq %rax, 0x6e8b(%rip)      # 0xa1b0
movq %rax, 0x6e8c(%rip)      # 0xa1b8
movq %rax, 0x6e8d(%rip)      # 0xa1c0
movq %rax, 0x6e8e(%rip)      # 0xa1c8
movq %rax, 0x6e8f(%rip)      # 0xa1d0
movq %rax, 0x6e90(%rip)      # 0xa1d8
movq %rax, 0x6e91(%rip)      # 0xa1e0
movq %rax, 0x6e92(%rip)      # 0xa1e8
leaq 0x850(%rip), %rsi       # 0x3bad
movl $0xf, %edi
callq 0x3120
cmpq $-0x1, %rax
je 0x336f
popq %rax
retq
leaq 0x2cc2(%rip), %rdi      # 0x6038
leaq 0x2cbd(%rip), %rsi      # 0x603a
leaq 0x2cbd(%rip), %rcx      # 0x6041
movl $0x2f, %edx
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/clee.c
// Function: clee_children_lookup
clee_tracee *clee_children_lookup(pid_t pid) {
    clee_tracee *tracee;
    _Bool found = false;
    int i;
    int len = list_size(&children);
    for (i = 0; i < len; i++) {
        tracee = list_get_at(&children, i);
        if (tracee->pid == pid) {
            found = true;
            break;
        }
    }
    return (found ? tracee : NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
leaq 0x6811(%rip), %rdi      # 0xa118
callq 0x466d
xorl %ebx, %ebx
testl %eax, %eax
jle 0x393b
movl %eax, %r14d
leaq 0x67fc(%rip), %r15      # 0xa118
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x41b9
cmpl %ebp, (%rax)
je 0x3938
incl %r12d
cmpl %r12d, %r14d
jne 0x391f
jmp 0x393b
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/clee.c
// Function: clee_children_delete
void clee_children_delete(pid_t pid) {
    clee_tracee *tracee = clee_children_lookup(pid);
    if (tracee == NULL) {
        CLEE_ERROR;
    }
    free(tracee);
    list_delete(&children, tracee);
}

// Assembly:
pushq %rbx
callq 0x38f6
testq %rax, %rax
je 0x396d
movq %rax, %rbx
movq %rax, %rdi
callq 0x3030
leaq 0x67b4(%rip), %rdi      # 0xa118
movq %rbx, %rsi
popq %rbx
jmp 0x435b
leaq 0x26c4(%rip), %rdi      # 0x6038
leaq 0x26bf(%rip), %rsi      # 0x603a
leaq 0x284e(%rip), %rcx      # 0x61d0
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/clee.c
// Function: clee_syscall
void clee_syscall() {
    clee_syscall_regs_get();
    if (syscall_regs.rax == -ENOSYS) {
        if (event_handlers.syscall_entry != NULL) {
            (event_handlers.syscall_entry)();
        }
        clee_syscall_regs_set();
    } else {
        if (event_handlers.syscall_exit != NULL) {
            (event_handlers.syscall_exit)();
        }
    }
}

// Assembly:
pushq %rax
callq 0x3c36
cmpq $-0x26, 0x68c6(%rip)    # 0xa260
jne 0x39b2
movq 0x67ed(%rip), %rcx      # 0xa190
testq %rcx, %rcx
je 0x39ac
xorl %eax, %eax
callq *%rcx
popq %rax
jmp 0x3c79
movq 0x67df(%rip), %rcx      # 0xa198
testq %rcx, %rcx
je 0x39c3
xorl %eax, %eax
popq %rdx
jmpq *%rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/clee.c
// Function: clee_read
ssize_t clee_read(void *src, void *dst, size_t len) {
    struct iovec remote = {src, len};
    struct iovec local = {dst, len};
    ssize_t readed;
    if ((readed = process_vm_readv(event_pid, &local, 1, &remote, 1, 0)) == -1) {
        CLEE_ERROR;
    }
    return readed;
}

// Assembly:
subq $0x28, %rsp
leaq 0x18(%rsp), %rcx
movq %rdi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movl 0x66fa(%rip), %edi      # 0xa1f4
movl $0x1, %edx
movl $0x1, %r8d
movq %rax, %rsi
xorl %r9d, %r9d
callq 0x3100
cmpq $-0x1, %rax
je 0x3b1b
addq $0x28, %rsp
retq
leaq 0x2516(%rip), %rdi      # 0x6038
leaq 0x2511(%rip), %rsi      # 0x603a
leaq 0x262d(%rip), %rcx      # 0x615d
movl $0x188, %edx            # imm = 0x188
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/clee.c
// Function: clee_write
ssize_t clee_write(void *src, void *dst, size_t len) {
    struct iovec remote = {dst, len};
    struct iovec local = {src, len};
    ssize_t written;
    if ((written = process_vm_writev(event_pid, &local, 1, &remote, 1, 0)) == -1) {
        CLEE_ERROR;
    }
    return written;
}

// Assembly:
subq $0x28, %rsp
leaq 0x18(%rsp), %rcx
movq %rsi, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
movq %rdx, 0x8(%rsi)
movl 0x6698(%rip), %edi      # 0xa1f4
movl $0x1, %edx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x31b0
cmpq $-0x1, %rax
je 0x3b7a
addq $0x28, %rsp
retq
leaq 0x24b7(%rip), %rdi      # 0x6038
leaq 0x24b2(%rip), %rsi      # 0x603a
leaq 0x25f8(%rip), %rcx      # 0x6187
movl $0x192, %edx            # imm = 0x192
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/clee.c
// Function: clee_kill
void clee_kill() {
    while (list_size(&children) > 0) {
        clee_tracee *tracee = list_get_at(&children, 0);
        kill(tracee->pid, 9);
        list_delete_at(&children, 0);
    }
}

// Assembly:
pushq %rbx
leaq 0x655e(%rip), %rdi      # 0xa118
callq 0x466d
testl %eax, %eax
je 0x3bf6
leaq 0x654e(%rip), %rbx      # 0xa118
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41b9
movl (%rax), %edi
movl $0x9, %esi
callq 0x3150
movq %rbx, %rdi
xorl %esi, %esi
callq 0x43ec
movq %rbx, %rdi
callq 0x466d
testl %eax, %eax
jne 0x3bca
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/clee.c
// Function: clee_process_exists
_Bool clee_process_exists(pid_t pid) {
    int result = kill(pid, 0);
    if (result == 0) {
        return true;
    } else if (errno == ESRCH) {
        return false;
    } else {
        CLEE_ERROR;
    }
}

// Assembly:
pushq %rbx
xorl %esi, %esi
callq 0x3150
movl %eax, %ebx
testl %eax, %eax
je 0x3c10
callq 0x3040
cmpl $0x3, (%rax)
jne 0x3c17
testl %ebx, %ebx
sete %al
popq %rbx
retq
leaq 0x241a(%rip), %rdi      # 0x6038
leaq 0x2415(%rip), %rsi      # 0x603a
leaq 0x25c5(%rip), %rcx      # 0x61f1
movl $0x1d4, %edx            # imm = 0x1D4
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_destroy
void list_destroy(list_t *restrict l) {
    unsigned int i;

    list_clear(l);
    for (i = 0; i < l->spareelsnum; i++) {
        free(l->spareels[i]);
    }
    free(l->spareels);
    free(l->head_sentinel);
    free(l->tail_sentinel);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3dba
movl 0x28(%rbx), %r15d
movq 0x20(%rbx), %r14
testq %r15, %r15
je 0x3d96
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x3030
incq %r12
cmpq %r12, %r15
jne 0x3d85
movq %r14, %rdi
callq 0x3030
movq (%rbx), %rdi
callq 0x3030
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_clear
int list_clear(list_t *restrict l) {
    struct list_entry_s *s;

    if (l->iter_active) return -1;
    
    if (l->attrs.copy_data) {        /* also free user data */
        /* spare a loop conditional with two loops: spareing elems and freeing elems */
        for (s = l->head_sentinel->next; l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS && s != l->tail_sentinel; s = s->next) {
            /* move elements as spares as long as there is room */
            if (s->data != NULL) free(s->data);
            l->spareels[l->spareelsnum++] = s;
        }
        while (s != l->tail_sentinel) {
            /* free the remaining elems */
            if (s->data != NULL) free(s->data);
            s = s->next;
            free(s->prev);
        }
        l->head_sentinel->next = l->tail_sentinel;
        l->tail_sentinel->prev = l->head_sentinel;
    } else { /* only free element containers */
        /* spare a loop conditional with two loops: spareing elems and freeing elems */
        for (s = l->head_sentinel->next; l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS && s != l->tail_sentinel; s = s->next) {
            /* move elements as spares as long as there is room */
            l->spareels[l->spareelsnum++] = s;
        }
        while (s != l->tail_sentinel) {
            /* free the remaining elems */
            s = s->next;
            free(s->prev);
        }
        l->head_sentinel->next = l->tail_sentinel;
        l->tail_sentinel->prev = l->head_sentinel;
    }
    l->numels = 0;
    l->mid = NULL;

    assert(list_repOk(l));

    return 0;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, 0x2c(%rdi)
je 0x3dc6
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x58(%rdi)
movq (%rdi), %r14
movq 0x8(%rdi), %r15
movl 0x28(%rdi), %r13d
movq 0x8(%r14), %r12
je 0x3e43
cmpl $0x4, %r13d
ja 0x3e3c
cmpq %r15, %r12
je 0x3e3c
movq (%r12), %rdi
testq %rdi, %rdi
je 0x3e00
callq 0x3030
movq 0x20(%rbx), %rax
leaq 0x1(%r13), %rcx
movl %ecx, 0x28(%rbx)
movq %r12, (%rax,%r13,8)
movq 0x8(%r12), %r12
movq %rcx, %r13
cmpq $0x5, %rcx
jne 0x3ded
jmp 0x3e3c
movq (%r12), %rdi
testq %rdi, %rdi
je 0x3e2d
callq 0x3030
movq 0x8(%r12), %r12
movq 0x10(%r12), %rdi
callq 0x3030
cmpq %r15, %r12
jne 0x3e1f
jmp 0x3e81
cmpl $0x4, %r13d
ja 0x3e7c
cmpq %r15, %r12
je 0x3e7c
movq 0x20(%rbx), %rax
leaq 0x1(%r13), %rcx
movl %ecx, 0x28(%rbx)
movq %r12, (%rax,%r13,8)
movq 0x8(%r12), %r12
movq %rcx, %r13
cmpq $0x5, %rcx
jne 0x3e49
jmp 0x3e7c
movq 0x8(%r12), %r12
movq 0x10(%r12), %rdi
callq 0x3030
cmpq %r15, %r12
jne 0x3e6d
movq %r15, 0x8(%r14)
movq %r14, 0x10(%r15)
movl $0x0, 0x18(%rbx)
movq $0x0, 0x10(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_attributes_copy
int list_attributes_copy(list_t *restrict l, element_meter metric_fun, int copy_data) {
    if (l == NULL || (metric_fun == NULL && copy_data != 0)) return -1;

    l->attrs.meter = metric_fun;
    l->attrs.copy_data = copy_data;

    assert(list_attrOk(l));

    return 0;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x3eec
testq %rsi, %rsi
sete %cl
testl %edx, %edx
setne %r8b
testb %r8b, %cl
jne 0x3eec
movq %rsi, 0x50(%rdi)
movl %edx, 0x58(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_extract_at
void *list_extract_at(list_t *restrict l, unsigned int pos) {
    struct list_entry_s *tmp;
    void *data;
    
    if (l->iter_active || pos >= l->numels) return NULL;

    tmp = list_findpos(l, pos);
    data = tmp->data;

    tmp->data = NULL;   /* save data from list_drop_elem() free() */
    list_drop_elem(l, tmp, pos);
    l->numels--;
    
    assert(list_repOk(l));

    return data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x2c(%rdi)
jne 0x4154
movl %esi, %edx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
cmpl %esi, %eax
jbe 0x4154
leal 0x1(%rdx), %ecx
cvtsi2ss %ecx, %xmm0
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movss 0x2caf(%rip), %xmm1     # 0x6ddc
ucomiss %xmm0, %xmm1
jae 0x4162
movss 0x2ca6(%rip), %xmm1     # 0x6de0
ucomiss %xmm0, %xmm1
jbe 0x4184
decl %eax
shrl %eax
incl %eax
movq %rbx, %rsi
movq 0x10(%rsi), %rsi
decl %eax
cmpl %edx, %eax
jg 0x4148
jmp 0x416d
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rsi
movq 0x8(%rsi), %rsi
decl %ecx
jne 0x4165
movq (%rsi), %r14
movq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x42c0
decl 0x18(%rbx)
jmp 0x4157
movss 0x2c58(%rip), %xmm1     # 0x6de4
ucomiss %xmm0, %xmm1
jae 0x41a1
movq 0x8(%rbx), %rsi
decl %eax
movq 0x10(%rsi), %rsi
cmpl %edx, %eax
jg 0x4195
jmp 0x416d
decl %eax
shrl %eax
movq 0x10(%rbx), %rsi
movl %edx, %ecx
subl %eax, %ecx
jbe 0x416d
movq 0x8(%rsi), %rsi
decl %ecx
jne 0x41af
jmp 0x416d
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_get_at
static inline struct list_entry_s *list_findpos(const list_t *restrict l, int posstart) {
    struct list_entry_s *ptr;
    float x;
    int i;

    /* accept 1 slot overflow for fetching head and tail sentinels */
    if (posstart < -1 || posstart > (int)l->numels) return NULL;

    x = (float)(posstart+1) / l->numels;
    if (x <= 0.25) {
        /* first quarter: get to posstart from head */
        for (i = -1, ptr = l->head_sentinel; i < posstart; ptr = ptr->next, i++);
    } else if (x < 0.5) {
        /* second quarter: get to posstart from mid */
        for (i = (l->numels-1)/2, ptr = l->mid; i > posstart; ptr = ptr->prev, i--);
    } else if (x <= 0.75) {
        /* third quarter: get to posstart from mid */
        for (i = (l->numels-1)/2, ptr = l->mid; i < posstart; ptr = ptr->next, i++);
    } else {
        /* fourth quarter: get to posstart from tail */
        for (i = l->numels, ptr = l->tail_sentinel; i > posstart; ptr = ptr->prev, i--);
    }

    return ptr;
}

// Assembly:
cmpl $-0x1, %esi
jl 0x421b
movl 0x18(%rdi), %eax
cmpl %esi, %eax
jl 0x421b
leal 0x1(%rsi), %ecx
cvtsi2ss %ecx, %xmm0
movl %eax, %edx
cvtsi2ss %rdx, %xmm1
divss %xmm1, %xmm0
movss 0x2bfd(%rip), %xmm1     # 0x6ddc
ucomiss %xmm0, %xmm1
jae 0x4203
movss 0x2bf4(%rip), %xmm1     # 0x6de0
ucomiss %xmm0, %xmm1
jbe 0x421e
decl %eax
shrl %eax
incl %eax
movq 0x10(%rdi), %rdi
decl %eax
cmpl %esi, %eax
jg 0x41f7
jmp 0x4212
movq (%rdi), %rdi
testl %esi, %esi
js 0x4212
movq 0x8(%rdi), %rdi
decl %ecx
jne 0x420a
testq %rdi, %rdi
je 0x421b
movq (%rdi), %rax
retq
xorl %eax, %eax
retq
movss 0x2bbe(%rip), %xmm1     # 0x6de4
ucomiss %xmm0, %xmm1
jae 0x423b
movq 0x8(%rdi), %rdi
cmpl %esi, %eax
jle 0x4212
decl %eax
movq 0x10(%rdi), %rdi
jmp 0x422f
decl %eax
shrl %eax
movq 0x10(%rdi), %rdi
subl %eax, %esi
jle 0x4212
movq 0x8(%rdi), %rdi
decl %esi
jne 0x4247
jmp 0x4212
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_get_minmax
static void *list_get_minmax(const list_t *restrict l, int versus) {
    void *curminmax;
    struct list_entry_s *s;

    if (l->attrs.comparator == NULL || l->numels == 0)
        return NULL;
    
    curminmax = l->head_sentinel->next->data;
    for (s = l->head_sentinel->next->next; s != l->tail_sentinel; s = s->next) {
        if (l->attrs.comparator(curminmax, s->data) * versus > 0)
            curminmax = s->data;
    }

    return curminmax;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x40(%rdi), %r15
testq %r15, %r15
je 0x42a9
cmpl $0x0, 0x18(%rdi)
je 0x42a9
movq (%rdi), %rax
movq 0x8(%rdi), %r12
movq 0x8(%rax), %rax
movq (%rax), %r14
movq 0x8(%rax), %r13
cmpq %r12, %r13
je 0x42ac
movl %esi, %ebx
movq (%r13), %rsi
movq %r14, %rdi
callq *%r15
imull %ebx, %eax
testl %eax, %eax
jle 0x429e
movq (%r13), %r14
movq 0x8(%r13), %r13
cmpq %r12, %r13
jne 0x4289
jmp 0x42ac
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_drop_elem
static int list_drop_elem(list_t *restrict l, struct list_entry_s *tmp, unsigned int pos) {
    if (tmp == NULL) return -1;

    /* fix mid pointer. This is wrt the PRE situation */
    if (l->numels % 2) {    /* now odd */
        /* sort out the base case by hand */
        if (l->numels == 1) l->mid = NULL;
        else if (pos >= l->numels/2) l->mid = l->mid->prev;
    } else {                /* now even */
        if (pos < l->numels/2) l->mid = l->mid->next;
    }
    
    tmp->prev->next = tmp->next;
    tmp->next->prev = tmp->prev;

    /* free what's to be freed */
    if (l->attrs.copy_data && tmp->data != NULL)
        free(tmp->data);

    if (l->spareelsnum < SIMCLIST_MAX_SPARE_ELEMS) {
        l->spareels[l->spareelsnum++] = tmp;
    } else {
        free(tmp);
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4344
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %eax
testb $0x1, %al
jne 0x42e6
shrl %eax
cmpl %edx, %eax
jbe 0x4307
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
jmp 0x4303
cmpl $0x1, %eax
jne 0x42f5
movq $0x0, 0x10(%r14)
jmp 0x4307
shrl %eax
cmpl %edx, %eax
ja 0x4307
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rax)
cmpl $0x0, 0x58(%r14)
je 0x432b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x432b
callq 0x3030
movl 0x28(%r14), %eax
cmpq $0x4, %rax
ja 0x434c
movq 0x20(%r14), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x28(%r14)
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_locate
int list_locate(const list_t *restrict l, const void *data) {
    struct list_entry_s *el;
    int pos = 0;
    
    if (l->attrs.comparator != NULL) {
        /* use comparator */
        for (el = l->head_sentinel->next; el != l->tail_sentinel; el = el->next, pos++) {
            if (l->attrs.comparator(data, el->data) == 0) break;
        }
    } else {
        /* compare references */
        for (el = l->head_sentinel->next; el != l->tail_sentinel; el = el->next, pos++) {
            if (el->data == data) break;
        }
    }
    if (el == l->tail_sentinel) return -1;

    return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x40(%rdi), %r12
movq (%rdi), %rax
movq 0x8(%rdi), %r14
movq 0x8(%rax), %r15
testq %r12, %r12
je 0x43ba
cmpq %r14, %r15
je 0x43d3
xorl %ebp, %ebp
movq (%r15), %rsi
movq %rbx, %rdi
callq *%r12
testl %eax, %eax
je 0x43d8
incl %ebp
movq 0x8(%r15), %r15
cmpq %r14, %r15
jne 0x43a0
jmp 0x43d5
cmpq %r14, %r15
je 0x43d3
xorl %ebp, %ebp
cmpq %rbx, (%r15)
je 0x43d8
incl %ebp
movq 0x8(%r15), %r15
cmpq %r14, %r15
jne 0x43c1
jmp 0x43d5
xorl %ebp, %ebp
movq %r14, %r15
cmpq %r14, %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_delete_at
int list_delete_at(list_t *restrict l, unsigned int pos) {
    struct list_entry_s *delendo;


    if (l->iter_active || pos >= l->numels) return -1;

    delendo = list_findpos(l, pos);

    list_drop_elem(l, delendo, pos);

    l->numels--;


    assert(list_repOk(l));

    return  0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x2c(%rdi)
jne 0x4473
movl %esi, %edx
movq %rdi, %r14
movl 0x18(%rdi), %eax
cmpl %esi, %eax
jbe 0x4473
cmpl $-0x1, %edx
setl %cl
cmpl %edx, %eax
setl %sil
xorl %ebx, %ebx
orb %cl, %sil
je 0x441e
xorl %esi, %esi
jmp 0x4467
leal 0x1(%rdx), %ecx
cvtsi2ss %ecx, %xmm0
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movss 0x29a7(%rip), %xmm1     # 0x6ddc
ucomiss %xmm0, %xmm1
jae 0x445c
movss 0x299e(%rip), %xmm1     # 0x6de0
ucomiss %xmm0, %xmm1
jbe 0x447d
decl %eax
shrl %eax
incl %eax
movq %r14, %rsi
movq 0x10(%rsi), %rsi
decl %eax
cmpl %edx, %eax
jg 0x4450
jmp 0x4467
movq (%r14), %rsi
movq 0x8(%rsi), %rsi
decl %ecx
jne 0x445f
movq %r14, %rdi
callq 0x42c0
decl 0x18(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movss 0x295f(%rip), %xmm1     # 0x6de4
ucomiss %xmm0, %xmm1
jae 0x449a
movq 0x8(%r14), %rsi
decl %eax
movq 0x10(%rsi), %rsi
cmpl %edx, %eax
jg 0x448e
jmp 0x4467
decl %eax
shrl %eax
movq 0x10(%r14), %rsi
movl %edx, %ecx
subl %eax, %ecx
jbe 0x4467
movq 0x8(%rsi), %rsi
decl %ecx
jne 0x44a8
jmp 0x4467
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_seek
void *list_seek(list_t *restrict l, const void *indicator) {
    const struct list_entry_s *iter;

    if (l->attrs.seeker == NULL) return NULL;

    for (iter = l->head_sentinel->next; iter != l->tail_sentinel; iter = iter->next) {
        if (l->attrs.seeker(iter->data, indicator) != 0) return iter->data;
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x46b7
movq %rsi, %r14
movq (%rdi), %r12
movq 0x8(%rdi), %r13
xorl %ebx, %ebx
movq 0x8(%r12), %r12
cmpq %r13, %r12
je 0x46b9
movq (%r12), %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
je 0x4699
movq (%r12), %rbx
jmp 0x46b9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_sort
int list_sort(list_t *restrict l, int versus) {
    if (l->iter_active || l->attrs.comparator == NULL) /* cannot modify list in the middle of an iteration */
        return -1;

    if (l->numels <= 1)
        return 0;
    list_sort_quicksort(l, versus, 0, l->head_sentinel->next, l->numels-1, l->tail_sentinel->prev);
    assert(list_repOk(l));
    return 0;
}

// Assembly:
pushq %rbx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x2c(%rdi)
je 0x482d
movl %ebx, %eax
popq %rbx
retq
cmpq $0x0, 0x40(%rdi)
je 0x4829
movl 0x18(%rdi), %r8d
xorl %ebx, %ebx
cmpl $0x2, %r8d
jb 0x4829
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x8(%rax), %rcx
decl %r8d
movq 0x10(%rdx), %r9
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x485d
jmp 0x4829
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_iterator_start
int list_iterator_start(list_t *restrict l) {
    if (l->iter_active) return 0;
    l->iter_pos = 0;
    l->iter_active = 1;
    l->iter_curentry = l->head_sentinel->next;
    return 1;
}

// Assembly:
xorl %eax, %eax
cmpl $0x0, 0x2c(%rdi)
je 0x4b25
retq
movq $0x1, 0x2c(%rdi)
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_iterator_next
void *list_iterator_next(list_t *restrict l) {
    void *toret;

    if (! l->iter_active) return NULL;

    toret = l->iter_curentry->data;
    l->iter_curentry = l->iter_curentry->next;
    l->iter_pos++;

    return toret;
}

// Assembly:
cmpl $0x0, 0x2c(%rdi)
je 0x4b57
movq 0x38(%rdi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x38(%rdi)
incl 0x30(%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_hash
int list_hash(const list_t *restrict l, list_hash_t *restrict hash) {
    struct list_entry_s *x;
    list_hash_t tmphash;
    
    assert(hash != NULL);

    tmphash = l->numels * 2 + 100;
    if (l->attrs.hasher == NULL) {
#ifdef SIMCLIST_ALLOW_LOCATIONBASED_HASHES
        /* ENABLE WITH CARE !! */
#warning "Memlocation-based hash is consistent only for testing modification in the same program run."
        int i;

        /* only use element references */
        for (x = l->head_sentinel->next; x != l->tail_sentinel; x = x->next) {
            for (i = 0; i < sizeof(x->data); i++) {
                tmphash += (tmphash ^ (uintptr_t)x->data);
            }
            tmphash += tmphash % l->numels;
        }
#else
        return -1;
#endif
    } else {
        /* hash each element with the user-given function */
        for (x = l->head_sentinel->next; x != l->tail_sentinel; x = x->next) {
            tmphash += tmphash ^ l->attrs.hasher(x->data);
            tmphash +=* hash % l->numels;
        }
    }

    *hash = tmphash;

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x60(%rdi), %r14
testq %r14, %r14
je 0x4bdc
movq %rsi, %rbx
movl 0x18(%rdi), %r15d
leal 0x64(,%r15,2), %ebp
movq (%rdi), %rax
movq 0x8(%rdi), %r12
movq 0x8(%rax), %r13
cmpq %r12, %r13
je 0x4be3
movq (%r13), %rdi
callq *%r14
movl %eax, %ecx
xorl %ebp, %ecx
movl (%rbx), %eax
xorl %edx, %edx
divl %r15d
addl %ebp, %edx
addl %ecx, %edx
movq 0x8(%r13), %r13
movl %edx, %ebp
cmpq %r12, %r13
jne 0x4bb9
jmp 0x4be5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4be9
movl %ebp, %edx
movl %edx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_dump_getinfo_file
int list_dump_getinfo_file(const char *restrict filename, list_dump_info_t *restrict info) {
    int fd, ret;

    fd = open(filename, O_RDONLY, 0);
    if (fd < 0) return -1;

    ret = list_dump_getinfo_filedescriptor(fd, info);
    close(fd);

    return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3190
testl %eax, %eax
js 0x4d9a
movl %eax, %ebp
movl %eax, %edi
movq %rbx, %rsi
callq 0x4bf8
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x4d9f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_dump_file
int list_dump_file(const list_t *restrict l, const char *restrict filename, size_t *restrict len) {
    int fd;
    size_t sizetoret;

    fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if (fd < 0) return -1;

    sizetoret = list_dump_filedescriptor(l, fd, len);
    close(fd);

    return sizetoret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x242, %esi            # imm = 0x242
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x3190
testl %eax, %eax
js 0x5592
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x4da6
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x5597
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/simclist.c
// Function: list_restore_file
int list_restore_file(list_t *restrict l, const char *restrict filename, size_t *restrict len) {
    int fd;
    size_t totdata;

    fd = open(filename, O_RDONLY, 0);
    if (fd < 0) return -1;

    totdata = list_restore_filedescriptor(l, fd, len);
    close(fd);

    return totdata;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3190
testl %eax, %eax
js 0x55d4
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x513f
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x55d9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/seojangho[P]clee/interpose.c
// Function: onSyscallEntry
void onSyscallEntry() {
    if (clee_syscall_num() == 1 && option_write2read) {
        clee_syscall_set(0);
    }
    if (clee_syscall_num() == 1 && option_write_stdout) {
        clee_set_arg(0, 1);
    }
    if (clee_syscall_num() == 1 && clee_get_arg(0) == 1 && option_nullify_stdout) {
        char null = '\0';
        int len = clee_get_arg(2);
        void *pos = (void*)clee_get_arg(1);
        int i;
        for (i = 0; i < len; i++) {
            clee_write(&null, pos + i, 1);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
callq 0x39cc
cmpq $0x1, %rax
jne 0x578a
cmpb $0x1, 0x4b67(%rip)      # 0xa2e8
jne 0x578a
xorl %edi, %edi
callq 0x39d4
xorl %eax, %eax
callq 0x39cc
cmpq $0x1, %rax
jne 0x57ac
cmpb $0x1, 0x4b4b(%rip)      # 0xa2e9
jne 0x57ac
movl $0x1, %esi
xorl %edi, %edi
callq 0x3a2b
xorl %eax, %eax
callq 0x39cc
cmpq $0x1, %rax
jne 0x5815
xorl %edi, %edi
callq 0x39f5
cmpq $0x1, %rax
jne 0x5815
cmpb $0x1, 0x4b1d(%rip)      # 0xa2ea
jne 0x5815
movb $0x0, 0xf(%rsp)
movl $0x2, %edi
callq 0x39f5
movq %rax, %rbx
movl $0x1, %edi
callq 0x39f5
testl %ebx, %ebx
jle 0x5815
movq %rax, %r14
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b3a
incq %r14
decq %rbx
jne 0x57fd
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/turquoise-hexagon[P]st/x.c
// Function: xloadcolor
int
xloadcolor(int i, const char *name, Color *ncolor)
{
	if (!name)
		if (BETWEEN(i, 16, 255))
			name = colorname[7];
		else
			name = colorname[i];

	return XftColorAllocName(xw.dpy, xw.vis, xw.cmap, name, ncolor);
}

// Assembly:
movq %rdx, %r8
movq %rsi, %rcx
testq %rsi, %rsi
jne 0xa1e5
leal -0x10(%rdi), %eax
cmpl $0xf0, %eax
jae 0xa1d7
leaq 0x4a74(%rip), %rcx      # 0xec49
jmp 0xa1e5
movslq %edi, %rax
leaq 0x884f(%rip), %rcx      # 0x12a30
movq (%rcx,%rax,8), %rcx
movq 0xdabc(%rip), %rdi      # 0x17ca8
movq 0xdb2d(%rip), %rsi      # 0x17d20
movq 0xdab6(%rip), %rdx      # 0x17cb0
jmp 0x54e0
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_16/longest_line.c
// Function: get_line
int get_line(char line[], int maxline)
{
  int c, i;

  for (i = 0; i < maxline - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }
  if (c == '\n')
  {
    line[i] = c;
    ++i;
  }
  
  line[i] = '\0';
  
  while(c != EOF && c != '\n')
  {
    ++i;
    c = getchar();
  }
  
  if (c == '\n')
    ++i;

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ecx, %ecx
cmpl $0x2, %esi
jl 0x1215
movl %esi, %ebx
decl %ebx
movl %ebx, %r12d
xorl %r15d, %r15d
callq 0x1040
cmpl $-0x1, %eax
je 0x120b
cmpl $0xa, %eax
je 0x120b
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %r12
jne 0x11ee
jmp 0x120e
movl %r15d, %ebx
movl %ebx, %ecx
cmpl $0xa, %eax
jne 0x1225
movl %ecx, %eax
movb $0xa, (%r14,%rax)
incl %ecx
movl $0xa, %eax
movl %ecx, %ebx
movslq %ebx, %rcx
movb $0x0, (%r14,%rcx)
cmpl $-0x1, %eax
je 0x1240
incl %ebx
cmpl $0xa, %eax
je 0x1240
callq 0x1040
jmp 0x122d
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pyk[P]simple-nn/deps/pcg/src/pcg-advance-16.c
// Function: pcg_advance_lcg_16
uint16_t pcg_advance_lcg_16(uint16_t state, uint16_t delta, uint16_t cur_mult,
                            uint16_t cur_plus)
{
    uint16_t acc_mult = 1u;
    uint16_t acc_plus = 0u;
    while (delta > 0) {
        if (delta & 1) {
            acc_mult *= cur_mult;
            acc_plus = acc_plus * cur_mult + cur_plus;
        }
        cur_plus = (cur_mult + 1) * cur_plus;
        cur_mult *= cur_mult;
        delta /= 2;
    }
    return acc_mult * state + acc_plus;
}

// Assembly:
testl %esi, %esi
je 0x1753
pushq %rbx
movw $0x1, %r8w
xorl %r10d, %r10d
movl $0x1, %r9d
movl %r10d, %eax
imull %edx, %eax
addl %ecx, %eax
testb $0x1, %sil
movl %edx, %r11d
cmovel %r9d, %r11d
movzwl %si, %ebx
cmovel %r10d, %eax
imull %r11d, %r8d
leal 0x1(%rdx), %r11d
imull %ecx, %r11d
imull %edx, %edx
movl %ebx, %esi
shrl %esi
movl %eax, %r10d
movl %r11d, %ecx
cmpw $0x1, %bx
ja 0x1717
popq %rbx
jmp 0x175a
movw $0x1, %r8w
xorl %eax, %eax
imull %edi, %r8d
addl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/gmcvicker[P]check_fastq/split_fastq.c
// Function: check_line_len
static void check_line_len(ReadSeq *read, char *line, gzFile f) {
  size_t len, n;
  char c;

  len = strlen(line);
  if(len == 0) {
    return;
  }
  if(line[len-1] == '\n') {
    return;
  }
  
  /* line did not terminate with a '\n' */
  my_warn("%s:%d: line did not terminate with '\\n':  \n'%s'\n", 
          __FILE__, __LINE__, line, len);

  read->status = FASTQ_ERR;

  /* seek in file until next '\n' is found */
  n = 0;
  while((c = gzgetc(f)) != -1) {
    n++;

    if(n < 10) {
      if(isprint(c)) {
        fprintf(stderr, "  extra character %ld: '%c'\n", n, c);
      }
      else {
        fprintf(stderr, "  unprintable extra character %ld: '\\%d'\n", n, c);
      }
    } else if(n == 10) {
      fprintf(stderr, "  ...\n");      
    }
    
    if(c == '\n') {
      fprintf(stderr, "  read %ld extra characters to reach end of line\n", n);
      return;
    }
  }

  fprintf(stderr, "  read %ld extra characters to reach end of file\n", n);
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1110
testq %rax, %rax
je 0x1ef5
cmpb $0xa, -0x1(%r15,%rax)
jne 0x1f04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x236b(%rip), %rdi      # 0x4276
leaq 0x2154(%rip), %rsi      # 0x4066
movl $0x44, %edx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x1cdc
movl $0x1, 0x1420(%r14)
movq 0x50c2(%rip), %r15      # 0x6ff8
xorl %r14d, %r14d
movq %r14, %r12
movl (%rbx), %eax
testl %eax, %eax
je 0x1f5b
decl %eax
movl %eax, (%rbx)
incq 0x10(%rbx)
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movb (%rax), %r13b
jmp 0x1f66
movq %rbx, %rdi
callq 0x10f0
movl %eax, %r13d
cmpb $-0x1, %r13b
je 0x1fc4
leaq 0x1(%r12), %r14
cmpq $0x9, %r14
jbe 0x1f85
cmpq $0x9, %r12
je 0x1fa7
cmpb $0xa, %r13b
jne 0x1f39
jmp 0x1fd3
movsbl %r13b, %r12d
callq 0x1290
movq (%rax), %rax
movslq %r12d, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
movq (%r15), %rdi
jne 0x1fae
leaq 0x231f(%rip), %rsi      # 0x42c4
jmp 0x1fb5
callq 0x1cad
jmp 0x1f7d
leaq 0x22f2(%rip), %rsi      # 0x42a7
movq %r14, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1170
jmp 0x1f7d
movq (%r15), %rdi
leaq 0x2359(%rip), %rsi      # 0x4327
movq %r12, %rdx
jmp 0x1fe0
movq (%r15), %rdi
leaq 0x2318(%rip), %rsi      # 0x42f5
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1170
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Marinouel[P]Network-Lab/client.c
// Function: writen
ssize_t writen(int fd, const void *vptr, size_t n)				//function given from the lessons
 {
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;
    ptr = vptr;
	nleft = n;
	while (nleft > 0) {

		if  ((nwritten = write(fd, ptr, nleft)) <= 0 ){ 
			if (errno == EINTR) 
				nwritten = 0;
          	else 
          		return -1; /* error */ 
		} 
		nleft -= nwritten;
        ptr += nwritten;
	} 
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x1251
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movq %rdx, %r12
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1060
testq %rax, %rax
jg 0x1247
callq 0x1050
cmpl $0x4, (%rax)
jne 0x1255
xorl %eax, %eax
addq %rax, %r14
subq %rax, %r12
jne 0x1228
jmp 0x125c
xorl %ebx, %ebx
jmp 0x125c
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.5/sigusr1.c
// Function: main
int main ()
{
	struct sigaction sa;
	memset (&sa, 0, sizeof (sa));
	sa.sa_handler = &handler;
	sigaction (SIGUSR1, &sa, NULL);
	int pid = (int) getpid();
	for (int i=0; i<10; i++)	
        kill(pid, SIGUSR1);
	printf ("SIGUSR1 was raised %d times\n", sigusr1_count);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
leaq -0xa0(%rbp), %rbx
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1040
leaq -0x37(%rip), %rax       # 0x117c
movq %rax, -0x8(%rbx)
movl $0xa, %r14d
leaq -0xa8(%rbp), %rsi
movl $0xa, %edi
xorl %edx, %edx
callq 0x1050
callq 0x1070
movl %eax, %ebx
movl %ebx, %edi
movl $0xa, %esi
callq 0x1060
decl %r14d
jne 0x11d7
movl 0x2e66(%rip), %esi      # 0x4054
leaq 0xe0f(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: check_existant
int		check_existant(char **av, int i)
{
	int		j;
	int		len;

	j = 1;
	while (j < i)
	{
		if (ft_strlen(av[j]) > ft_strlen(av[i]))
			len = ft_strlen(av[j]);
		else
			len = ft_strlen(av[i]);
		if (!ft_strncmp(av[j], av[i], len))
			return (1);
		j++;
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ebx, %ebx
cmpl $0x2, %esi
jl 0x12d9
movq %rdi, %r14
movl %esi, %r12d
leaq (%rdi,%r12,8), %r13
addq $0x8, %r14
decq %r12
movq (%r14), %rdi
callq 0x3412
movq %rax, %r15
movq (%r13), %rdi
callq 0x3412
cmpq %rax, %r15
movq %r13, %rax
cmovaq %r14, %rax
movq (%rax), %rdi
callq 0x3412
movq (%r14), %rdi
movq (%r13), %rsi
movslq %eax, %rdx
callq 0x3441
testl %eax, %eax
je 0x12d4
addq $0x8, %r14
decq %r12
jne 0x1290
jmp 0x12d9
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: parsing_ac
int		parsing_ac(char *av)
{
	int		i;
	int		minus;

	i = 0;
	minus = 0;
	while (av[i])
	{
		if (av[i] == '-')
			minus++;
		if (av[i] > '9' || av[i] < '0')
		{
			if (av[i] != '-' || minus > 1)
				return (-1);
		}
		i++;
	}
	return (0);
}

// Assembly:
xorl %ecx, %ecx
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x12fd
testl %eax, %eax
je 0x1313
leal -0x3a(%rax), %edx
cmpb $-0xb, %dl
jbe 0x12ff
jmp 0x130e
incl %ecx
cmpl $0x2d, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x1313
cmpl $0x1, %ecx
jg 0x1313
incq %rdi
jmp 0x12e7
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: fill_list_a
t_list	*fill_list_a(char *av)
{
	t_list	*new;
	t_data	*new_data;

	if (!(new_data = malloc(sizeof(t_data))))
		return (NULL);
	new_data->value = ft_atoi(av);
	new_data->index = 0;
	new_data->keep = 0;
	new = ft_lstnew(new_data);
	return (new);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xc, %edi
callq 0x1090
testq %rax, %rax
je 0x1365
movq %rax, %rbx
movq %r14, %rdi
callq 0x34dd
movl %eax, (%rbx)
movq $0x0, 0x4(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32c9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop