LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_connect
bool cli_connect(struct dubbo_client *cli)
{
    int fd = socket_create();
    if (fd < 0)
    {
        return false;
    }
    cli->fd = fd;

    int status = socket_connect(fd, &cli->addr, sizeof(cli->addr.s));
    if (status == 0)
    {
        if (!cli_connected(cli))
        {
            goto close;
        }
    }
    else
    {
        if (errno == EINPROGRESS)
        {
            // 这里 貌似应该 read + write
            if (AE_ERR == aeCreateFileEvent(cli->el, fd, AE_WRITABLE, cli_on_connect, cli))
            {
                goto close;
            }
            cli->timerid = aeCreateTimeEvent(cli->el, cli->timeout_ms, cli_connect_timeout, cli, NULL);
            if (AE_ERR == cli->timerid)
            {
                cli->timerid = AE_NOMORE;
                goto close;
            }
        }
        else
        {
            goto close;
        }
    }
    return true;

close:
    close(fd);
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, %al
callq 0xa100
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xcb55
movb $0x0, -0x1(%rbp)
jmp 0xcc30
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl $0x10, %edx
callq 0xa3e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xcb94
movq -0x10(%rbp), %rdi
callq 0xcc40
testb $0x1, %al
jne 0xcb8f
jmp 0xcc24
jmp 0xcc1e
callq 0x2050
cmpl $0x73, (%rax)
jne 0xcc1a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %r8
movl $0x2, %edx
leaq 0xf8(%rip), %rcx        # 0xccb0
callq 0x2920
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0xcbca
jmp 0xcc24
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rcx
leaq -0x194(%rip), %rdx      # 0xca50
xorl %eax, %eax
movl %eax, %r8d
callq 0x2cc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq $-0x1, %rax
cmpq 0x38(%rcx), %rax
jne 0xcc18
movq -0x10(%rbp), %rax
movq $-0x1, 0x38(%rax)
jmp 0xcc24
jmp 0xcc1c
jmp 0xcc24
jmp 0xcc1e
movb $0x1, -0x1(%rbp)
jmp 0xcc30
movl -0x14(%rbp), %edi
callq 0x21a0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_connected
static bool cli_connected(struct dubbo_client *cli)
{
    cli->connected = true;
    cli_clear_timer(cli);
    if (AE_ERR == aeCreateFileEvent(cli->el, cli->fd, AE_READABLE, cli_on_read, cli))
    {
        return false;
    }
    cli_pipe_send(cli);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x6c(%rax)
movq -0x10(%rbp), %rdi
callq 0xd5b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x68(%rax), %esi
movq -0x10(%rbp), %r8
movl $0x1, %edx
leaq 0x975(%rip), %rcx       # 0xd5f0
callq 0x2920
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0xcc91
movb $0x0, -0x1(%rbp)
jmp 0xcc9e
movq -0x10(%rbp), %rdi
callq 0xd860
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_on_connect
static void cli_on_connect(struct aeEventLoop *el, int fd, void *ud, int mask)
{
    struct dubbo_client *cli = (struct dubbo_client *)ud;
    // 注意: ae 将 err 与 hup 转换成 write 事件
    if ((mask & AE_WRITABLE) /* && !(mask & AE_READABLE)*/)
    {
        aeDeleteFileEvent(el, fd, AE_WRITABLE /* | AE_READABLE*/);
        // 所以, 可能出错 !!!
        cli_connected(cli);
    }
    else
    {
        LOG_ERROR("连接失败: %s", strerror(errno));
        cli_reconnect(cli);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xccf5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0x2ae0
movq -0x28(%rbp), %rdi
callq 0xcc40
jmp 0xcd41
movq 0x82fc(%rip), %rax      # 0x14ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23b0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x3cff(%rip), %rsi      # 0x10a1c
leaq 0x3d32(%rip), %rcx      # 0x10a56
leaq 0x37af(%rip), %r8       # 0x104da
movl $0x172, %r9d            # imm = 0x172
movb $0x0, %al
callq 0x2220
movq -0x28(%rbp), %rdi
callq 0xcab0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_end
static void cli_end(struct dubbo_client *cli)
{
    if (cli->run)
    {
        cli_close(cli);
        cli_clear_timer(cli);

        gettimeofday(&cli->end, NULL);
        g_cli = NULL;
        cli->run = false;
        aeStop(cli->el);

        double elapsed_sec = ((double)cli->end.tv_sec + 1.0e-6 * cli->end.tv_usec) -
                             ((double)cli->start.tv_sec + 1.0e-6 * cli->start.tv_usec);
        int reqs = cli->req_n - cli->req_left;
        double qps = elapsed_sec < 0.001 ? 0 : reqs / elapsed_sec;
        fprintf(stderr, "\x1B[1;32m[SUMMARY]\x1B[0m COST %.2fs, REQ %d, SUCC %d, FAIL %d, QPS %.f\n", elapsed_sec, reqs, cli->ok_n, cli->ko_n, qps);

        cli_release(cli);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x6d(%rax)
je 0xceb6
movq -0x8(%rbp), %rdi
callq 0xde50
movq -0x8(%rbp), %rdi
callq 0xd5b0
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2160
movq $0x0, 0x84b5(%rip) # 0x15280
movq -0x8(%rbp), %rax
movb $0x0, 0x6d(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2900
movq -0x8(%rbp), %rax
cvtsi2sdq 0x80(%rax), %xmm1
movq -0x8(%rbp), %rax
cvtsi2sdq 0x88(%rax), %xmm0
movsd 0x3687(%rip), %xmm2     # 0x10488
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdq 0x70(%rax), %xmm2
movq -0x8(%rbp), %rax
cvtsi2sdq 0x78(%rax), %xmm1
movsd 0x3663(%rip), %xmm3     # 0x10488
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x5c(%rcx), %eax
movl %eax, -0x14(%rbp)
movsd 0x3631(%rip), %xmm0     # 0x10480
ucomisd -0x10(%rbp), %xmm0
jbe 0xce60
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xce6f
cvtsi2sdl -0x14(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x8178(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movsd -0x10(%rbp), %xmm0
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x64(%rax), %r8d
movsd -0x20(%rbp), %xmm1
leaq 0x3ab6(%rip), %rsi      # 0x1095c
movb $0x2, %al
callq 0x2220
movq -0x8(%rbp), %rdi
callq 0xde90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: dubbo_bench_async
bool dubbo_bench_async(struct dubbo_args *args, struct dubbo_async_args *async_args)
{
    struct dubbo_client *cli = cli_create(args, async_args);
    if (cli == NULL)
    {
        return false;
    }
    return cli_start(cli);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcf50
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcf2e
movb $0x0, -0x1(%rbp)
jmp 0xcf3c
movq -0x20(%rbp), %rdi
callq 0xd130
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_start
static bool cli_start(struct dubbo_client *cli)
{
    if (cli->run)
    {
        return false;
    }

    atexit(exit_handler);
    signal(SIGINT, sig_handler);
    signal(SIGTERM, sig_handler);
    gettimeofday(&cli->start, NULL);

    g_cli = cli;
    cli->run = true;

    return cli_connect(cli);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x6d(%rax)
je 0xd14c
movb $0x0, -0x1(%rbp)
jmp 0xd1ac
leaq -0x403(%rip), %rdi      # 0xcd50
callq 0xe480
movl $0x2, %edi
leaq -0x2a4(%rip), %rsi      # 0xcec0
callq 0x2210
movl $0xf, %edi
leaq -0x2b5(%rip), %rsi      # 0xcec0
callq 0x2210
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2160
movq -0x10(%rbp), %rax
movq %rax, 0x80ea(%rip)      # 0x15280
movq -0x10(%rbp), %rax
movb $0x1, 0x6d(%rax)
movq -0x10(%rbp), %rdi
callq 0xcb30
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_send_req
static void cli_send_req(struct dubbo_client *cli)
{
    struct buffer *buf = cli_encode_req(cli);
    if (buf == NULL)
    {
        PANIC("Dubbo 请求失败: 编码失败");
        return;
    }

    buf_append(cli->snd_buf, buf_peek(buf), buf_readable(buf));
    buf_release(buf);
    if (!cli_write(cli))
    {
        cli_reconnect(cli);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdb90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xdb36
movq 0x74f1(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x2d04(%rip), %rsi      # 0x10815
leaq 0x2d47(%rip), %rdx      # 0x1085f
leaq 0x29bb(%rip), %rcx      # 0x104da
movl $0x151, %r8d            # imm = 0x151
movb $0x0, %al
callq 0x2220
movl $0x1, %edi
callq 0x2360
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8330
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x8aa0
movq -0x10(%rbp), %rdi
callq 0x8270
movq -0x8(%rbp), %rdi
callq 0xdc30
testb $0x1, %al
jne 0xdb87
movq -0x8(%rbp), %rdi
callq 0xcab0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_encode_req
static struct buffer *cli_encode_req(struct dubbo_client *cli)
{
    struct dubbo_req *req = dubbo_req_create(cli->args->service, cli->args->method, cli->args->args, cli->args->attach);
    if (req == NULL)
    {
        return false;
    }
    if (cli->verbos)
    {
        printf("<req>[seq=%" PRId64 "]\n", dubbo_req_getid(req));
    }
    return dubbo_encode(req);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rcx
callq 0xbb30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdbe6
movq $0x0, -0x8(%rbp)
jmp 0xdc17
movq -0x10(%rbp), %rax
testb $0x1, 0x6e(%rax)
je 0xdc0a
movq -0x18(%rbp), %rdi
callq 0xbe50
movq %rax, %rsi
leaq 0x2c69(%rip), %rdi      # 0x1086c
movb $0x0, %al
callq 0x2120
movq -0x18(%rbp), %rdi
callq 0xbe70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_on_write
static void cli_on_write(struct aeEventLoop *el, int fd, void *ud, int mask)
{
    UNUSED(el);
    UNUSED(fd);
    UNUSED(mask);

    struct dubbo_client *cli = (struct dubbo_client *)ud;
    assert(cli->connected);

    if (!cli_write(cli))
    {
        cli_reconnect(cli);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x6c(%rax)
je 0xde0a
jmp 0xde29
leaq 0x2798(%rip), %rdi      # 0x105a9
leaq 0x26c2(%rip), %rsi      # 0x104da
movl $0x17e, %edx            # imm = 0x17E
leaq 0x2afe(%rip), %rcx      # 0x10922
callq 0x2170
movq -0x28(%rbp), %rdi
callq 0xdc30
testb $0x1, %al
jne 0xde3f
movq -0x28(%rbp), %rdi
callq 0xcab0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_reset
static void cli_reset(struct dubbo_client *cli)
{
    cli->connected = false;
    cli_clear_timer(cli);
    cli->fd = -1;
    cli->pipe_left = cli->pipe_n;
    buf_retrieveAll(cli->rcv_buf);
    buf_retrieveAll(cli->snd_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x6c(%rax)
movq -0x8(%rbp), %rdi
callq 0xd5b0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x8780
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x8780
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/dubbo.c
// Function: trim_opt
static char *trim_opt(char *opt)
{
    char *end;
    if (opt == 0)
    {
        return 0;
    }

    while (isspace((int)*opt) || *opt == '=')
        opt++;

    if (*opt == 0)
    {
        return opt;
    }

    end = opt + strlen(opt) - 1;
    while (end > opt && isspace((int)*end))
        end--;

    *(end + 1) = 0;

    return opt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe370
movq $0x0, -0x8(%rbp)
jmp 0xe452
jmp 0xe372
callq 0x23c0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0xe3a8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xe3b1
jmp 0xe3bf
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe372
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xe3d5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe452
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x29(%rbp)
jbe 0xe42b
callq 0x23c0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xe434
jmp 0xe442
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xe3f8
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sample.c
// Function: tick_init
void
tick_init()
{
	time_t t0;
	time_t t1;

	DBUG_ENTER("tick_init");
	time(&t0);
	do {				/* synchronize timer at boundry */
		time(&t1);
	} while (t0 == t1);
	DBUG_PRINT("", ("t0=%d t1=%d", t0, t1));
	time_base = t0;
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x106a5(%rip), %rax     # 0x13194
movq %rax, -0x38(%rbp)
leaq 0x15816(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x15, -0x2c(%rbp)
leaq 0x1254b(%rip), %rax     # 0x15060
movq %rax, -0x28(%rbp)
leaq 0x15658(%rip), %rax     # 0x18178
movq %rax, -0x20(%rbp)
leaq 0x157e5(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11e00
leaq -0x8(%rbp), %rdi
callq 0x2180
leaq -0x10(%rbp), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x2b48
jmp 0x2b5d
leaq 0x15d5c(%rip), %rax     # 0x188c0
cmpl $0x0, (%rax)
je 0x2bbe
leaq 0x157a0(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x124e2(%rip), %rcx     # 0x15060
movq %rcx, 0x10(%rax)
leaq 0x124d7(%rip), %rdi     # 0x15060
callq 0x11210
cmpl $0x0, %eax
je 0x2bbe
leaq 0x15776(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x1a, 0xc(%rax)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x105e7(%rip), %rdi     # 0x1319e
movb $0x0, %al
callq 0x11eb0
jmp 0x2bc0
movq -0x8(%rbp), %rax
movq %rax, 0x157a5(%rip)     # 0x18370
movl $0x1c, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11fd0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sample.c
// Function: print_text
BEH_DECL(print_text)
{
	CONS* text;

	DBUG_ENTER("print_text");
	text = map_get(WHAT, ATOM("text"));
	printf("%s", (atomp(text) ? atom_str(text) : cons_to_str(text)));
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x10511(%rip), %rax     # 0x131b4
movq %rax, -0x38(%rbp)
leaq 0x15662(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x2d, -0x2c(%rbp)
leaq 0x12397(%rip), %rax     # 0x15060
movq %rax, -0x28(%rbp)
leaq 0x154a4(%rip), %rax     # 0x18178
movq %rax, -0x20(%rbp)
leaq 0x15631(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11e00
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xee80
movq %rax, -0x40(%rbp)
leaq 0x104af(%rip), %rdi     # 0x131ba
callq 0xb050
movq -0x40(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x2, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2d4f
movq -0x10(%rbp), %rdi
callq 0xb110
movq %rax, -0x48(%rbp)
jmp 0x2d5c
movq -0x10(%rbp), %rdi
callq 0x6bc0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq 0x10f32(%rip), %rdi     # 0x13c99
movb $0x0, %al
callq 0x20e0
movl $0x30, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11fd0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sample.c
// Function: print_line
BEH_DECL(print_line)
{
	CONS* text;

	DBUG_ENTER("print_line");
	text = map_get(WHAT, ATOM("text"));
	printf("%s", (atomp(text) ? atom_str(text) : cons_to_str(text)));
	putchar('\n');
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1041c(%rip), %rax     # 0x131bf
movq %rax, -0x38(%rbp)
leaq 0x15562(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x37, -0x2c(%rbp)
leaq 0x12297(%rip), %rax     # 0x15060
movq %rax, -0x28(%rbp)
leaq 0x153a4(%rip), %rax     # 0x18178
movq %rax, -0x20(%rbp)
leaq 0x15531(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11e00
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xee80
movq %rax, -0x40(%rbp)
leaq 0x103af(%rip), %rdi     # 0x131ba
callq 0xb050
movq -0x40(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x2, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2e4f
movq -0x10(%rbp), %rdi
callq 0xb110
movq %rax, -0x48(%rbp)
jmp 0x2e5c
movq -0x10(%rbp), %rdi
callq 0x6bc0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq 0x10e32(%rip), %rdi     # 0x13c99
movb $0x0, %al
callq 0x20e0
movl $0xa, %edi
callq 0x2040
movl $0x3b, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11fd0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sample.c
// Function: start_ticker
void
start_ticker(CONFIG* cfg, int count)
{
	CONS* actor;
	CONS* state;
	CONS* msg;
	
	DBUG_ENTER("start_ticker");
	DBUG_PRINT("", ("count=%d", count));
	state = map_put(NIL, ATOM("count"), NUMBER(count));
	actor = CFG_ACTOR(cfg, each_second, state);
	
	state = map_put(NIL, ATOM("sec"), actor);
	msg = map_put(NIL, ATOM("time"), tick_time());
	CFG_SEND(cfg, CFG_ACTOR(cfg, time_ticker, state), msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xf8c8(%rip), %rax      # 0x132ae
movq %rax, -0x50(%rbp)
leaq 0x1491f(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x8a, -0x44(%rbp)
leaq 0x11654(%rip), %rax     # 0x15060
movq %rax, -0x40(%rbp)
leaq 0x14761(%rip), %rax     # 0x18178
movq %rax, -0x38(%rbp)
leaq 0x148ee(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x11e00
leaq 0x14e83(%rip), %rax     # 0x188c0
cmpl $0x0, (%rax)
je 0x3a92
leaq 0x148c7(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x11609(%rip), %rcx     # 0x15060
movq %rcx, 0x10(%rax)
leaq 0x115fe(%rip), %rdi     # 0x15060
callq 0x11210
cmpl $0x0, %eax
je 0x3a92
leaq 0x1489d(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x8b, 0xc(%rax)
movl -0xc(%rbp), %esi
leaq 0xfc9a(%rip), %rdi      # 0x13725
movb $0x0, %al
callq 0x11eb0
jmp 0x3a94
leaq 0xfc9f(%rip), %rdi      # 0x1373a
callq 0xb050
movq %rax, %rsi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
orq $0x3, %rdx
leaq 0x147ca(%rip), %rdi     # 0x18280
callq 0xf790
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0xc3e(%rip), %rsi      # 0x2e90
callq 0x5060
movq %rax, -0x18(%rbp)
leaq 0xf713(%rip), %rdi      # 0x131f1
callq 0xb050
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq 0x1478f(%rip), %rdi     # 0x18280
callq 0xf790
movq %rax, -0x20(%rbp)
leaq 0xf6ae(%rip), %rdi      # 0x131af
callq 0xb050
movq %rax, -0x60(%rbp)
callq 0x2bf0
movq -0x60(%rbp), %rsi
movq %rax, %rdx
leaq 0x14763(%rip), %rdi     # 0x18280
callq 0xf790
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x8cd(%rip), %rsi      # 0x3270
callq 0x5060
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
callq 0x5180
movl $0x92, -0x44(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x11fd0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sample.c
// Function: say_hello
BEH_DECL(say_hello)
{
	CONS* name = map_get(WHAT, ATOM("name"));
	CONS* printer = ACTOR(print_text, NIL);
	CONS* a_text = ATOM("text");

	DBUG_ENTER("say_hello");
	SEND(printer, map_put(NIL, a_text, ATOM("Hello, ")));
	SEND(printer, MINE);
	SEND(printer, map_put(NIL, a_text, ATOM(" from ")));
	SEND(ACTOR(print_line, NIL), map_put(NIL, a_text, name));
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xee80
movq %rax, -0xa0(%rbp)
leaq 0xf721(%rip), %rdi      # 0x132bb
callq 0xb050
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf6a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xf31(%rip), %rsi      # 0x2c90
leaq 0x146b8(%rip), %rdx     # 0x18280
callq 0x5060
movq %rax, -0x18(%rbp)
leaq 0xf5e2(%rip), %rdi      # 0x131ba
callq 0xb050
movq %rax, -0x20(%rbp)
leaq 0xf6d8(%rip), %rax      # 0x132c0
movq %rax, -0x48(%rbp)
leaq 0x1471d(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x9b, -0x3c(%rbp)
leaq 0x11452(%rip), %rax     # 0x15060
movq %rax, -0x38(%rbp)
leaq 0x1455f(%rip), %rax     # 0x18178
movq %rax, -0x30(%rbp)
leaq 0x146ec(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11e00
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq 0xf66a(%rip), %rdi      # 0x132ca
callq 0xb050
movq -0x98(%rbp), %rsi
movq %rax, %rdx
leaq 0x1460a(%rip), %rdi     # 0x18280
callq 0xf790
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
callq 0x5180
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xecf0
movq %rax, %rdi
callq 0x3f70
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, %rdx
callq 0x5180
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0xf5ed(%rip), %rdi      # 0x132d2
callq 0xb050
movq -0x70(%rbp), %rsi
movq %rax, %rdx
leaq 0x14588(%rip), %rdi     # 0x18280
callq 0xf790
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x5180
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xf90(%rip), %rsi      # 0x2d90
leaq 0x14559(%rip), %rdx     # 0x18280
callq 0x5060
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x14541(%rip), %rdi     # 0x18280
callq 0xf790
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x5180
movl $0xa0, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11fd0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sample.c
// Function: test_sample
void
test_sample(CONFIG* cfg)
{
	CONS* actor;
	CONS* state;
	CONS* msg;

	DBUG_ENTER("test_sample");
	TRACE(printf("--test_sample--\n"));
	state = map_put(NIL, ATOM("text"), ATOM("Actor"));
	actor = CFG_ACTOR(cfg, say_hello, state);
	
	msg = map_put(NIL, ATOM("name"), ATOM("World!"));
	CFG_SEND(cfg, actor, msg);
	
	msg = NIL;
	msg = map_put(msg, ATOM("name"), NUMBER(42));
	msg = map_put(msg, ATOM("addr"), actor);
	CFG_SEND(cfg, actor, msg);
	
	report_configuration(cfg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf556(%rip), %rax      # 0x132d9
movq %rax, -0x48(%rbp)
leaq 0x14582(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0xaa, -0x3c(%rbp)
leaq 0x112b7(%rip), %rax     # 0x15060
movq %rax, -0x38(%rbp)
leaq 0x143c4(%rip), %rax     # 0x18178
movq %rax, -0x30(%rbp)
leaq 0x14551(%rip), %rax     # 0x18310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11e00
leaq 0xf50b(%rip), %rdi      # 0x132e5
movb $0x0, %al
callq 0x20e0
leaq 0xf3d2(%rip), %rdi      # 0x131ba
callq 0xb050
movq %rax, -0x68(%rbp)
leaq 0xf4fe(%rip), %rdi      # 0x132f6
callq 0xb050
movq -0x68(%rbp), %rsi
movq %rax, %rdx
leaq 0x14475(%rip), %rdi     # 0x18280
callq 0xf790
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x2b3(%rip), %rsi      # 0x3b70
callq 0x5060
movq %rax, -0x10(%rbp)
leaq 0xf488(%rip), %rdi      # 0x132bb
callq 0xb050
movq %rax, -0x60(%rbp)
leaq 0xf4b9(%rip), %rdi      # 0x132fc
callq 0xb050
movq -0x60(%rbp), %rsi
movq %rax, %rdx
leaq 0x1442a(%rip), %rdi     # 0x18280
callq 0xf790
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5180
leaq 0x14409(%rip), %rax     # 0x18280
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0xf431(%rip), %rdi      # 0x132bb
callq 0xb050
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl $0xab, %edx
callq 0xf790
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xf450(%rip), %rdi      # 0x13303
callq 0xb050
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0xf790
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5180
movq -0x8(%rbp), %rdi
callq 0x64a0
movl $0xb8, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x11fd0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/7-Threading/pthread_hello_world.c
// Function: hello
void * hello(void *input)
{
	int i;

	for(i = 0; i < 100000000; i++)
	{
		if(i == 10000000)
			printf("T:DAM!\n");
		if(i == 50000000)
			printf("T:BAM!\n");
		if(i == 100000000-1)
			printf("T:GAM!\n");
	}

	printf("%s\n", (char *) input);
	pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x5f5e100, -0xc(%rbp)  # imm = 0x5F5E100
jge 0x11de
cmpl $0x989680, -0xc(%rbp)   # imm = 0x989680
jne 0x11a3
leaq 0xe68(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
cmpl $0x2faf080, -0xc(%rbp)  # imm = 0x2FAF080
jne 0x11ba
leaq 0xe59(%rip), %rdi       # 0x200c
movb $0x0, %al
callq 0x1030
cmpl $0x5f5e0ff, -0xc(%rbp)  # imm = 0x5F5E0FF
jne 0x11d1
leaq 0xe4a(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
jmp 0x11d3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1183
movq -0x8(%rbp), %rsi
leaq 0xe33(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
movl %eax, %edi
callq 0x1040
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/7-Threading/pthread_hello_world.c
// Function: main
int main(void)
{
	int i;
	pthread_t tid;
	pthread_create(&tid, NULL, hello, "hello world");

	for(i = 0; i < 100000000; i++)
	{
		if(i == 10000000)
			printf("JAM\n");
		if(i == 50000000) 
			printf("EAM\n");
		if(i == 100000000-1)
			printf("ZAM\n");
	}

	pthread_join(tid, NULL);
	printf("main thread terminated\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xae(%rip), %rdx       # 0x1170
leaq 0xdfb(%rip), %rcx       # 0x2020
callq 0x1050
movl $0x0, -0x8(%rbp)
cmpl $0x5f5e100, -0x8(%rbp)  # imm = 0x5F5E100
jge 0x128c
cmpl $0x989680, -0x8(%rbp)   # imm = 0x989680
jne 0x1251
leaq 0xde2(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x1030
cmpl $0x2faf080, -0x8(%rbp)  # imm = 0x2FAF080
jne 0x1268
leaq 0xdd0(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1030
cmpl $0x5f5e0ff, -0x8(%rbp)  # imm = 0x5F5E0FF
jne 0x127f
leaq 0xdbe(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1030
jmp 0x1281
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1231
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1060
leaq 0xd9b(%rip), %rdi       # 0x203b
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/yes.c
// Function: main
int main(int argc, char **argv){
    if(argc == 1){
        while(1){
            puts("y");
        }
    }
    else {
        while(1){
            for(int i = 1; i < argc; i++){
                printf("%s", argv[i]);
                if(argc - i > 1){
                    putchar(' ');
                }
            }
            putchar('\n');
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x118c
jmp 0x117e
leaq 0xe7f(%rip), %rdi       # 0x2004
callq 0x1040
jmp 0x117e
jmp 0x118e
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11d9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xe56(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1050
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x1, %eax
jle 0x11cc
movl $0x20, %edi
callq 0x1030
jmp 0x11ce
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1195
movl $0xa, %edi
callq 0x1030
jmp 0x118e
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_22/fold_line.c
// Function: main
int main(void)
{
  char line[MAXLINE];
  char fold_str[MAXLINE];

  while ((get_line(line, MAXLINE)) > 0)
  {
    fold_line(line, fold_str, BREAKING_POINT);
    printf("%s", fold_str);
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e30, %rsp           # imm = 0x4E30
movl $0x0, -0x4(%rbp)
leaq -0x2720(%rbp), %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x11c0
cmpl $0x0, %eax
jle 0x11a7
leaq -0x2720(%rbp), %rdi
leaq -0x4e30(%rbp), %rsi
movl $0x28, %edx
callq 0x1260
leaq -0x4e30(%rbp), %rsi
leaq 0xe66(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x1162
xorl %eax, %eax
addq $0x4e30, %rsp           # imm = 0x4E30
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_22/fold_line.c
// Function: get_line
int get_line(char line[], int max_line_len)
{
  int c, i = 0;

  while (i < max_line_len - 1 && (c = getchar()) != EOF && c != '\n')
  {
    line[i++] = c;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jge 0x1206
callq 0x1040
movl %eax, %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x1206
cmpl $0xa, -0x10(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x120f
jmp 0x122b
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x11d6
cmpl $0xa, -0x10(%rbp)
jne 0x124b
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_22/fold_line.c
// Function: fold_line
void fold_line(char line[], char fold_str[], int n_break)
{
  int i, j;
  int column = 0;
  int split = FALSE;
  int last_blank = 0;

  for (i = 0, j = 0; line[i] != '\0'; ++i, ++j)
  {
    fold_str[j] = line[i];

    if (fold_str[j] == '\n')
    {
      column = 0;
    }

    column++;

    if (column == n_break - OFFSET)
    {
      split = TRUE;
    }

    if (split && (fold_str[j] == ' ' || fold_str[j] == '\t'))
    {
      last_blank = j;
    }

    if (column == n_break)
    {
      if (last_blank)
      {
        fold_str[last_blank] = '\n';
        column = j - last_blank;
        last_blank = 0;
      }
      else
      {
        fold_str[j++] = '-';
        fold_str[j] = '\n';

        column = 0;
      }

      split = FALSE;
    }
  }

  fold_str[j] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1395
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x12d5
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0xa, %ecx
cmpl %ecx, %eax
jne 0x12f2
movl $0x1, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1320
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x131a
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x1320
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x137c
cmpl $0x0, -0x28(%rbp)
je 0x134c
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0xa, (%rax,%rcx)
movl -0x1c(%rbp), %eax
subl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
jmp 0x1375
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0xa, (%rax,%rcx)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x137e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1292
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/fifo/fifo_server.c
// Function: set_shutdown
void *set_shutdown ()
{
        printf("[SIGNAL] : Got shutdown signal\n");
        semctl( gnSemID1, IPC_RMID, 0 );
        printf("[SIGNAL] : Semapore segment marked for deletion\n");
        exit (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1006(%rip), %rdi      # 0x3111
movb $0x0, %al
callq 0x1050
movl 0x307c(%rip), %edi      # 0x5194
xorl %edx, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x1130
leaq 0x1007(%rip), %rdi      # 0x3131
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x1160
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_05/strncat.c
// Function: main
int main(void)
{
  char s[100] = "This is the first string";
  char *t = ", this second string!";
  size_t nr_chars = 5;

  strcat_ptr(s, t, nr_chars);

  puts(s);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0xe93(%rip), %rsi       # 0x2010
movl $0x64, %edx
callq 0x1050
leaq 0xee6(%rip), %rax       # 0x2074
movq %rax, -0x78(%rbp)
movq $0x5, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x11c0
leaq -0x70(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_05/strncat.c
// Function: strcat_ptr
void strcat_ptr(char *s, char *t, size_t n)
{
  // Find the end of s
  size_t s_length = strlen(s);

  // Move the s pointer to the end of the s string.
  s += s_length;

  // copy t to the end of s
  while ((*s++ = *t++) != '\0' && n--)
    ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x1235
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x123e
jmp 0x1240
jmp 0x11ed
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/crossover/crossover.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    RRA *h;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 0)
        {
        in = stdin;
        out = stdout;
        }
    else if (argc-argIndex == 1)
        {
        in = OpenFile(argv[argIndex],"r");
        out = stdout;
        }
    else if (argc-argIndex == 2)
        {
        in = OpenFile(argv[argIndex],"r");
        out = OpenFile(argv[argIndex+1],"w");
        }
    else
        {
        printf("usage: fader -n<N> [<input rra file> [<output rra file>]]\n");
        exit(-1);
        }

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

    process(h);

    fclose(in);
    fclose(out);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1460
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x136e
movq 0x6c8a(%rip), %rax      # 0x7fd8
movq (%rax), %rax
movq %rax, 0x6df8(%rip)      # 0x8150
movq 0x6c71(%rip), %rax      # 0x7fd0
movq (%rax), %rax
movq %rax, 0x6def(%rip)      # 0x8158
jmp 0x1417
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x13ab
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3cda(%rip), %rsi      # 0x5066
callq 0x1c80
movq %rax, 0x6db8(%rip)      # 0x8150
movq 0x6c31(%rip), %rax      # 0x7fd0
movq (%rax), %rax
movq %rax, 0x6daf(%rip)      # 0x8158
jmp 0x1415
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x2, %eax
jne 0x13fb
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3c9d(%rip), %rsi      # 0x5066
callq 0x1c80
movq %rax, 0x6d7b(%rip)      # 0x8150
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3c28(%rip), %rsi      # 0x5015
callq 0x1c80
movq %rax, 0x6d5f(%rip)      # 0x8158
jmp 0x1413
leaq 0x3c15(%rip), %rdi      # 0x5017
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11d0
jmp 0x1415
jmp 0x1417
callq 0x2160
movq %rax, -0x20(%rbp)
movq 0x6d29(%rip), %rdi      # 0x8150
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2660
movq -0x20(%rbp), %rdi
callq 0x1610
movq 0x6d0c(%rip), %rdi      # 0x8150
callq 0x1070
movq 0x6d08(%rip), %rdi      # 0x8158
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.9/tifftest.c
// Function: main
int main (int argc, char** argv)
{
	if(!(argc-1)){
		printf("Error al abrir el archivo.");
		return 0;
	}
	TIFF* tiff;
	char dir[70] = "../../src/capitulo_2/2.9/";
  //char dir[70] = "./";

	strcat(dir, argv[1]);
	tiff = TIFFOpen (dir, "r");
	if (tiff) {
		int dircount = 0;
		do {
		    dircount++;
	} while (TIFFReadDirectory(tiff));
		  printf("%d directorios en %s\n", dircount, argv[1]);
      TIFFClose(tiff);
  }

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jne 0x11cb
leaq 0xe4c(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x1253
leaq -0x60(%rbp), %rdi
leaq 0xe6a(%rip), %rsi       # 0x2040
movl $0x46, %edx
callq 0x1080
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1050
leaq -0x60(%rbp), %rdi
leaq 0xe23(%rip), %rsi       # 0x201f
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x124c
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
jne 0x1213
movl -0x64(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xde5(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_EvalSource
int Jim_EvalSource(Jim_Interp *interp, const char *filename, int lineno, const char *script)
{
    int retval;
    Jim_Obj *scriptObjPtr;

    scriptObjPtr = Jim_NewStringObj(interp, script, -1);
    Jim_IncrRefCount(scriptObjPtr);
    if (filename) {
        Jim_SetSourceInfo(interp, scriptObjPtr, Jim_NewStringObj(interp, filename, -1), lineno);
    }
    retval = Jim_EvalObj(interp, scriptObjPtr);
    Jim_DecrRefCount(interp, scriptObjPtr);
    return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x66f6
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movl -0x14(%rbp), %ecx
callq 0xd4a0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9b80
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x6725
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7a10
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_AioFilehandle
int Jim_AioFilehandle(Jim_Interp *interp, Jim_Obj *command)
{
    Jim_Cmd *cmdPtr = Jim_GetCommand(interp, command, JIM_ERRMSG);


    if (cmdPtr && !cmdPtr->isproc && cmdPtr->u.native.cmdProc == JimAioSubCmdProc) {
        return ((AioFile *) cmdPtr->u.native.privData)->fd;
    }
    Jim_SetResultFormatted(interp, "Not a filehandle: \"%#s\"", command);
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x6930
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6908
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x6908
movq -0x20(%rbp), %rax
leaq 0x1fe(%rip), %rcx       # 0x6af0
cmpq %rcx, 0x18(%rax)
jne 0x6908
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6925
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x34205(%rip), %rsi     # 0x3ab1c
movb $0x0, %al
callq 0x6b40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_aioInit
int Jim_aioInit(Jim_Interp *interp)
{
    if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG))
        return JIM_ERR;

#if defined(JIM_SSL)
    Jim_CreateCommand(interp, "load_ssl_certs", JimAioLoadSSLCertsCommand, NULL, NULL);
#endif

    Jim_CreateCommand(interp, "open", JimAioOpenCommand, NULL, NULL);
#ifdef HAVE_SOCKETS
    Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL);
#endif
#ifdef HAVE_PIPE
    Jim_CreateCommand(interp, "pipe", JimAioPipeCommand, NULL, NULL);
#endif


    JimMakeChannel(interp, fileno(stdin), NULL, "stdin", 0, AIO_KEEPOPEN);
    JimMakeChannel(interp, fileno(stdout), NULL, "stdout", 0, AIO_KEEPOPEN);
    JimMakeChannel(interp, fileno(stderr), NULL, "stderr", 0, AIO_KEEPOPEN | AIO_WBUF_NONE);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x33bdd(%rip), %rsi     # 0x3ab34
leaq 0x3098c(%rip), %rdx     # 0x378ea
movl $0x1, %ecx
callq 0x6660
cmpl $0x0, %eax
je 0x6f79
movl $0x1, -0x4(%rbp)
jmp 0x7060
movq -0x10(%rbp), %rdi
leaq 0x3492a(%rip), %rsi     # 0x3b8ae
leaq 0x145(%rip), %rdx       # 0x70d0
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x7070
movq -0x10(%rbp), %rdi
leaq 0x34d73(%rip), %rsi     # 0x3bd16
leaq 0x346(%rip), %rdx       # 0x72f0
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x7070
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x40fc2(%rip), %rax     # 0x47f88
movq (%rax), %rdi
callq 0x6360
movq -0x28(%rbp), %rdi
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x33b59(%rip), %rcx     # 0x3ab38
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x7350
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x40f7c(%rip), %rax     # 0x47f78
movq (%rax), %rdi
callq 0x6360
movq -0x20(%rbp), %rdi
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x33b29(%rip), %rcx     # 0x3ab3e
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x7350
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x40fc6(%rip), %rax     # 0x47ff8
movq (%rax), %rdi
callq 0x6360
movq -0x18(%rbp), %rdi
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x33afa(%rip), %rcx     # 0x3ab45
xorl %r8d, %r8d
movl $0x9, %r9d
callq 0x7350
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)