LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/goghcrow[P]dubbo_ab/dubbo_codec.c
// Function: dubbo_encode
struct buffer *dubbo_encode(const struct dubbo_req *req)
{
    struct buffer *buf = buf_create_ex(DUBBO_BUF_LEN, DUBBO_HDR_LEN);
    if (encode_req(buf, req))
    {
        return buf;
    }
    else
    {
        buf_release(buf);
        return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x2000, %edi           # imm = 0x2000
movl $0x10, %esi
callq 0x6328
movq %rax, %rbx
movq (%r15), %r14
movb 0x8(%r15), %al
shlb $0x6, %al
leal -0x7e(%rax), %ecx
movb 0x9(%r15), %dl
orb $-0x5e, %al
movzbl %al, %eax
movzbl %cl, %r13d
testb %dl, %dl
cmovnel %eax, %r13d
cmpb $0x1, %dl
jne 0x8871
movq 0x38(%r15), %rsi
movq 0x40(%r15), %rdx
movq %rbx, %rdi
callq 0x6829
jmp 0x89ca
movq %rbx, %rdi
callq 0x646a
leaq 0x23b8(%rip), %rdi      # 0xac38
movq %rax, %rsi
callq 0x80b5
cmpl $-0x1, %eax
je 0x8a1e
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6478
movq 0x10(%r15), %r12
movq %rbx, %rdi
callq 0x646a
movq %r12, %rdi
movq %rax, %rsi
callq 0x80b5
cmpl $-0x1, %eax
je 0x8a1e
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6478
movq %rbx, %rdi
callq 0x646a
leaq 0x2370(%rip), %rdi      # 0xac46
movq %rax, %rsi
callq 0x80b5
cmpl $-0x1, %eax
je 0x8a1e
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6478
movq %rbx, %rdi
callq 0x646a
leaq 0x234b(%rip), %rdi      # 0xac4c
movq %rax, %rsi
callq 0x80b5
cmpl $-0x1, %eax
je 0x8a1e
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6478
movq %rbx, %rdi
callq 0x646a
leaq 0x2334(%rip), %rdi      # 0xac60
movq %rax, %rsi
callq 0x80b5
cmpl $-0x1, %eax
je 0x8a1e
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6478
movq 0x20(%r15), %rax
movq (%rax), %r12
movq %rbx, %rdi
callq 0x646a
movq %r12, %rdi
movq %rax, %rsi
callq 0x80b5
cmpl $-0x1, %eax
je 0x8a1e
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6478
movq %rbx, %rdi
callq 0x646a
movq %rax, %rdi
callq 0x7f74
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6478
movq 0x20(%r15), %rax
movq 0x10(%rax), %r15
movq %r15, %rdi
callq 0x20d0
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x831b
movq %rbx, %rdi
callq 0x646a
movq %rax, %rdi
callq 0x7f74
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x6478
movq %rbx, %rdi
callq 0x642f
movq %rax, %r15
movq %rbx, %rdi
callq 0x6454
cmpq $0x10, %rax
jb 0x8a25
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6b25
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6ae5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6ba4
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x6ba4
movq %rbx, %rdi
movl $0xffffdabb, %esi       # imm = 0xFFFFDABB
callq 0x6b63
jmp 0x8a34
callq 0x247e
jmp 0x8a2a
callq 0x24af
movq %rbx, %rdi
callq 0x63bc
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/goghcrow[P]dubbo_ab/dubbo_codec.c
// Function: is_completed_dubbo_pkt
bool is_completed_dubbo_pkt(const struct buffer *buf, int *remaining)
{
    if (!is_dubbo_pkt(buf))
    {
        return false;
    }

    int32_t body_sz = 0;
    memcpy(&body_sz, buf_peek(buf) + DUBBO_HDR_LEN - sizeof(int32_t), sizeof(int32_t));
    body_sz = be32toh(body_sz);
    if (body_sz <= 0 || body_sz > DUBBO_MAX_PKT_SZ)
    {
        LOG_ERROR("invalid dubbo pkt body size %d", body_sz);
        return false;
    }

    if (remaining)
    {
        *remaining = body_sz + DUBBO_HDR_LEN - buf_readable(buf);
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r12
callq 0x8d84
testb %al, %al
je 0x8e06
movq %r12, %rdi
callq 0x645d
movl 0xc(%rax), %r15d
bswapl %r15d
leal -0x1(%r15), %eax
cmpl $0x400000, %eax         # imm = 0x400000
jae 0x8e15
movb $0x1, %r14b
testq %rbx, %rbx
je 0x8e09
movq %r12, %rdi
callq 0x642f
subl %eax, %r15d
addl $0x10, %r15d
movl %r15d, (%rbx)
jmp 0x8e09
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x71dc(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0x1d23(%rip), %rsi      # 0xab49
leaq 0x1d64(%rip), %rcx      # 0xab91
leaq 0x1bcd(%rip), %r8       # 0xaa01
xorl %r14d, %r14d
movl %r15d, %edx
movl $0x1f4, %r9d            # imm = 0x1F4
xorl %eax, %eax
callq 0x21e0
jmp 0x8e09
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x764c
testl %eax, %eax
js 0x8ef6
movl %eax, %ebx
movl %eax, 0x68(%r14)
leaq 0x10(%r14), %rsi
movl %eax, %edi
movl $0x10, %edx
callq 0x7831
testl %eax, %eax
je 0x8edd
callq 0x2050
cmpl $0x73, (%rax)
jne 0x8eec
movq (%r14), %rdi
leaq 0xd8(%rip), %rcx        # 0x8f71
movl %ebx, %esi
movl $0x2, %edx
movq %r14, %r8
callq 0x2fa0
cmpl $-0x1, %eax
je 0x8eec
movq (%r14), %rdi
movq 0x30(%r14), %rsi
leaq -0x6846(%rip), %rdx     # 0x2675
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x3160
movq %rax, 0x38(%r14)
movb $0x1, %r15b
cmpq $-0x1, %rax
jne 0x8ef6
movq $-0x1, 0x38(%r14)
jmp 0x8eec
movq %r14, %rdi
callq 0x8f04
movb $0x1, %r15b
testb %al, %al
jne 0x8ef6
movl %ebx, %edi
callq 0x2160
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x6c(%rdi)
movq 0x38(%rdi), %rsi
cmpq $-0x1, %rsi
je 0x8f2c
movq (%rbx), %rdi
callq 0x3262
movq $-0x1, 0x38(%rbx)
movq (%rbx), %rdi
movl 0x68(%rbx), %esi
leaq 0x583(%rip), %rcx       # 0x94bc
movl $0x1, %edx
movq %rbx, %r8
callq 0x2fa0
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x8f58
jmp 0x8f65
movq %rbx, %rdi
callq 0x9781
subl $0x1, 0x54(%rbx)
jae 0x8f50
movl $0x0, 0x54(%rbx)
cmpl $-0x1, %r14d
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdx, %rbx
testb $0x2, %cl
je 0x8f97
movl $0x2, %edx
callq 0x3076
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8f04
movq %rbx, %rdi
callq 0x2734
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %edi
movl $0x90, %esi
callq 0x21b0
testq %rax, %rax
je 0x9135
movq %rax, %rbx
movq (%r15), %rax
movq %rax, (%rbx)
movb 0x10(%r15), %al
movb %al, 0x6e(%rbx)
movl $0x400, %edi            # imm = 0x400
movl $0x8, %esi
callq 0x6328
movq %rax, 0x40(%rbx)
movl $0x400, %edi            # imm = 0x400
movl $0x8, %esi
callq 0x6328
movq %rax, 0x48(%rbx)
movl 0xc(%r15), %eax
movl %eax, 0x58(%rbx)
movl %eax, 0x5c(%rbx)
movl 0x8(%r15), %ecx
cmpl %eax, %ecx
cmovll %ecx, %eax
movl %eax, 0x50(%rbx)
movl %ecx, 0x54(%rbx)
movb $0x0, 0x6d(%rbx)
movq $0x0, 0x60(%rbx)
imulq $0x3e8, 0x30(%r14), %rax # imm = 0x3E8
movq %rax, 0x30(%rbx)
movq $-0x1, 0x38(%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
callq 0x99c2
movq 0x8(%rbx), %rax
movq (%rax), %rdi
leaq 0x10(%rbx), %rsi
callq 0x7c3e
testb %al, %al
je 0x9154
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x22d0
rolw $0x8, %ax
movw %ax, 0x12(%rbx)
cmpb $0x0, 0x6d(%rbx)
je 0x90dd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x13e(%rip), %rdi      # 0x8fa6
callq 0x9d30
leaq -0x119(%rip), %r14      # 0x8fd7
movl $0x2, %edi
movq %r14, %rsi
callq 0x21d0
movl $0xf, %edi
movq %r14, %rsi
callq 0x21d0
movq %rbx, %rdi
addq $0x70, %rdi
xorl %esi, %esi
callq 0x2140
movq %rbx, 0x7129(%rip)      # 0x10248
movb $0x1, 0x6d(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8e4c
leaq 0x23f1(%rip), %rdi      # 0xb52d
leaq 0x1e5f(%rip), %rsi      # 0xafa2
leaq 0x23e7(%rip), %rcx      # 0xb531
movl $0x64, %edx
callq 0x2150
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2869
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rcx
callq 0x85dd
testq %rax, %rax
je 0x97dc
movq %rax, %r14
cmpb $0x1, 0x6e(%rbx)
jne 0x97cf
movq %r14, %rdi
callq 0x880b
leaq 0x1b6f(%rip), %rdi      # 0xb334
movq %rax, %rsi
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
callq 0x8814
movq %rax, %r14
jmp 0x97df
xorl %r14d, %r14d
testq %r14, %r14
je 0x9836
movq 0x48(%rbx), %r15
movq %r14, %rdi
callq 0x645d
movq %rax, %r12
movq %r14, %rdi
callq 0x642f
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x6829
movq %r14, %rdi
callq 0x63bc
movq %rbx, %rdi
callq 0x983b
testb %al, %al
je 0x9826
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x26bc
callq 0x29fd
// File: /workspace/github_c_makefile_star2_O1/goghcrow[P]dubbo_ab/dubbo_client.c
// Function: cli_write
static bool cli_write(struct dubbo_client *cli)
{
    struct buffer *buf = cli->snd_buf;
    if (!buf_readable(buf))
    {
        aeDeleteFileEvent(cli->el, cli->fd, AE_WRITABLE);
        return true;
    }

    int nwritten = 0;
    while (buf_readable(buf))
    {
        nwritten = write(cli->fd, buf_peek(buf), buf_readable(buf));
        if (nwritten <= 0)
        {
            if (errno == EINTR)
            {
                continue;
            }
            break;
        }
        buf_retrieve(buf, nwritten);
    }

    if (nwritten <= 0)
    {
        if (errno == EAGAIN)
        {
            if (AE_ERR == aeCreateFileEvent(cli->el, cli->fd, AE_WRITABLE, cli_on_write, cli))
            {
                LOG_ERROR("Dubbo 请求失败: 创建可写事件失败");
                return false;
            }
            return true;
        }
        else
        {
            LOG_ERROR("Dubbo 发送数据失败: %s", strerror(errno));
            return false;
        }
    }

    if (!buf_readable(buf))
    {
        aeDeleteFileEvent(cli->el, cli->fd, AE_WRITABLE);
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x642f
testq %rax, %rax
je 0x991e
movq %r14, %rdi
callq 0x642f
testq %rax, %rax
je 0x98e9
movl 0x68(%rbx), %r15d
movq %r14, %rdi
callq 0x645d
movq %rax, %r12
movq %r14, %rdi
callq 0x642f
movl %r15d, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0x20b0
movq %rax, %r15
testl %r15d, %r15d
jle 0x98ab
movl %r15d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %r14, %rdi
callq 0x6638
jmp 0x98b5
callq 0x2050
cmpl $0x4, (%rax)
jne 0x98c2
movq %r14, %rdi
callq 0x642f
testq %rax, %rax
jne 0x986b
testl %r15d, %r15d
jle 0x98e9
movq %r14, %rdi
callq 0x642f
movb $0x1, %r14b
testq %rax, %rax
jne 0x9931
movq (%rbx), %rdi
movl 0x68(%rbx), %esi
movl $0x2, %edx
callq 0x3076
jmp 0x9931
callq 0x2050
movl (%rax), %edi
cmpl $0xb, %edi
jne 0x993d
movq (%rbx), %rdi
movl 0x68(%rbx), %esi
leaq 0x45(%rip), %rcx        # 0x9947
movl $0x2, %edx
movq %rbx, %r8
callq 0x2fa0
movb $0x1, %r14b
cmpl $-0x1, %eax
jne 0x9931
callq 0x2a78
jmp 0x9942
movq (%rbx), %rdi
movl 0x68(%rbx), %esi
movl $0x2, %edx
callq 0x3076
movb $0x1, %r14b
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a35
xorl %r14d, %r14d
jmp 0x9931
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
cmpb $0x0, 0x6c(%rdx)
je 0x9977
movq %rdx, %rbx
movq %rdx, %rdi
callq 0x983b
testb %al, %al
je 0x9969
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x26bc
leaq 0x16f3(%rip), %rdi      # 0xb071
leaq 0x161d(%rip), %rsi      # 0xafa2
leaq 0x1a5e(%rip), %rcx      # 0xb3ea
movl $0x17e, %edx            # imm = 0x17E
callq 0x2150
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x6c(%rdi)
movq 0x38(%rdi), %rsi
cmpq $-0x1, %rsi
je 0x99e9
movq (%rbx), %rdi
callq 0x3262
movq $-0x1, 0x38(%rbx)
movl $0xffffffff, 0x68(%rbx) # imm = 0xFFFFFFFF
movl 0x50(%rbx), %eax
movl %eax, 0x54(%rbx)
movq 0x40(%rbx), %rdi
callq 0x667f
movq 0x48(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x667f
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9d1e
movq %rdi, %rbx
callq 0x2370
movq (%rax), %r14
decq %rbx
movsbq 0x1(%rbx), %rax
incq %rbx
cmpq $0x3d, %rax
je 0x9cd2
movzwl (%r14,%rax,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
jne 0x9cd2
testb %al, %al
je 0x9d20
movq %rbx, %rdi
callq 0x20d0
leaq (%rbx,%rax), %rcx
decq %rcx
movq %rcx, %rax
cmpq %rbx, %rcx
jbe 0x9d18
movsbq (%rax), %rdx
leaq -0x1(%rax), %rcx
testb $0x20, 0x1(%r14,%rdx,2)
jne 0x9d00
movb $0x0, 0x1(%rax)
jmp 0x9d20
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/abe.c
// Function: test_pre
void
test_pre()
{
/*	char tmp_buf[256]; */

	DBUG_ENTER("test_pre");

	DBUG_PRINT("", ("sizeof(int)=%d", sizeof(int)));
	DBUG_PRINT("", ("sizeof(CONS*)=%d", sizeof(CONS*)));
	DBUG_PRINT("", ("sizeof(BEH)=%d", sizeof(BEH)));
	assert(sizeof(int) == sizeof(CONS*));
	assert(sizeof(BEH) == sizeof(CONS*));

	DBUG_PRINT("", ("NIL=16#%08lx (%p)", NIL, NIL));
	assert(nilp(NIL));
	assert(nilp(NIL) == _nilp(NIL));

	DBUG_PRINT("", ("sizeof(BOOL)=%d", sizeof(BOOL)));
	assert(sizeof(BOOL) == sizeof(CONS*));
	DBUG_PRINT("", ("TRUE=16#%08lx (%p)", TRUE, TRUE));
	DBUG_PRINT("", ("FALSE=16#%08lx (%p)", FALSE, FALSE));
	assert(TRUE);
	assert(!FALSE);
	assert(TRUE == ((BOOL)(0 == 0)));
	assert(FALSE == ((BOOL)(0 != 0)));

#if TYPETAG_USES_3MSB
	DBUG_PRINT("", ("Type tag in MSB[31:29]"));
#endif /* TYPETAG_USES_3MSB */
#if TYPETAG_USES_2LSB
	DBUG_PRINT("", ("Type tag in LSB[1:0]"));
#endif /* TYPETAG_USES_2LSB */
#if TYPETAG_USES_3LSB
	DBUG_PRINT("", ("Type tag in LSB[2/1:0]"));
#endif /* TYPETAG_USES_3LSB */
#if TYPETAG_USES_1LSB_2MSB
	DBUG_PRINT("", ("Type tag in LSB[0]+MSB[31:30]"));
#endif /* TYPETAG_USES_1LSB_2MSB */
	DBUG_PRINT("", ("_Program[]=16#%08lx (%p)", _Program, _Program));
	assert(_Program == MK_PTR(MK_REF(_Program)));

/* FIXME: enable this test when stack allocation is allowed
	DBUG_PRINT("", ("tmp_buf[]=%p", tmp_buf));
	assert(tmp_buf == MK_PTR(MK_REF(tmp_buf)));
*/

	DBUG_PRINT("", ("test_pre()=16#%08lx (%p)", test_pre, test_pre));
	assert(test_pre == MK_BEH(MK_FUNC(test_pre)));

	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0xb8a8(%rip), %rax      # 0xe004
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10ba5(%rip), %r14     # 0x13310
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1c, 0xc(%rdi)
leaq 0xd726(%rip), %rbx      # 0xfeac
movq %rbx, 0x10(%rdi)
leaq 0x1099f(%rip), %rcx     # 0x13130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xd826
leaq 0x1111b(%rip), %r15     # 0x138c0
cmpl $0x0, (%r15)
je 0x27e3
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %rbx, 0x10(%rax)
movq %rbx, %rdi
callq 0xcf98
testl %eax, %eax
je 0x27e3
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x1e, 0xc(%rax)
leaq 0xb836(%rip), %rdi      # 0xe00d
movl $0x4, %esi
xorl %eax, %eax
callq 0xd897
cmpl $0x0, (%r15)
je 0x2821
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %rbx, 0x10(%rax)
movq %rbx, %rdi
callq 0xcf98
testl %eax, %eax
je 0x2821
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x1f, 0xc(%rax)
leaq 0xb807(%rip), %rdi      # 0xe01c
movl $0x8, %esi
xorl %eax, %eax
callq 0xd897
cmpl $0x0, (%r15)
je 0x285f
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %rbx, 0x10(%rax)
movq %rbx, %rdi
callq 0xcf98
testl %eax, %eax
je 0x285f
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x20, 0xc(%rax)
leaq 0xb7da(%rip), %rdi      # 0xe02d
movl $0x8, %esi
xorl %eax, %eax
callq 0xd897
leaq 0xb7d6(%rip), %rdi      # 0xe03c
leaq 0xb7ec(%rip), %rsi      # 0xe059
leaq 0xb7eb(%rip), %rcx      # 0xe05f
movl $0x21, %edx
callq 0x2110
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0xb480(%rip), %rax      # 0xe194
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x105ed(%rip), %r15     # 0x13310
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x15, 0xc(%rdi)
leaq 0xd16e(%rip), %rbx      # 0xfeac
movq %rbx, 0x10(%rdi)
leaq 0x1042f(%rip), %rcx     # 0x13178
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xd826
leaq 0x8(%rsp), %rdi
callq 0x2180
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2180
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2d65
leaq 0x10b40(%rip), %rax     # 0x138c0
cmpl $0x0, (%rax)
je 0x2dc2
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbx, 0x10(%rax)
movq %rbx, %rdi
callq 0xcf98
testl %eax, %eax
je 0x2dc2
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x1a, 0xc(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xb3e3(%rip), %rdi      # 0xe19e
xorl %eax, %eax
callq 0xd897
movq 0x8(%rsp), %rax
movq %rax, 0x105a2(%rip)     # 0x13370
leaq 0x18(%rsp), %rdi
movl $0x1c, 0xc(%rdi)
callq 0xd9ab
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xb333(%rip), %rax      # 0xe1b4
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10480(%rip), %rax     # 0x13310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x2d, 0xc(%rdi)
leaq 0xd001(%rip), %rcx      # 0xfeac
movq %rcx, 0x10(%rdi)
leaq 0x102c2(%rip), %rcx     # 0x13178
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xd826
movq 0x30(%rbx), %rdi
callq 0xbb59
movq %rax, %rbx
leaq 0xb2e4(%rip), %rdi      # 0xe1ba
callq 0x8f90
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xbf8e
movl %eax, %ecx
andl $0x3, %ecx
movq %rax, %rdi
cmpl $0x2, %ecx
jne 0x2efc
callq 0x8ffd
jmp 0x2f01
callq 0x5ab0
leaq 0xbd8c(%rip), %rdi      # 0xec94
movq %rax, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x8(%rsp), %rdi
movl $0x30, 0xc(%rdi)
callq 0xd9ab
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xb287(%rip), %rax      # 0xe1bf
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x103c9(%rip), %rax     # 0x13310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x37, 0xc(%rdi)
leaq 0xcf4a(%rip), %rcx      # 0xfeac
movq %rcx, 0x10(%rdi)
leaq 0x1020b(%rip), %rcx     # 0x13178
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xd826
movq 0x30(%rbx), %rdi
callq 0xbb59
movq %rax, %rbx
leaq 0xb22d(%rip), %rdi      # 0xe1ba
callq 0x8f90
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xbf8e
movl %eax, %ecx
andl $0x3, %ecx
movq %rax, %rdi
cmpl $0x2, %ecx
jne 0x2fb3
callq 0x8ffd
jmp 0x2fb8
callq 0x5ab0
leaq 0xbcd5(%rip), %rdi      # 0xec94
movq %rax, %rsi
xorl %eax, %eax
callq 0x20f0
movl $0xa, %edi
callq 0x2040
leaq 0x8(%rsp), %rdi
movl $0x3b, 0xc(%rdi)
callq 0xd9ab
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xaaab(%rip), %rax      # 0xe28e
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xfb1e(%rip), %r15      # 0x13310
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x8a, 0xc(%rdi)
leaq 0xc69f(%rip), %r14      # 0xfeac
movq %r14, 0x10(%rdi)
leaq 0xf960(%rip), %rcx      # 0x13178
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xd826
leaq 0x10094(%rip), %rax     # 0x138c0
cmpl $0x0, (%rax)
je 0x3866
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0xcf98
testl %eax, %eax
je 0x3866
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x8b, 0xc(%rax)
leaq 0xaec6(%rip), %rdi      # 0xe723
movl %ebp, %esi
xorl %eax, %eax
callq 0xd897
leaq 0xaecb(%rip), %rdi      # 0xe738
callq 0x8f90
movslq %ebp, %rcx
leaq 0x3(,%rcx,4), %rdx
leaq 0xf9fc(%rip), %r14      # 0x13280
movq %r14, %rdi
movq %rax, %rsi
callq 0xc000
leaq -0x8ac(%rip), %rsi      # 0x2fea
movq %rbx, %rdi
movq %rax, %rdx
callq 0x474e
movq %rax, %r15
leaq 0xa946(%rip), %rdi      # 0xe1f1
callq 0x8f90
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xc000
movq %rax, %r15
leaq 0xa8e7(%rip), %rdi      # 0xe1af
callq 0x8f90
movq %rax, %r12
callq 0x2de9
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xc000
movq %rax, %r14
leaq -0x647(%rip), %rsi      # 0x32a6
movq %rbx, %rdi
movq %r15, %rdx
callq 0x474e
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x482b
leaq 0x8(%rsp), %rdi
movl $0x92, 0xc(%rdi)
callq 0xd9ab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xbb59
movq %rax, %r14
leaq 0xa953(%rip), %rdi      # 0xe29b
callq 0x8f90
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xbf8e
movq %rax, %r14
leaq -0xaf2(%rip), %rsi      # 0x2e72
leaq 0xf915(%rip), %r15      # 0x13280
movq %rbx, %rdi
movq %r15, %rdx
callq 0x474e
movq %rax, %rbp
leaq 0xa83a(%rip), %rdi      # 0xe1ba
callq 0x8f90
movq %rax, %r13
leaq 0xa911(%rip), %rax      # 0xe2a0
movq %rsp, %r12
movq %rax, (%r12)
leaq 0xf973(%rip), %rax      # 0x13310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r12)
movl $0x9b, 0xc(%r12)
leaq 0xc4f0(%rip), %rcx      # 0xfeac
movq %rcx, 0x10(%r12)
leaq 0xf7b0(%rip), %rcx      # 0x13178
movq %rcx, 0x18(%r12)
movq %rax, 0x20(%r12)
movq %r12, %rdi
callq 0xd826
leaq 0xa8c9(%rip), %rdi      # 0xe2aa
callq 0x8f90
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xc000
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x482b
movq 0x30(%rbx), %rdi
callq 0xbaba
movq %rax, %rdi
callq 0x3c25
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x482b
leaq 0xa88a(%rip), %rdi      # 0xe2b2
callq 0x8f90
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xc000
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x482b
leaq -0xb27(%rip), %rsi      # 0x2f29
movq %rbx, %rdi
movq %r15, %rdx
callq 0x474e
movq %rax, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xc000
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x482b
movl $0xa0, 0xc(%r12)
movq %r12, %rdi
callq 0xd9ab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0xa807(%rip), %rax      # 0xe2b9
movq %rsp, %rbx
movq %rax, (%rbx)
leaq 0xf851(%rip), %rax      # 0x13310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rbx)
movl $0xaa, 0xc(%rbx)
leaq 0xc3d2(%rip), %rcx      # 0xfeac
movq %rcx, 0x10(%rbx)
leaq 0xf693(%rip), %rcx      # 0x13178
movq %rcx, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0xd826
leaq 0xa7f1(%rip), %rdi      # 0xe2ed
callq 0x20b0
leaq 0xa6b2(%rip), %rdi      # 0xe1ba
callq 0x8f90
movq %rax, %r15
leaq 0xa7ae(%rip), %rdi      # 0xe2c5
callq 0x8f90
leaq 0xf75d(%rip), %r12      # 0x13280
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc000
leaq -0x214(%rip), %rsi      # 0x3924
movq %r14, %rdi
movq %rax, %rdx
callq 0x474e
movq %rax, %r15
leaq 0xa74e(%rip), %r13      # 0xe29b
movq %r13, %rdi
callq 0x8f90
movq %rax, %rbp
leaq 0xa76c(%rip), %rdi      # 0xe2cb
callq 0x8f90
movq %r12, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0xc000
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x482b
movq %r13, %rdi
callq 0x8f90
movl $0xab, %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0xc000
movq %rax, %r12
leaq 0xa730(%rip), %rdi      # 0xe2d2
callq 0x8f90
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xc000
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x482b
movq %r14, %rdi
callq 0x5607
movl $0xb8, 0xc(%rbx)
movq %rbx, %rdi
callq 0xd9ab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0xe90(%rip), %r14       # 0x2010
leaq 0xe97(%rip), %r15       # 0x201e
leaq 0xe89(%rip), %r12       # 0x2017
movq %r14, %rdi
cmpl $0x989680, %ebp         # imm = 0x989680
je 0x11b1
cmpl $0x5f5e0ff, %ebp        # imm = 0x5F5E0FF
je 0x11ae
cmpl $0x2faf080, %ebp        # imm = 0x2FAF080
jne 0x11b6
movq %r12, %rdi
jmp 0x11b1
movq %r15, %rdi
callq 0x1030
incl %ebp
cmpl $0x5f5e100, %ebp        # imm = 0x5F5E100
jne 0x118e
movq %rbx, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq -0x72(%rip), %rdx       # 0x116c
leaq 0xe1f(%rip), %rcx       # 0x2004
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1050
leaq 0xe44(%rip), %r14       # 0x203c
leaq 0xe45(%rip), %r15       # 0x2044
leaq 0xe3a(%rip), %r12       # 0x2040
movq %r14, %rdi
cmpl $0x989680, %ebx         # imm = 0x989680
je 0x1229
cmpl $0x5f5e0ff, %ebx        # imm = 0x5F5E0FF
je 0x1226
cmpl $0x2faf080, %ebx        # imm = 0x2FAF080
jne 0x122e
movq %r12, %rdi
jmp 0x1229
movq %r15, %rdi
callq 0x1030
incl %ebx
cmpl $0x5f5e100, %ebx        # imm = 0x5F5E100
jne 0x1206
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1060
leaq 0xddb(%rip), %rdi       # 0x2025
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x1180
leaq 0xe8e(%rip), %rbx       # 0x2004
movq %rbx, %rdi
callq 0x1040
jmp 0x1176
movq %rsi, %rbx
movslq %edi, %r12
movl %edi, %r13d
decq %r12
leaq 0xe73(%rip), %r15       # 0x2006
movl %edi, -0x2c(%rbp)
cmpl $0x2, %edi
jl 0x11c6
movl $0x1, %r14d
movq (%rbx,%r14,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
cmpq %r12, %r14
jge 0x11be
movl $0x20, %edi
callq 0x1030
incq %r14
cmpq %r14, %r13
jne 0x11a1
movl $0xa, %edi
callq 0x1030
movl -0x2c(%rbp), %edi
jmp 0x1196
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/converters/dtos8cvt/dtos8cvt.c
// Function: main
int main (int argc, char *argv[])
{
int i, k;
unsigned short buf[BLKSIZ];
char *ppos, oname[256];
FILE *ifile, *ofile;

if ((argc < 2) || (argv[0] == NULL)) {
	printf ("Usage is: verb file [file...]\n");
	exit (0);  }

for (i = 1; i < argc; i++) {
	strcpy (oname, argv[i]);
        if (ppos = strrchr (oname, '.')) strcpy (ppos, ".dt8");
                else strcat (oname, ".dt8");
	ifile = fopen (argv[i], "rb");
	if (ifile == NULL) {
		printf ("Error opening file: %s\n", argv[i]);
		exit (0);  }
	ofile = fopen (oname, "wb");
	if (ofile == NULL) {
		printf ("Error opening file: %s\n", oname);
		exit (0);  }

	printf ("Processing file %s\n", argv[i]);
	for (;;) {
		k = fread (buf, sizeof (short), BLKSIZ - 1, ifile);
		if (k == 0) break;
		for ( ; k < BLKSIZ; k++) buf[k] = 0;
		fwrite (buf, sizeof (short), BLKSIZ, ofile);
		}
	fclose (ifile);
	fclose (ofile);
	}

return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
cmpl $0x2, %edi
jl 0x1359
movq %rsi, %rbx
cmpq $0x0, (%rsi)
je 0x1359
movl %edi, %eax
movq %rax, 0x8(%rsp)
movl $0x1, %r13d
leaq 0x10(%rsp), %r14
leaq 0x110(%rsp), %rbp
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
callq 0x1030
movq %r14, %rdi
movl $0x2e, %esi
callq 0x1090
testq %rax, %rax
je 0x1247
movb $0x0, 0x4(%rax)
movl $0x3874642e, (%rax)     # imm = 0x3874642E
jmp 0x125c
movq %r14, %rdi
callq 0x1070
movl $0x3874642e, 0x10(%rsp,%rax) # imm = 0x3874642E
movb $0x0, 0x14(%rsp,%rax)
movq (%rbx,%r13,8), %rdi
leaq 0xda2(%rip), %rsi       # 0x2009
callq 0x10b0
testq %rax, %rax
je 0x1332
movq %rax, %r15
movq %r14, %rdi
leaq 0xda2(%rip), %rsi       # 0x2024
callq 0x10b0
testq %rax, %rax
je 0x133f
movq %rax, %r12
movq (%rbx,%r13,8), %rsi
leaq 0xd89(%rip), %rdi       # 0x2027
xorl %eax, %eax
callq 0x1080
movl $0x2, %esi
movl $0x80, %edx
movq %rbp, %rdi
movq %r15, %rcx
callq 0x1050
testl %eax, %eax
je 0x1300
cmpl $0x80, %eax
jg 0x12e9
movslq %eax, %rcx
leaq (%rsp,%rcx,2), %rdi
addq $0x110, %rdi            # imm = 0x110
movl $0x80, %ecx
subl %eax, %ecx
leaq 0x2(,%rcx,2), %rdx
xorl %esi, %esi
callq 0x10a0
movl $0x2, %esi
movl $0x81, %edx
movq %rbp, %rdi
movq %r12, %rcx
callq 0x10d0
jmp 0x12a5
movq %r15, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1060
incq %r13
cmpq 0x8(%rsp), %r13
jne 0x121d
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx,%r13,8), %rsi
leaq 0xccf(%rip), %rdi       # 0x200c
jmp 0x134b
leaq 0xcc6(%rip), %rdi       # 0x200c
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x1080
xorl %edi, %edi
callq 0x10c0
leaq 0xcdb(%rip), %rdi       # 0x203b
callq 0x1040
jmp 0x1352
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x4e20, %rsp           # imm = 0x4E20
movq %rsp, %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x11b8
testl %eax, %eax
jle 0x11a9
movq %rsp, %rbx
leaq 0x2710(%rsp), %r14
leaq 0xe89(%rip), %r15       # 0x2004
movq %rbx, %rdi
movq %r14, %rsi
movl $0x28, %edx
callq 0x1219
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x11b8
testl %eax, %eax
jg 0x117b
xorl %eax, %eax
addq $0x4e20, %rsp           # imm = 0x4E20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jl 0x11ee
movl %esi, %ebp
decl %ebp
movl %ebp, %r15d
xorl %r14d, %r14d
callq 0x1040
cmpl $-0x1, %eax
je 0x11f2
cmpl $0xa, %eax
je 0x11f2
movb %al, (%rbx,%r14)
incq %r14
cmpq %r14, %r15
jne 0x11d1
jmp 0x11f5
xorl %ebp, %ebp
jmp 0x11fb
movl %r14d, %ebp
cmpl $0xa, %eax
sete %al
testb $0x1, %al
je 0x1207
movl %ebp, %eax
incl %ebp
movb $0xa, (%rbx,%rax)
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movb (%rdi), %bl
xorl %eax, %eax
testb %bl, %bl
je 0x12b2
leal -0xb(%rdx), %ecx
incq %rdi
xorl %r10d, %r10d
xorl %ebp, %ebp
xorl %r9d, %r9d
xorl %r8d, %r8d
movslq %r8d, %r14
movb %bl, (%rsi,%r14)
cmpb $0xa, %bl
cmovel %eax, %r9d
movl $0x1, %r11d
cmpl %ecx, %r9d
je 0x1256
movl %ebp, %r11d
testl %r11d, %r11d
je 0x126b
cmpb $0x20, %bl
je 0x1268
movzbl %bl, %ebx
cmpl $0x9, %ebx
jne 0x126b
movl %r8d, %r10d
incl %r9d
cmpl %edx, %r9d
jne 0x12a0
testl %r10d, %r10d
jne 0x128c
leaq 0x1(%r14), %r8
movb $0x2d, (%rsi,%r14)
movb $0xa, 0x1(%rsi,%r14)
xorl %r9d, %r9d
jmp 0x129a
movslq %r10d, %r9
movb $0xa, (%rsi,%r9)
movl %r8d, %r9d
subl %r10d, %r9d
xorl %r11d, %r11d
xorl %r10d, %r10d
incl %r8d
movb (%rdi), %bl
incq %rdi
movl %r11d, %ebp
testb %bl, %bl
jne 0x123a
movslq %r8d, %rax
movb $0x0, (%rsi,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4ba(%rip), %rdi       # 0x2307
callq 0x1050
movl 0x233c(%rip), %edi      # 0x4194
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1130
leaq 0x4bc(%rip), %rdi       # 0x2326
callq 0x1050
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x70, %rsp
leaq 0xeb8(%rip), %rsi       # 0x2010
movq %rsp, %rbx
movl $0xc, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0x0, 0x60(%rbx)
movq %rbx, %rdi
callq 0x1040
movl $0x6874202c, (%rsp,%rax) # imm = 0x6874202C
movw $0x7369, 0x4(%rsp,%rax) # imm = 0x7369
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r12d
cmpl $0x2, %edi
jl 0x1673
movl $0x1, %r12d
movslq %r12d, %rax
movq (%rbx,%rax,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x1673
movb 0x2(%rsi), %r13b
testb %r13b, %r13b
je 0x161c
leaq 0x2(%rsi), %rdi
jmp 0x1621
movq 0x8(%rbx,%rax,8), %rdi
movzbl 0x1(%rsi), %eax
cmpl $0x69, %eax
je 0x1662
cmpl $0x6f, %eax
je 0x1669
cmpl $0x76, %eax
je 0x1736
xorl %r15d, %r15d
leaq 0x2a31(%rip), %rdi      # 0x4073
xorl %eax, %eax
callq 0x1890
testb %r13b, %r13b
sete %al
andb %r15b, %al
movzbl %al, %eax
addl %eax, %r12d
incl %r12d
cmpl %r14d, %r12d
jl 0x1601
jmp 0x1673
callq 0x1284
jmp 0x166e
callq 0x1260
movb $0x1, %r15b
jmp 0x1649
subl %r12d, %r14d
jne 0x1684
movq 0x5959(%rip), %rax      # 0x6fd8
movq (%rax), %rax
jmp 0x16a7
cmpl $0x2, %r14d
je 0x16ba
cmpl $0x1, %r14d
jne 0x1759
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
leaq 0x297d(%rip), %rsi      # 0x401f
callq 0x192a
movq %rax, 0x5ab2(%rip)      # 0x7160
movq 0x591b(%rip), %rax      # 0x6fd0
movq (%rax), %rax
jmp 0x16e5
movslq %r12d, %r14
movq (%rbx,%r14,8), %rdi
leaq 0x2957(%rip), %rsi      # 0x401f
callq 0x192a
movq %rax, 0x5a8c(%rip)      # 0x7160
movq 0x8(%rbx,%r14,8), %rdi
leaq 0x2929(%rip), %rsi      # 0x4009
callq 0x192a
movq %rax, 0x5a7c(%rip)      # 0x7168
callq 0x1ba7
movq %rax, %rbx
movq 0x5a65(%rip), %rdi      # 0x7160
movq %rax, %rsi
xorl %edx, %edx
callq 0x1fb4
movq %rbx, %rdi
callq 0x176f
movq 0x5a4c(%rip), %rdi      # 0x7160
callq 0x1090
movq 0x5a48(%rip), %rdi      # 0x7168
callq 0x1090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x59fb(%rip), %rsi      # 0x7138
movq 0x59fc(%rip), %rdx      # 0x7140
leaq 0x2919(%rip), %rdi      # 0x4064
xorl %eax, %eax
callq 0x10b0
xorl %edi, %edi
callq 0x1200
leaq 0x292d(%rip), %rdi      # 0x408d
callq 0x1070
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1200
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpl $0x1, %edi
jne 0x119e
leaq 0xe6f(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
jmp 0x1218
movq %rsi, %rbx
leaq 0xe98(%rip), %rsi       # 0x2040
leaq -0x60(%rbp), %r14
movl $0x8, %ecx
movq %r14, %rdi
rep  movsq (%rsi), %es:(%rdi)
movw $0x0, 0x44(%r14)
movl $0x0, 0x40(%r14)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1050
leaq 0xe46(%rip), %rsi       # 0x201f
movq %r14, %rdi
callq 0x1070
testq %rax, %rax
je 0x1218
movq %rax, %r14
xorl %r15d, %r15d
incl %r15d
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
jne 0x11ec
movq 0x8(%rbx), %rdx
leaq 0xe1b(%rip), %rdi       # 0x2021
movl %r15d, %esi
xorl %eax, %eax
callq 0x1030
movq %r14, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r14
incl 0x10(%rax)
testq %r12, %r12
je 0x66d2
movq %rbx, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7516
movq %rax, %r12
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x66ba
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x66ba
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
incl 0x10(%r12)
movq %r12, 0x18(%r14)
movl %r15d, 0x20(%r14)
leaq 0x2fb0a(%rip), %rax     # 0x361d8
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9078
movl %eax, %r15d
movl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x10(%r14)
cmpl $0x1, %eax
jg 0x66fb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x759a
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edx
callq 0x67d1
testq %rax, %rax
je 0x67aa
cmpl $0x0, 0x4(%rax)
jne 0x67aa
leaq 0x149(%rip), %rcx       # 0x68ed
cmpq %rcx, 0x18(%rax)
je 0x67c8
leaq 0x2526a(%rip), %rsi     # 0x2ba1b
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x692d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
movq 0x28(%rax), %rax
movl 0x18(%rax), %eax
jmp 0x67c3