LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/linenoise/linenoise.c
// Function: linenoiseEditBackspace
void linenoiseEditBackspace(struct linenoiseState *l) {
    if (l->pos > 0 && l->len > 0) {
        memmove(l->buf+l->pos-1,l->buf+l->pos,l->len-l->pos);
        l->pos--;
        l->len--;
        l->buf[l->len] = '\0';
        refreshLine(l);
    }
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1a74b
movq %rdi, %rbx
movq 0x38(%rdi), %rdx
testq %rdx, %rdx
je 0x1a74b
movq 0x8(%rbx), %rsi
leaq (%rsi,%rax), %rdi
decq %rdi
addq %rax, %rsi
subq %rax, %rdx
callq 0xc4d0
decq 0x28(%rbx)
movq 0x8(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x38(%rbx)
movb $0x0, -0x1(%rax,%rcx)
movq %rbx, %rdi
popq %rbx
jmp 0x19fd9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/linenoise/linenoise.c
// Function: linenoiseEditDeletePrevWord
void linenoiseEditDeletePrevWord(struct linenoiseState *l) {
    size_t old_pos = l->pos;
    size_t diff;

    while (l->pos > 0 && l->buf[l->pos-1] == ' ')
        l->pos--;
    while (l->pos > 0 && l->buf[l->pos-1] != ' ')
        l->pos--;
    diff = old_pos - l->pos;
    memmove(l->buf+l->pos,l->buf+old_pos,l->len-old_pos+1);
    l->len -= diff;
    refreshLine(l);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1a775
movq 0x8(%rbx), %rcx
leaq -0x1(%rax), %rdx
cmpb $0x20, (%rcx,%rdx)
jne 0x1a775
movq %rdx, 0x28(%rbx)
addq $-0x1, %rdx
jb 0x1a765
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x1a796
movq 0x8(%rbx), %rcx
cmpb $0x20, -0x1(%rcx,%r14)
je 0x1a796
decq %r14
movq %r14, 0x28(%rbx)
jne 0x1a782
xorl %r14d, %r14d
movq 0x8(%rbx), %rsi
movq 0x38(%rbx), %rdx
leaq (%rsi,%r14), %rdi
subq %rax, %r14
addq %rax, %rsi
subq %rax, %rdx
incq %rdx
callq 0xc4d0
addq %r14, 0x38(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19fd9
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/linenoise/linenoise.c
// Function: linenoisePrintKeyCodes
void linenoisePrintKeyCodes(void) {
    char quit[4];

    printf("Linenoise key codes debugging mode.\n"
            "Press keys to see scan codes. Type 'quit' at any time to exit.\n");
    if (enableRawMode(STDIN_FILENO) == -1) return;
    memset(quit,' ',4);
    while(1) {
        char c;
        int nread;

        nread = read(STDIN_FILENO,&c,1);
        if (nread <= 0) continue;
        memmove(quit,quit+1,sizeof(quit)-1); /* shift string to left. */
        quit[sizeof(quit)-1] = c; /* Insert current char on the right. */
        if (memcmp(quit,"quit",sizeof(quit)) == 0) break;

        printf("'%c' %02x (%d) (type quit to exit)\n",
            isprint(c) ? c : '?', (int)c, (int)c);
        printf("\r"); /* Go left edge manually, we are in raw mode. */
        fflush(stdout);
    }
    disableRawMode(STDIN_FILENO);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x21ad1(%rip), %rdi     # 0x3c2aa
callq 0xc0e0
callq 0x1a8b8
cmpl $-0x1, %eax
je 0x1a8ab
leaq 0xd(%rsp), %r15
movl $0x20202020, -0x1(%r15) # imm = 0x20202020
leaq 0xb(%rsp), %rbx
leaq 0x21a2f(%rip), %r14     # 0x3c234
movq 0x317b4(%rip), %r12     # 0x4bfc0
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0xc2c0
testl %eax, %eax
jle 0x1a80c
movzwl (%r15), %eax
movb 0x2(%r15), %cl
movb %cl, 0xe(%rsp)
movw %ax, 0xc(%rsp)
movsbl 0xb(%rsp), %ebp
movb %bpl, 0xf(%rsp)
cmpl $0x74697571, 0xc(%rsp)  # imm = 0x74697571
je 0x1a883
callq 0xc690
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xe, %eax
movl $0x3f, %esi
jae 0x1a860
movl %ebp, %esi
movq %r14, %rdi
movl %ebp, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0xc1e0
movl $0xd, %edi
callq 0xc070
movq (%r12), %rdi
callq 0xc410
jmp 0x1a80c
cmpb $0x1, 0x324b6(%rip)     # 0x4cd40
jne 0x1a8ab
leaq 0x32471(%rip), %rdx     # 0x4cd04
xorl %edi, %edi
movl $0x2, %esi
callq 0xc500
cmpl $-0x1, %eax
je 0x1a8ab
movb $0x0, 0x32495(%rip)     # 0x4cd40
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/linenoise/linenoise.c
// Function: enableRawMode
static int enableRawMode(int fd) {
    struct termios raw;

    if (!isatty(STDIN_FILENO)) goto fatal;
    if (!atexit_registered) {
        atexit(linenoiseAtExit);
        atexit_registered = 1;
    }
    if (tcgetattr(fd,&orig_termios) == -1) goto fatal;

    raw = orig_termios;  /* modify the original mode */
    /* input modes: no break, no CR to NL, no parity check, no strip char,
     * no start/stop output control. */
    raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
    /* output modes - disable post processing */
    raw.c_oflag &= ~(OPOST);
    /* control modes - set 8 bit chars */
    raw.c_cflag |= (CS8);
    /* local modes - choing off, canonical off, no extended functions,
     * no signal chars (^Z,^C) */
    raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    /* control chars - set return condition: min number of bytes and timer.
     * We want read to return every single byte, without timeout. */
    raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */

    /* put terminal in raw mode after flushing */
    if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal;
    rawmode = 1;
    return 0;

fatal:
    errno = ENOTTY;
    return -1;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorl %edi, %edi
callq 0xc0f0
testl %eax, %eax
je 0x1a95f
cmpb $0x0, 0x3242d(%rip)     # 0x4cd00
jne 0x1a8e8
leaq 0xb3a(%rip), %rdi       # 0x1b416
callq 0x38d70
movb $0x1, 0x32418(%rip)     # 0x4cd00
leaq 0x32415(%rip), %rsi     # 0x4cd04
xorl %edi, %edi
callq 0xc4f0
cmpl $-0x1, %eax
je 0x1a95f
movups 0x32402(%rip), %xmm0    # 0x4cd04
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movups 0x32405(%rip), %xmm0    # 0x4cd14
movaps %xmm0, 0x10(%rdx)
movups 0x32416(%rip), %xmm0    # 0x4cd30
movups %xmm0, 0x2c(%rdx)
movups 0x323ff(%rip), %xmm0    # 0x4cd24
andl $0xfffffacd, (%rdx)     # imm = 0xFFFFFACD
movaps %xmm0, 0x20(%rdx)
andb $-0x2, 0x4(%rdx)
orb $0x30, 0x8(%rdx)
andl $0xffff7ff4, 0xc(%rdx)  # imm = 0xFFFF7FF4
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x2, %esi
callq 0xc500
testl %eax, %eax
js 0x1a95f
movb $0x1, 0x323e3(%rip)     # 0x4cd40
jmp 0x1a96f
callq 0xc0a0
movl $0x19, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/linenoise/linenoise.c
// Function: linenoiseHistoryAdd
int linenoiseHistoryAdd(const char *line) {
    char *linecopy;

    if (history_max_len == 0) return 0;

    /* Initialization on first call. */
    if (history == NULL) {
        history = malloc(sizeof(char*)*history_max_len);
        if (history == NULL) return 0;
        memset(history,0,(sizeof(char*)*history_max_len));
    }

    /* Don't add duplicated lines. */
    if (history_len && !strcmp(history[history_len-1], line)) return 0;

    /* Add an heap allocated copy of the line in the history.
     * If we reached the max length, remove the older line. */
    linecopy = strdup(line);
    if (!linecopy) return 0;
    if (history_len == history_max_len) {
        free(history[0]);
        memmove(history,history+1,sizeof(char*)*(history_max_len-1));
        history_len--;
    }
    history[history_len] = linecopy;
    history_len++;
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x3196a(%rip), %ebx     # 0x4cae0
cmpq $0x0, 0x31b7a(%rip)     # 0x4ccf8
jne 0x1b1ad
leaq (,%rbx,8), %r15
movq %r15, %rdi
callq 0xc3f0
movq %rax, 0x31b61(%rip)     # 0x4ccf8
testq %rax, %rax
je 0x1b236
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xc250
movslq 0x31b3c(%rip), %r12     # 0x4ccf0
testq %r12, %r12
je 0x1b1d1
movq 0x31b38(%rip), %rax     # 0x4ccf8
movq -0x8(%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0xc330
testl %eax, %eax
je 0x1b236
movq %r14, %rdi
callq 0xc600
testq %rax, %rax
je 0x1b236
movq %rax, %r14
cmpl %ebx, %r12d
jne 0x1b214
movq 0x31b0b(%rip), %r15     # 0x4ccf8
movq (%r15), %rdi
callq 0xc060
leaq 0x8(%r15), %rsi
decl %ebx
shlq $0x3, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0xc4d0
decl %r12d
movl %r12d, 0x31adc(%rip)    # 0x4ccf0
movq 0x31add(%rip), %rax     # 0x4ccf8
movslq 0x31ace(%rip), %rcx     # 0x4ccf0
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x31ac1(%rip)     # 0x4ccf0
movl $0x1, %eax
jmp 0x1b238
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/linenoise/linenoise.c
// Function: linenoiseHistorySetMaxLen
int linenoiseHistorySetMaxLen(int len) {
    char **new;

    if (len < 1) return 0;
    if (history) {
        int tocopy = history_len;

        new = malloc(sizeof(char*)*len);
        if (new == NULL) return 0;

        /* If we can't copy everything, free the elements we'll not use. */
        if (len < tocopy) {
            int j;

            for (j = 0; j < tocopy-len; j++) free(history[j]);
            tocopy = len;
        }
        memset(new,0,sizeof(char*)*len);
        memcpy(new,history+(history_len-tocopy), sizeof(char*)*tocopy);
        free(history);
        history = new;
    }
    history_max_len = len;
    if (history_len > history_max_len)
        history_len = history_max_len;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testl %edi, %edi
jle 0x1b305
movl %edi, %ebx
movq 0x31a96(%rip), %r14     # 0x4ccf8
testq %r14, %r14
je 0x1b2ec
movl 0x31a7e(%rip), %r13d    # 0x4ccf0
movl %ebx, %r12d
shlq $0x3, %r12
movq %r12, %rdi
callq 0xc3f0
testq %rax, %rax
je 0x1b305
movq %rax, %r15
movl %r13d, %eax
movl %r13d, %ebp
subl %ebx, %eax
jle 0x1b2b7
movl %ebx, %ebp
jle 0x1b2b7
movq %r15, (%rsp)
movl %eax, %ebp
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0xc060
incq %r15
cmpq %r15, %rbp
jne 0x1b2a0
movl %ebx, %ebp
movq (%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xc250
subl %ebp, %r13d
movslq %r13d, %rax
leaq (%r14,%rax,8), %rsi
movslq %ebp, %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc3a0
movq %r14, %rdi
callq 0xc060
movq %r15, 0x31a0c(%rip)     # 0x4ccf8
movl %ebx, 0x317ee(%rip)     # 0x4cae0
movl $0x1, %ebp
cmpl %ebx, 0x319f3(%rip)     # 0x4ccf0
jle 0x1b305
movl %ebx, 0x319eb(%rip)     # 0x4ccf0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/linenoise/linenoise.c
// Function: getCursorPosition
static int getCursorPosition(int ifd, int ofd) {
    char buf[32];
    int cols, rows;
    unsigned int i = 0;

    /* Report cursor location */
    if (write(ofd, "\x1b[6n", 4) != 4) return -1;

    /* Read the response: ESC [ rows ; cols R */
    while (i < sizeof(buf)-1) {
        if (read(ifd,buf+i,1) != 1) break;
        if (buf[i] == 'R') break;
        i++;
    }
    buf[i] = '\0';

    /* Parse it. */
    if (buf[0] != ESC || buf[1] != '[') return -1;
    if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1;
    return cols;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x20e0f(%rip), %rsi     # 0x3c29f
movl $0x4, %edx
movl $0x1, %edi
callq 0xc170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $0x4, %rax
jne 0x1b51d
xorl %r14d, %r14d
leaq (%rsp,%r14), %rsi
addq $0x10, %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0xc2c0
cmpq $0x1, %rax
jne 0x1b4de
cmpb $0x52, 0x10(%rsp,%r14)
je 0x1b4de
incq %r14
cmpq $0x1f, %r14
jne 0x1b4ad
movl $0x1f, %r14d
movb $0x0, 0x10(%rsp,%r14)
cmpb $0x1b, 0x10(%rsp)
jne 0x1b51d
cmpb $0x5b, 0x11(%rsp)
jne 0x1b51d
leaq 0x12(%rsp), %rdi
leaq 0x20da6(%rip), %rsi     # 0x3c2a4
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0xc420
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2, %eax
jne 0x1b51d
movl 0x8(%rsp), %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20c98
testq %rax, %rax
jne 0x18802
callq 0x189d8
callq 0x18818
movq %rax, %r14
decl %ebp
leaq 0x8(%rbx), %rsi
movl %ebp, %edi
callq 0x224fb
movq %rax, %r15
movq %rax, %rdi
callq 0x2233e
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x28f24
testl %eax, %eax
sete %bpl
movq (%r12), %rdi
testq %rdi, %rdi
setne %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x187c9
leaq 0x8(%rsp), %r12
callq 0x2201e
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x28f24
testl %eax, %eax
sete %bpl
jne 0x187c9
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x187a4
testb %bpl, %bpl
je 0x18809
leaq 0x6283e(%rip), %rdi     # 0x7b013
callq 0x77d0
movq %r15, %rdi
callq 0x28eaa
movq %r14, %rdi
callq 0x18999
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 0x187f2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a4d
jmp 0x187da
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3ce0
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 0x856(%rip), %rsi       # 0x3bb3
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_O1/seojangho[P]clee/clee.c
// Function: clee_children_add
void clee_children_add(pid_t pid) {
    clee_tracee *new_tracee = malloc(sizeof(clee_tracee));
    if (new_tracee == NULL) {
        CLEE_ERROR;
    }
    new_tracee->pid = pid;
    list_append(&children, new_tracee);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0x4, %edi
callq 0x3160
testq %rax, %rax
je 0x35a7
movl %ebx, (%rax)
leaq 0x6b7a(%rip), %rdi      # 0xa118
movq %rax, %rsi
popq %rbx
jmp 0x3f2d
leaq 0x2a8a(%rip), %rdi      # 0x6038
leaq 0x2a85(%rip), %rsi      # 0x603a
leaq 0x2bf6(%rip), %rcx      # 0x61b2
movl $0x1af, %edx            # imm = 0x1AF
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O1/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 0x680b(%rip), %rdi      # 0xa118
callq 0x46ba
xorl %ebx, %ebx
testl %eax, %eax
jle 0x3941
movl %eax, %r14d
leaq 0x67f6(%rip), %r15      # 0xa118
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x41ca
cmpl %ebp, (%rax)
je 0x393e
incl %r12d
cmpl %r12d, %r14d
jne 0x3925
jmp 0x3941
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x38fc
testq %rax, %rax
je 0x3973
movq %rax, %rbx
movq %rax, %rdi
callq 0x3030
leaq 0x67ae(%rip), %rdi      # 0xa118
movq %rbx, %rsi
popq %rbx
jmp 0x437b
leaq 0x26be(%rip), %rdi      # 0x6038
leaq 0x26b9(%rip), %rsi      # 0x603a
leaq 0x2848(%rip), %rcx      # 0x61d0
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O1/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 0x3c3c
cmpq $-0x26, 0x68c0(%rip)    # 0xa260
jne 0x39b8
movq 0x67e7(%rip), %rcx      # 0xa190
testq %rcx, %rcx
je 0x39b2
xorl %eax, %eax
callq *%rcx
popq %rax
jmp 0x3c7f
movq 0x67d9(%rip), %rcx      # 0xa198
testq %rcx, %rcx
je 0x39c9
xorl %eax, %eax
popq %rdx
jmpq *%rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x66f4(%rip), %edi      # 0xa1f4
movl $0x1, %edx
movl $0x1, %r8d
movq %rax, %rsi
xorl %r9d, %r9d
callq 0x3100
cmpq $-0x1, %rax
je 0x3b21
addq $0x28, %rsp
retq
leaq 0x2510(%rip), %rdi      # 0x6038
leaq 0x250b(%rip), %rsi      # 0x603a
leaq 0x2627(%rip), %rcx      # 0x615d
movl $0x188, %edx            # imm = 0x188
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O1/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 0x6692(%rip), %edi      # 0xa1f4
movl $0x1, %edx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x31b0
cmpq $-0x1, %rax
je 0x3b80
addq $0x28, %rsp
retq
leaq 0x24b1(%rip), %rdi      # 0x6038
leaq 0x24ac(%rip), %rsi      # 0x603a
leaq 0x25f2(%rip), %rcx      # 0x6187
movl $0x192, %edx            # imm = 0x192
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O1/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 0x6558(%rip), %rdi      # 0xa118
callq 0x46ba
testl %eax, %eax
je 0x3bfc
leaq 0x6548(%rip), %rbx      # 0xa118
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41ca
movl (%rax), %edi
movl $0x9, %esi
callq 0x3150
movq %rbx, %rdi
xorl %esi, %esi
callq 0x441a
movq %rbx, %rdi
callq 0x46ba
testl %eax, %eax
jne 0x3bd0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c16
callq 0x3040
cmpl $0x3, (%rax)
jne 0x3c1d
testl %ebx, %ebx
sete %al
popq %rbx
retq
leaq 0x2414(%rip), %rdi      # 0x6038
leaq 0x240f(%rip), %rsi      # 0x603a
leaq 0x25bf(%rip), %rcx      # 0x61f1
movl $0x1d4, %edx            # imm = 0x1D4
callq 0x30c0
// File: /workspace/github_c_makefile_star2_O1/seojangho[P]clee/simclist.c
// Function: list_init
int list_init(list_t *restrict l) {
    if (l == NULL) return -1;

    seed_random();

    l->numels = 0;

    /* head/tail sentinels and mid pointer */
    l->head_sentinel = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
    l->tail_sentinel = (struct list_entry_s *)malloc(sizeof(struct list_entry_s));
    l->head_sentinel->next = l->tail_sentinel;
    l->tail_sentinel->prev = l->head_sentinel;
    l->head_sentinel->prev = l->tail_sentinel->next = l->mid = NULL;
    l->head_sentinel->data = l->tail_sentinel->data = NULL;

    /* iteration attributes */
    l->iter_active = 0;
    l->iter_pos = 0;
    l->iter_curentry = NULL;

    /* free-list attributes */
    l->spareels = (struct list_entry_s **)malloc(SIMCLIST_MAX_SPARE_ELEMS * sizeof(struct list_entry_s *));
    l->spareelsnum = 0;

#ifdef SIMCLIST_WITH_THREADS
    l->threadcount = 0;
#endif

    list_attributes_setdefaults(l);

    assert(list_repOk(l));
    assert(list_attrOk(l));

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3d5c
movq %rdi, %r14
xorl %ebx, %ebx
movl %ebx, 0x18(%rdi)
movl $0x18, %edi
callq 0x3160
movq %rax, %r15
movq %rax, (%r14)
movl $0x18, %edi
callq 0x3160
movq %rax, 0x8(%r14)
movq %rax, 0x8(%r15)
movq %r15, 0x10(%rax)
movq %rbx, 0x10(%r14)
movq %rbx, 0x8(%rax)
movq %rbx, 0x10(%r15)
movq %rbx, (%rax)
movq %rbx, (%r15)
movq %rbx, 0x2c(%r14)
movq %rbx, 0x38(%r14)
movl $0x28, %edi
callq 0x3160
movq %rax, 0x20(%r14)
movl %ebx, 0x28(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x4c(%r14)
movups %xmm0, 0x60(%r14)
movq %rbx, 0x70(%r14)
jmp 0x3d61
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3dbf
movl 0x28(%rbx), %r14d
testq %r14, %r14
je 0x3d9a
movq 0x20(%rbx), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x3030
incq %r12
cmpq %r12, %r14
jne 0x3d89
movq 0x20(%rbx), %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_O1/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 0x3dcb
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x58(%rdi)
movq (%rdi), %r14
movl 0x28(%rdi), %r12d
movq 0x8(%r14), %r15
je 0x3e46
cmpl $0x4, %r12d
ja 0x3e21
movq 0x8(%rbx), %r13
cmpq %r13, %r15
je 0x3e21
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3e04
callq 0x3030
movq 0x20(%rbx), %rax
leaq 0x1(%r12), %rcx
movl %ecx, 0x28(%rbx)
movq %r15, (%rax,%r12,8)
movq 0x8(%r15), %r15
movq %rcx, %r12
cmpq $0x5, %rcx
jne 0x3df2
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x3e8a
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3e37
callq 0x3030
movq 0x8(%r15), %r15
movq 0x10(%r15), %rdi
callq 0x3030
jmp 0x3e25
cmpl $0x4, %r12d
ja 0x3e72
movq 0x8(%rbx), %rax
cmpq %rax, %r15
je 0x3e72
movq 0x20(%rbx), %rcx
leaq 0x1(%r12), %rdx
movl %edx, 0x28(%rbx)
movq %r15, (%rcx,%r12,8)
movq 0x8(%r15), %r15
movq %rdx, %r12
cmpq $0x5, %rdx
jne 0x3e50
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x3e8a
movq 0x8(%r15), %r15
movq 0x10(%r15), %rdi
callq 0x3030
jmp 0x3e76
movq %r12, 0x8(%r14)
movq %r14, 0x10(%r12)
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_O1/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 0x3ef6
testq %rsi, %rsi
sete %cl
testl %edx, %edx
setne %r8b
testb %r8b, %cl
jne 0x3ef6
movq %rsi, 0x50(%rdi)
movl %edx, 0x58(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4161
movl %esi, %edx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
cmpl %esi, %eax
jbe 0x4161
leal 0x1(%rdx), %ecx
cvtsi2ss %ecx, %xmm0
movl %eax, %esi
cvtsi2ss %rsi, %xmm1
divss %xmm1, %xmm0
movss 0x2ca2(%rip), %xmm1     # 0x6ddc
ucomiss %xmm0, %xmm1
jae 0x416f
movss 0x2c99(%rip), %xmm1     # 0x6de0
ucomiss %xmm0, %xmm1
jbe 0x4195
decl %eax
shrl %eax
incl %eax
movq %rbx, %rsi
movq 0x10(%rsi), %rsi
decl %eax
cmpl %edx, %eax
jg 0x4155
jmp 0x417e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rsi
testl %edx, %edx
js 0x417e
movq 0x8(%rsi), %rsi
decl %ecx
jne 0x4176
movq (%rsi), %r14
movq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x42dc
decl 0x18(%rbx)
jmp 0x4164
movss 0x2c47(%rip), %xmm1     # 0x6de4
ucomiss %xmm0, %xmm1
jae 0x41b2
movq 0x8(%rbx), %rsi
cmpl %edx, %eax
jle 0x417e
decl %eax
movq 0x10(%rsi), %rsi
jmp 0x41a6
decl %eax
shrl %eax
movq 0x10(%rbx), %rsi
movl %edx, %ecx
subl %eax, %ecx
jle 0x417e
movq 0x8(%rsi), %rsi
decl %ecx
jne 0x41c0
jmp 0x417e
// File: /workspace/github_c_makefile_star2_O1/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 0x41d6
movl 0x18(%rdi), %eax
cmpl %esi, %eax
jge 0x41e4
xorl %edi, %edi
testq %rdi, %rdi
je 0x41e1
movq (%rdi), %rax
retq
xorl %eax, %eax
retq
leal 0x1(%rsi), %ecx
cvtsi2ss %ecx, %xmm0
movl %eax, %edx
cvtsi2ss %rdx, %xmm1
divss %xmm1, %xmm0
movss 0x2bde(%rip), %xmm1     # 0x6ddc
ucomiss %xmm0, %xmm1
jae 0x4222
movss 0x2bd5(%rip), %xmm1     # 0x6de0
ucomiss %xmm0, %xmm1
jbe 0x4233
decl %eax
shrl %eax
incl %eax
movq 0x10(%rdi), %rdi
decl %eax
cmpl %esi, %eax
jg 0x4216
jmp 0x41d8
movq (%rdi), %rdi
testl %esi, %esi
js 0x41d8
movq 0x8(%rdi), %rdi
decl %ecx
jne 0x4229
jmp 0x41d8
movss 0x2ba9(%rip), %xmm1     # 0x6de4
ucomiss %xmm0, %xmm1
jae 0x4250
movq 0x8(%rdi), %rdi
cmpl %esi, %eax
jle 0x41d8
decl %eax
movq 0x10(%rdi), %rdi
jmp 0x4244
decl %eax
shrl %eax
movq 0x10(%rdi), %rdi
subl %eax, %esi
jle 0x41d8
movq 0x8(%rdi), %rdi
decl %esi
jne 0x4260
jmp 0x41d8
// File: /workspace/github_c_makefile_star2_O1/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 0x42c5
cmpl $0x0, 0x18(%rdi)
je 0x42c5
movq (%rdi), %rax
movq 0x8(%rdi), %r12
movq 0x8(%rax), %rax
movq (%rax), %r14
movq 0x8(%rax), %r13
cmpq %r12, %r13
je 0x42c8
movl %esi, %ebx
movq (%r13), %rsi
movq %r14, %rdi
callq *%r15
imull %ebx, %eax
testl %eax, %eax
jle 0x42ba
movq (%r13), %r14
movq 0x8(%r13), %r13
cmpq %r12, %r13
jne 0x42a5
jmp 0x42c8
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4364
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %eax
testb $0x1, %al
jne 0x4302
shrl %eax
cmpl %edx, %eax
jbe 0x4323
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
jmp 0x431f
cmpl $0x1, %eax
jne 0x4311
movq $0x0, 0x10(%r14)
jmp 0x4323
shrl %eax
cmpl %edx, %eax
ja 0x4323
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 0x8(%rbx), %rax
movq %rcx, 0x10(%rax)
cmpl $0x0, 0x58(%r14)
je 0x434b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x434b
callq 0x3030
movl 0x28(%r14), %eax
cmpq $0x4, %rax
ja 0x436c
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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %r13
movq (%rdi), %rax
movq 0x8(%rdi), %r12
movq 0x8(%rax), %r15
testq %r13, %r13
je 0x43e4
cmpq %r12, %r15
je 0x43fd
xorl %ebp, %ebp
movq (%r15), %rsi
movq %r14, %rdi
callq *%r13
testl %eax, %eax
je 0x43ff
incl %ebp
movq 0x8(%r15), %r15
cmpq %r12, %r15
jne 0x43ca
jmp 0x43ff
cmpq %r12, %r15
je 0x43fd
xorl %ebp, %ebp
cmpq %r14, (%r15)
je 0x43ff
incl %ebp
movq 0x8(%r15), %r15
cmpq %r12, %r15
jne 0x43eb
jmp 0x43ff
xorl %ebp, %ebp
cmpq 0x8(%rbx), %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x44a8
movl %esi, %edx
movq %rdi, %r14
movl 0x18(%rdi), %eax
cmpl %esi, %eax
jbe 0x44a8
cmpl $-0x1, %edx
setl %cl
cmpl %edx, %eax
setl %sil
xorl %ebx, %ebx
orb %cl, %sil
je 0x444c
xorl %esi, %esi
jmp 0x449c
leal 0x1(%rdx), %ecx
cvtsi2ss %ecx, %xmm0
movl %eax, %esi
cvtsi2ss %rsi, %xmm1
divss %xmm1, %xmm0
movss 0x2976(%rip), %xmm1     # 0x6ddc
ucomiss %xmm0, %xmm1
jae 0x448d
movss 0x296d(%rip), %xmm1     # 0x6de0
ucomiss %xmm0, %xmm1
jbe 0x44b2
decl %eax
shrl %eax
incl %eax
movq %r14, %rsi
movq 0x10(%rsi), %rsi
decl %eax
cmpl %edx, %eax
jg 0x4481
jmp 0x449c
movq (%r14), %rsi
testl %edx, %edx
js 0x449c
movq 0x8(%rsi), %rsi
decl %ecx
jne 0x4494
movq %r14, %rdi
callq 0x42dc
decl 0x18(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movss 0x292a(%rip), %xmm1     # 0x6de4
ucomiss %xmm0, %xmm1
jae 0x44cf
movq 0x8(%r14), %rsi
cmpl %edx, %eax
jle 0x449c
decl %eax
movq 0x10(%rsi), %rsi
jmp 0x44c3
decl %eax
shrl %eax
movq 0x10(%r14), %rsi
movl %edx, %ecx
subl %eax, %ecx
jle 0x449c
movq 0x8(%rsi), %rsi
decl %ecx
jne 0x44dd
jmp 0x449c
// File: /workspace/github_c_makefile_star2_O1/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 0x4704
movq %rsi, %r14
movq (%rdi), %r12
movq 0x8(%rdi), %r13
xorl %ebx, %ebx
movq 0x8(%r12), %r12
cmpq %r13, %r12
je 0x4706
movq (%r12), %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
je 0x46e6
movq (%r12), %rbx
jmp 0x4706
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x488a
movl %ebx, %eax
popq %rbx
retq
cmpq $0x0, 0x40(%rdi)
je 0x4886
movl 0x18(%rdi), %r8d
xorl %ebx, %ebx
cmpl $0x2, %r8d
jb 0x4886
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x8(%rax), %rcx
decl %r8d
movq 0x10(%rdx), %r9
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x48ba
jmp 0x4886
// File: /workspace/github_c_makefile_star2_O1/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 0x4b72
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_O1/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 0x4ba4
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_O1/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 0x4c29
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 0x4c30
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 0x4c06
jmp 0x4c32
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4c36
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_O1/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 0x4e04
movl %eax, %ebp
movl %eax, %edi
movq %rbx, %rsi
callq 0x4c45
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x4e09
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x559f
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x4e10
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x55a4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x55e1
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x5178
movl %eax, %ebx
movl %ebp, %edi
callq 0x30d0
movl %ebx, %eax
jmp 0x55e6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x39d2
cmpq $0x1, %rax
jne 0x5792
cmpb $0x1, 0x4b5f(%rip)      # 0xa2e8
jne 0x5792
xorl %edi, %edi
callq 0x39da
xorl %eax, %eax
callq 0x39d2
cmpq $0x1, %rax
jne 0x57b4
cmpb $0x1, 0x4b43(%rip)      # 0xa2e9
jne 0x57b4
movl $0x1, %esi
xorl %edi, %edi
callq 0x3a31
xorl %eax, %eax
callq 0x39d2
cmpq $0x1, %rax
jne 0x581d
xorl %edi, %edi
callq 0x39fb
cmpq $0x1, %rax
jne 0x581d
cmpb $0x1, 0x4b15(%rip)      # 0xa2ea
jne 0x581d
movb $0x0, 0xf(%rsp)
movl $0x2, %edi
callq 0x39fb
movq %rax, %rbx
movl $0x1, %edi
callq 0x39fb
testl %ebx, %ebx
jle 0x581d
movq %rax, %r14
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b40
incq %r14
decq %rbx
jne 0x5805
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9ee2
leal -0x10(%rdi), %eax
cmpl $0xf0, %eax
jae 0x9ed4
leaq 0x4d57(%rip), %rcx      # 0xec29
jmp 0x9ee2
movslq %edi, %rax
leaq 0x8b52(%rip), %rcx      # 0x12a30
movq (%rcx,%rax,8), %rcx
movq 0xddcf(%rip), %rdi      # 0x17cb8
movq 0xde40(%rip), %rsi      # 0x17d30
movq 0xddc9(%rip), %rdx      # 0x17cc0
jmp 0x54e0
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_16/longest_line.c
// Function: main
int main(void)
{
  int len;
  char line[MAXLINE];

  int maxlen;
  char maxline[MAXLINE];

  maxlen = 0;
  while ((len = get_line(line, MAXLINE)) > 0)
  {
    if (maxlen < len)
    {
      maxlen = len;
      copy(line, maxline);
    }

    printf("line_length: %d\n", len);
  }

  if (maxlen > 0)
  {
    printf("%s", maxline);
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x7e0, %rsp            # imm = 0x7E0
movq %rsp, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11d2
testl %eax, %eax
jle 0x11c4
leaq 0xe95(%rip), %rbx       # 0x2004
movq %rsp, %r14
xorl %ebp, %ebp
cmpl %eax, %ebp
jge 0x118d
xorl %ecx, %ecx
movb (%rsp,%rcx), %dl
movb %dl, 0x3f0(%rsp,%rcx)
incq %rcx
testb %dl, %dl
jne 0x117a
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movq %r14, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11d2
testl %eax, %eax
jg 0x1174
testl %ebp, %ebp
jle 0x11c4
leaq 0xe60(%rip), %rdi       # 0x2015
leaq 0x3f0(%rsp), %rsi
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbx
popq %r14
popq %rbp
retq