LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: tb_strerror
const char *tb_strerror(int err) {
    switch (err) {
        case TB_OK:
            return "Success";
        case TB_ERR_NEED_MORE:
            return "Not enough input";
        case TB_ERR_INIT_ALREADY:
            return "Termbox initialized already";
        case TB_ERR_MEM:
            return "Out of memory";
        case TB_ERR_NO_EVENT:
            return "No event";
        case TB_ERR_NO_TERM:
            return "No TERM in environment";
        case TB_ERR_NOT_INIT:
            return "Termbox not initialized";
        case TB_ERR_OUT_OF_BOUNDS:
            return "Out of bounds";
        case TB_ERR_UNSUPPORTED_TERM:
            return "Unsupported terminal";
        case TB_ERR_CAP_COLLISION:
            return "Termcaps collision";
        case TB_ERR_RESIZE_SSCANF:
            return "Terminal width/height not received by sscanf() after "
                   "resize";
        case TB_ERR:
        case TB_ERR_INIT_OPEN:
        case TB_ERR_READ:
        case TB_ERR_RESIZE_IOCTL:
        case TB_ERR_RESIZE_PIPE:
        case TB_ERR_RESIZE_SIGACTION:
        case TB_ERR_POLL:
        case TB_ERR_TCGETATTR:
        case TB_ERR_TCSETATTR:
        case TB_ERR_RESIZE_WRITE:
        case TB_ERR_RESIZE_POLL:
        case TB_ERR_RESIZE_READ:
        default:
            strerror_r(global.last_errno, global.errbuf, sizeof(global.errbuf));
            return (const char *)global.errbuf;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x16, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x16, %eax
ja 0x8f01
movq -0x18(%rbp), %rax
leaq 0x291c5(%rip), %rcx     # 0x32020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x29b98(%rip), %rax     # 0x32a03
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29b90(%rip), %rax     # 0x32a0b
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29b91(%rip), %rax     # 0x32a1c
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29b9d(%rip), %rax     # 0x32a38
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29b9b(%rip), %rax     # 0x32a46
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29b97(%rip), %rax     # 0x32a4f
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29ba1(%rip), %rax     # 0x32a66
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29bac(%rip), %rax     # 0x32a7e
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29bad(%rip), %rax     # 0x32a8c
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29bb5(%rip), %rax     # 0x32aa1
movq %rax, -0x8(%rbp)
jmp 0x8f30
leaq 0x29bbb(%rip), %rax     # 0x32ab4
movq %rax, -0x8(%rbp)
jmp 0x8f30
jmp 0x8f01
movl 0x331b1(%rip), %edi     # 0x3c0b8
leaq 0x32f8a(%rip), %rsi     # 0x3be98
addq $0x238, %rsi            # imm = 0x238
movl $0x400, %edx            # imm = 0x400
callq 0x63b0
leaq 0x32f72(%rip), %rax     # 0x3be98
addq $0x238, %rax            # imm = 0x238
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: main
int main(int argc, char **argv) {
    int rv;
    parse_opts(argc, argv);

    if (opt_top_mode != 0) {
        rv = main_top(argc, argv);
    } else if (opt_pid != -1) {
        rv = main_pid(opt_pid);
    } else if (opt_pgrep_args != NULL) {
        in_pgrep_mode = 1;
        rv = main_pgrep();
    } else if (optind < argc) {
        rv = main_fork(argc, argv);
    } else {
        log_error("Expected pid (-p), pgrep (-P), or command\n\n");
        usage(stderr, 1);
        rv = 1;
    }
    cleanup();
    return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x9050
cmpl $0x0, 0x3353f(%rip)     # 0x3c4d8
je 0x8faf
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2a460
movl %eax, -0x14(%rbp)
jmp 0x9036
cmpl $-0x1, 0x3136a(%rip)    # 0x3a320
je 0x8fc8
movl 0x31362(%rip), %edi     # 0x3a320
callq 0x96c0
movl %eax, -0x14(%rbp)
jmp 0x9034
cmpq $0x0, 0x33500(%rip)     # 0x3c4d0
je 0x8fe8
movl $0x1, 0x33584(%rip)     # 0x3c560
movb $0x0, %al
callq 0x29b50
movl %eax, -0x14(%rbp)
jmp 0x9032
movq 0x30fd9(%rip), %rax     # 0x39fc8
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jge 0x9007
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x9b90
movl %eax, -0x14(%rbp)
jmp 0x9030
leaq 0x29b1b(%rip), %rdi     # 0x32b29
movb $0x0, %al
callq 0x9cc0
movq 0x30fd4(%rip), %rax     # 0x39ff0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x9d70
movl $0x1, -0x14(%rbp)
jmp 0x9032
jmp 0x9034
jmp 0x9036
callq 0x11ec0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: main_fork
static int main_fork(int argc, char **argv) {
    int rv, status;
    pid_t fork_pid;
    (void)argc;
    fork_pid = fork();
    if (fork_pid == 0) {
        redirect_child_stdio(STDOUT_FILENO, opt_path_child_out);
        redirect_child_stdio(STDERR_FILENO, opt_path_child_err);
        ptrace(PTRACE_TRACEME, 0, NULL, NULL);
        execvp(argv[optind], argv + optind);
        perror("execvp");
        exit(1);
    } else if (fork_pid < 0) {
        perror("fork");
        exit(1);
    }
    waitpid(fork_pid, &status, 0);
    if (!WIFSTOPPED(status) || WSTOPSIG(status) != SIGTRAP) {
        log_error("main_fork: Expected SIGTRAP from child\n");
    }
    ptrace(PTRACE_DETACH, fork_pid, NULL, NULL);
    rv = main_pid(fork_pid);
    waitpid(fork_pid, NULL, 0);
    return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x65e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x9c23
movq 0x3078c(%rip), %rsi     # 0x3a340
movl $0x1, %edi
callq 0x11da0
movq 0x30783(%rip), %rsi     # 0x3a348
movl $0x2, %edi
callq 0x11da0
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %ecx
movl %esi, %edi
movq %rcx, %rdx
movb $0x0, %al
callq 0x6410
movq -0x10(%rbp), %rax
movq 0x303dc(%rip), %rcx     # 0x39fc8
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq 0x303ca(%rip), %rax     # 0x39fc8
movslq (%rax), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x6560
leaq 0x2b00e(%rip), %rdi     # 0x34c22
callq 0x6520
movl $0x1, %edi
callq 0x6580
cmpl $0x0, -0x1c(%rbp)
jge 0x9c3f
leaq 0x2aff9(%rip), %rdi     # 0x34c29
callq 0x6520
movl $0x1, %edi
callq 0x6580
jmp 0x9c41
movl -0x1c(%rbp), %edi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x64a0
movl -0x18(%rbp), %eax
andl $0xff, %eax
cmpl $0x7f, %eax
jne 0x9c6c
movl -0x18(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x5, %eax
je 0x9c7a
leaq 0x2afbb(%rip), %rdi     # 0x34c2e
movb $0x0, %al
callq 0x9cc0
movl -0x1c(%rbp), %esi
movl $0x11, %edi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
movb $0x0, %al
callq 0x6410
movl -0x1c(%rbp), %edi
callq 0x96c0
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x64a0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: log_error
void log_error(const char *fmt, ...) {
    va_list args;
    if (log_error_enabled) {
        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x9cf5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x3064d(%rip)     # 0x3a370
je 0x9d60
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x302a0(%rip), %rax     # 0x39ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x6540
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: find_addresses
static int find_addresses(trace_target_t *target) {
    int rv;
    addr_memo_t memo;

    memset(&memo, 0, sizeof(addr_memo_t));

    if (opt_executor_globals_addr != 0) {
        target->executor_globals_addr = opt_executor_globals_addr;
    } else {
        try(rv, get_symbol_addr(&memo, target->pid, "executor_globals", &target->executor_globals_addr));
    }
    if (opt_sapi_globals_addr != 0) {
        target->sapi_globals_addr = opt_sapi_globals_addr;
    } else if (opt_capture_req) {
        try(rv, get_symbol_addr(&memo, target->pid, "sapi_globals", &target->sapi_globals_addr));
    }
    if (opt_capture_mem) {
        try(rv, get_symbol_addr(&memo, target->pid, "alloc_globals", &target->alloc_globals_addr));
    }
    log_error_enabled = 0;
    if (get_symbol_addr(&memo, target->pid, "basic_functions_module", &target->basic_functions_module_addr) != 0) {
        target->basic_functions_module_addr = 0;
    }
    log_error_enabled = 1;
    return PHPSPY_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
movl $0x208, %edx            # imm = 0x208
callq 0x6230
cmpq $0x0, 0x32086(%rip)     # 0x3c4e0
je 0xa46d
movq 0x3207d(%rip), %rcx     # 0x3c4e0
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xa4a7
jmp 0xa46f
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
leaq -0x220(%rbp), %rdi
leaq 0x2a7e9(%rip), %rdx     # 0x34c74
callq 0x2c7a0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xa4a3
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa594
jmp 0xa4a5
jmp 0xa4a7
cmpq $0x0, 0x32039(%rip)     # 0x3c4e8
je 0xa4c2
movq 0x32030(%rip), %rcx     # 0x3c4e8
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa507
cmpl $0x0, 0x32027(%rip)     # 0x3c4f0
je 0xa505
jmp 0xa4cd
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
leaq -0x220(%rbp), %rdi
leaq 0x2a79c(%rip), %rdx     # 0x34c85
callq 0x2c7a0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xa501
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa594
jmp 0xa503
jmp 0xa505
jmp 0xa507
cmpl $0x0, 0x31ff6(%rip)     # 0x3c504
je 0xa547
jmp 0xa512
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
leaq -0x220(%rbp), %rdi
leaq 0x2a764(%rip), %rdx     # 0x34c92
callq 0x2c7a0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xa543
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa594
jmp 0xa545
jmp 0xa547
movl $0x0, 0x2fe1f(%rip)     # 0x3a370
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
leaq -0x220(%rbp), %rdi
leaq 0x2a733(%rip), %rdx     # 0x34ca0
callq 0x2c7a0
cmpl $0x0, %eax
je 0xa583
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x1, 0x2fde3(%rip)     # 0x3a370
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: clock_get
static void clock_get(struct timespec *ts) {
    if (clock_gettime(CLOCK_MONOTONIC_RAW, ts) == -1) {
        perror("clock_gettime");
        ts->tv_sec = 0;
        ts->tv_nsec = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x4, %edi
callq 0x6110
cmpl $-0x1, %eax
jne 0xbe62
leaq 0x28e71(%rip), %rdi     # 0x34cb7
callq 0x6520
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: clock_add
static void clock_add(struct timespec *a, struct timespec *b, struct timespec *res) {
    res->tv_sec = a->tv_sec + b->tv_sec;
    res->tv_nsec = a->tv_nsec + b->tv_nsec;
    if (res->tv_nsec >= 1000000000L) {
        res->tv_sec += res->tv_nsec / 1000000000L;
        res->tv_nsec = res->tv_nsec % 1000000000L;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x3b9aca00, 0x8(%rax)  # imm = 0x3B9ACA00
jl 0xbef4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq -0x18(%rbp), %rax
movq %rdx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: pause_pid
static int pause_pid(pid_t pid) {
    int rv;
    if (ptrace(PTRACE_ATTACH, pid, 0, 0) == -1) {
        rv = errno;
        perror("ptrace");
        return PHPSPY_ERR + (rv == ESRCH ? PHPSPY_ERR_PID_DEAD : 0);
    }
    if (waitpid(pid, NULL, 0) < 0) {
        perror("waitpid");
        return PHPSPY_ERR;
    }
    return PHPSPY_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %esi
movl $0x10, %edi
xorl %ecx, %ecx
movl %ecx, %edx
movb $0x0, %al
callq 0x6410
cmpq $-0x1, %rax
jne 0xbf52
callq 0x6060
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x28d30(%rip), %rdi     # 0x34c65
callq 0x6520
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x3, %edx
cmovel %ecx, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xbf81
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x64a0
cmpl $0x0, %eax
jge 0xbf7a
leaq 0x28d00(%rip), %rdi     # 0x34c6c
callq 0x6520
movl $0x1, -0x4(%rbp)
jmp 0xbf81
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: unpause_pid
static int unpause_pid(pid_t pid) {
    int rv;
    if (ptrace(PTRACE_DETACH, pid, 0, 0) == -1) {
        rv = errno;
        perror("ptrace");
        return PHPSPY_ERR + (rv == ESRCH ? PHPSPY_ERR_PID_DEAD : 0);
    }
    return PHPSPY_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %esi
movl $0x11, %edi
xorl %ecx, %ecx
movl %ecx, %edx
movb $0x0, %al
callq 0x6410
cmpq $-0x1, %rax
jne 0xbfe2
callq 0x6060
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x28ca0(%rip), %rdi     # 0x34c65
callq 0x6520
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x3, %edx
cmovel %ecx, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xbfe9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: clock_diff
static int clock_diff(struct timespec *a, struct timespec *b) {
    if (a->tv_sec == b->tv_sec) {
        if (a->tv_nsec == b->tv_nsec) {
            return 0;
        }
        return a->tv_nsec > b->tv_nsec ? 1 : -1;
    }
    return a->tv_sec > b->tv_sec ? 1 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xc05c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xc037
movl $0x0, -0x4(%rbp)
jmp 0xc07d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovgl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xc07d
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovgl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: calc_sleep_time
static void calc_sleep_time(struct timespec *end, struct timespec *start, struct timespec *sleep) {
    long end_ns, start_ns, sleep_ns;
    if (end->tv_sec == start->tv_sec) {
        sleep_ns = opt_sleep_ns - (end->tv_nsec - start->tv_nsec);
    } else {
        end_ns = (end->tv_sec * 1000000000UL) + (end->tv_nsec * 1UL);
        start_ns = (start->tv_sec * 1000000000UL) + (start->tv_nsec * 1UL);
        sleep_ns = opt_sleep_ns - (end_ns - start_ns);
    }
    if (sleep_ns < 0) {
        log_error("calc_sleep_time: Expected sleep_ns>0; decrease sample rate\n");
        sleep_ns = 0;
    }
    if (sleep_ns < 1000000000L) {
        sleep->tv_sec = 0;
        sleep->tv_nsec = (long)sleep_ns;
    } else {
        sleep->tv_sec = (long)sleep_ns / 1000000000L;
        sleep->tv_nsec = (long)sleep_ns - (sleep->tv_sec * 1000000000L);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xc0d4
movq 0x2e26d(%rip), %rax     # 0x3a328
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x8(%rdx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0xc126
movq -0x8(%rbp), %rax
imulq $0x3b9aca00, (%rax), %rax # imm = 0x3B9ACA00
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x0, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
imulq $0x3b9aca00, (%rax), %rax # imm = 0x3B9ACA00
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x0, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x2e211(%rip), %rax     # 0x3a328
movq -0x20(%rbp), %rcx
subq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0xc143
leaq 0x28b91(%rip), %rdi     # 0x34cc5
movb $0x0, %al
callq 0x9cc0
movq $0x0, -0x30(%rbp)
cmpq $0x3b9aca00, -0x30(%rbp) # imm = 0x3B9ACA00
jge 0xc166
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc198
movq -0x30(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
imulq $0x3b9aca00, (%rax), %rax # imm = 0x3B9ACA00
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: load_terminfo_from_path
static int load_terminfo_from_path(const char *path, const char *term) {
    int rv;
    char tmp[PATH_MAX];

    // Look for term at this terminfo location, e.g., <terminfo>/x/xterm
    snprintf_or_return(rv, tmp, sizeof(tmp), "%s/%c/%s", path, term[0], term);
    if_ok_return(rv, read_terminfo_path(tmp));

#ifdef __APPLE__
    // Try the Darwin equivalent path, e.g., <terminfo>/78/xterm
    snprintf_or_return(rv, tmp, sizeof(tmp), "%s/%x/%s", path, term[0], term);
    return read_terminfo_path(tmp);
#endif

    return TB_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movsbl (%rax), %r8d
movq -0x18(%rbp), %r9
movl $0x1000, %esi           # imm = 0x1000
leaq 0x275c6(%rip), %rdx     # 0x3407c
movb $0x0, %al
callq 0x61d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xcacf
cmpl $0x1000, -0x1c(%rbp)    # imm = 0x1000
jl 0xcad8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcafd
jmp 0xcada
leaq -0x1020(%rbp), %rdi
callq 0xcb10
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0xcaf6
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcafd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: read_terminfo_path
static int read_terminfo_path(const char *path) {
    FILE *fp = fopen(path, "rb");
    if (!fp) {
        return TB_ERR;
    }

    struct stat st;
    if (fstat(fileno(fp), &st) != 0) {
        fclose(fp);
        return TB_ERR;
    }

    size_t fsize = st.st_size;
    char *data = tb_malloc(fsize);
    if (!data) {
        fclose(fp);
        return TB_ERR;
    }

    if (fread(data, 1, fsize, fp) != fsize) {
        fclose(fp);
        tb_free(data);
        return TB_ERR;
    }

    global.terminfo = data;
    global.nterminfo = fsize;

    fclose(fp);
    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2755b(%rip), %rsi     # 0x34085
callq 0x6510
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xcb46
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcc20
movq -0x18(%rbp), %rdi
callq 0x6380
movl %eax, %edi
leaq -0xa8(%rbp), %rsi
callq 0x65d0
cmpl $0x0, %eax
je 0xcb77
movq -0x18(%rbp), %rdi
callq 0x6140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcc20
movq -0x78(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x63e0
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
jne 0xcbb1
movq -0x18(%rbp), %rdi
callq 0x6140
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcc20
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x60e0
cmpq -0xb0(%rbp), %rax
je 0xcbf4
movq -0x18(%rbp), %rdi
callq 0x6140
movq -0xb8(%rbp), %rdi
callq 0x6050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcc20
movq -0xb8(%rbp), %rax
movq %rax, 0x2f2d6(%rip)     # 0x3bed8
movq -0xb0(%rbp), %rax
movq %rax, 0x2f2d0(%rip)     # 0x3bee0
movq -0x18(%rbp), %rdi
callq 0x6140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: get_terminfo_string
static const char *get_terminfo_string(int16_t str_offsets_pos,
    int16_t str_table_pos, int16_t str_table_len, int16_t str_index) {
    const int16_t *str_offset =
        (int16_t *)(global.terminfo + (int)str_offsets_pos +
                    ((int)str_index * (int)sizeof(int16_t)));
    if (*str_offset < 0) {
        // A negative indicates the cap is absent from this terminal
        return "";
    }
    if (*str_offset >= str_table_len) {
        // Invalid string offset
        return NULL;
    }
    if (((size_t)((int)str_table_pos + (int)*str_offset)) >= global.nterminfo) {
        // Truncated/corrupt terminfo?
        return NULL;
    }
    return (
        const char *)(global.terminfo + (int)str_table_pos + (int)*str_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %cx, %ax
movw %dx, %cx
movw %si, %dx
movw %di, %si
movw %si, -0xa(%rbp)
movw %dx, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movq 0x2f281(%rip), %rax     # 0x3bed8
movswl -0xa(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movswl -0x10(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movswl (%rax), %eax
cmpl $0x0, %eax
jge 0xcc8a
leaq 0x27e28(%rip), %rax     # 0x34aac
movq %rax, -0x8(%rbp)
jmp 0xcce7
movq -0x18(%rbp), %rax
movswl (%rax), %eax
movswl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jl 0xcca3
movq $0x0, -0x8(%rbp)
jmp 0xcce7
movswl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl (%rcx), %ecx
addl %ecx, %eax
cltq
cmpq 0x2f227(%rip), %rax     # 0x3bee0
jb 0xccc5
movq $0x0, -0x8(%rbp)
jmp 0xcce7
movq 0x2f20c(%rip), %rax     # 0x3bed8
movswl -0xc(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movswl (%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: cellbuf_init
static int cellbuf_init(struct cellbuf_t *c, int w, int h) {
    c->cells = tb_malloc(sizeof(struct tb_cell) * w * h);
    if (!c->cells) {
        return TB_ERR_MEM;
    }
    memset(c->cells, 0, sizeof(struct tb_cell) * w * h);
    c->width = w;
    c->height = h;
    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
movslq -0x18(%rbp), %rax
imulq %rax, %rdi
callq 0x63e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd146
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xd17f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
movslq -0x18(%rbp), %rax
imulq %rax, %rdx
xorl %esi, %esi
callq 0x6230
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: cellbuf_free
static int cellbuf_free(struct cellbuf_t *c) {
    if (c->cells) {
        int i;
        for (i = 0; i < c->width * c->height; i++) {
            cell_free(&c->cells[i]);
        }
        tb_free(c->cells);
    }
    memset(c, 0, sizeof(*c));
    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd1f3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
cmpl %ecx, %eax
jge 0xd1e6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xd2d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd1ae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6050
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x6230
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: bytebuf_free
static int bytebuf_free(struct bytebuf_t *b) {
    if (b->buf) {
        tb_free(b->buf);
    }
    memset(b, 0, sizeof(*b));
    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd232
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6050
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x6230
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: cap_trie_deinit
static int cap_trie_deinit(struct cap_trie_t *node) {
    size_t j;
    for (j = 0; j < node->nchildren; j++) {
        cap_trie_deinit(&node->children[j]);
    }
    if (node->children) {
        tb_free(node->children);
    }
    memset(node, 0, sizeof(*node));
    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd298
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0xd250
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd264
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd2b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6050
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x6230
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: extract_esc
static int extract_esc(struct tb_event *event) {
    int rv;
    if_ok_or_need_more_return(rv, extract_esc_user(event, 0));
    if_ok_or_need_more_return(rv, extract_esc_cap(event));
    if_ok_or_need_more_return(rv, extract_esc_mouse(event));
    if_ok_or_need_more_return(rv, extract_esc_user(event, 1));
    return TB_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xd610
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xd525
cmpl $-0x2, -0x14(%rbp)
jne 0xd52d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd596
movq -0x10(%rbp), %rdi
callq 0xd6c0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xd544
cmpl $-0x2, -0x14(%rbp)
jne 0xd54c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd596
movq -0x10(%rbp), %rdi
callq 0xd790
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xd563
cmpl $-0x2, -0x14(%rbp)
jne 0xd56b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd596
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xd610
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xd587
cmpl $-0x2, -0x14(%rbp)
jne 0xd58f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd596
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: bytebuf_shift
static int bytebuf_shift(struct bytebuf_t *b, size_t n) {
    if (n > b->len) {
        n = b->len;
    }
    size_t nmove = b->len - n;
    memmove(b->buf, b->buf + n, nmove);
    b->len -= n;
    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xd5ca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
addq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6480
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: extract_esc_user
static int extract_esc_user(struct tb_event *event, int is_post) {
    int rv;
    size_t consumed = 0;
    struct bytebuf_t *in = &global.in;
    int (*fn)(struct tb_event *, size_t *);

    fn = is_post ? global.fn_extract_esc_post : global.fn_extract_esc_pre;

    if (!fn) {
        return TB_ERR;
    }

    rv = fn(event, &consumed);
    if (rv == TB_OK) {
        bytebuf_shift(in, consumed);
    }

    if_ok_or_need_more_return(rv, rv);
    return TB_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x2e86a(%rip), %rax     # 0x3be98
addq $0x190, %rax            # imm = 0x190
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xd64b
movq 0x2ea83(%rip), %rax     # 0x3c0c8
movq %rax, -0x38(%rbp)
jmp 0xd656
movq 0x2ea6e(%rip), %rax     # 0x3c0c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd66e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd6b2
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq *%rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xd692
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd5a0
movl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0xd6a3
cmpl $-0x2, -0x18(%rbp)
jne 0xd6ab
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd6b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: extract_esc_cap
static int extract_esc_cap(struct tb_event *event) {
    int rv;
    struct bytebuf_t *in = &global.in;
    struct cap_trie_t *node;
    size_t depth;

    if_err_return(rv, cap_trie_find(in->buf, in->len, &node, &depth));
    if (node->is_leaf) {
        // Found a leaf node
        event->type = TB_EVENT_KEY;
        event->ch = 0;
        event->key = node->key;
        event->mod = node->mod;
        bytebuf_shift(in, depth);
        return TB_OK;
    } else if (node->nchildren > 0 && in->len <= depth) {
        // Found a branch node (not enough input)
        return TB_ERR_NEED_MORE;
    }

    return TB_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x2e7c5(%rip), %rax     # 0x3be98
addq $0x190, %rax            # imm = 0x190
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0xdcb0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xd709
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd784
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xd759
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x28(%rbp), %rax
movw 0x1c(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x28(%rbp), %rax
movb 0x1e(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xd5a0
movl $0x0, -0x4(%rbp)
jmp 0xd784
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0xd77b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x30(%rbp), %rax
ja 0xd77b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xd784
jmp 0xd77d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: cap_trie_find
static int cap_trie_find(const char *buf, size_t nbuf, struct cap_trie_t **last,
    size_t *depth) {
    struct cap_trie_t *next, *node = &global.cap_trie;
    size_t i, j;
    *last = node;
    *depth = 0;
    for (i = 0; i < nbuf; i++) {
        char c = buf[i];
        next = NULL;

        // Find c in node.children
        for (j = 0; j < node->nchildren; j++) {
            if (node->children[j].c == c) {
                next = &node->children[j];
                break;
            }
        }
        if (!next) {
            // Not found
            return TB_OK;
        }
        node = next;
        *last = node;
        *depth += 1;
        if (node->is_leaf && node->nchildren < 1) {
            break;
        }
    }
    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x2e1cd(%rip), %rax     # 0x3be98
addq $0x170, %rax            # imm = 0x170
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xddcf
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xdd74
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
movsbl -0x49(%rbp), %ecx
cmpl %ecx, %eax
jne 0xdd64
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0xdd74
jmp 0xdd66
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xdd1f
cmpq $0x0, -0x30(%rbp)
jne 0xdd84
movl $0x0, -0x4(%rbp)
jmp 0xddd6
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xddbc
movq -0x38(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jae 0xddbc
jmp 0xddcf
jmp 0xddbe
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xdcf3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: convert_num
static int convert_num(uint32_t num, char *buf) {
    int i, l = 0;
    char ch;
    do {
        /* '0' = 48; 48 + num%10 < 58 < MAX_8bitCHAR */
        buf[l++] = (char)('0' + (num % 10));
        num /= 10;
    } while (num);
    for (i = 0; i < l / 2; i++) {
        ch = buf[i];
        buf[i] = buf[l - 1 - i];
        buf[l - 1 - i] = ch;
    }
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
addl $0x30, %edx
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xe342
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0xe3e9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe382
movl -0x18(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: send_cluster
static int send_cluster(int x, int y, uint32_t *ch, size_t nch) {
    int rv;
    char abuf[8];

    if (global.last_x != x - 1 || global.last_y != y) {
        if_err_return(rv, send_cursor_if(x, y));
    }
    global.last_x = x;
    global.last_y = y;

    int i;
    for (i = 0; i < (int)nch; i++) {
        uint32_t ach = *(ch + i);
        int aw = tb_utf8_unicode_to_char(abuf, ach);
        if (!ach) {
            abuf[0] = ' ';
        }
        if_err_return(rv, bytebuf_nputs(&global.out, abuf, (size_t)aw));
    }

    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl 0x2dab4(%rip), %eax     # 0x3bec0
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xe421
movl 0x2daa8(%rip), %eax     # 0x3bec4
cmpl -0xc(%rbp), %eax
je 0xe441
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x7ab0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xe43f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe4cb
jmp 0xe441
movl -0x8(%rbp), %eax
movl %eax, 0x2da76(%rip)     # 0x3bec0
movl -0xc(%rbp), %eax
movl %eax, 0x2da71(%rip)     # 0x3bec4
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
jge 0xe4c4
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
leaq -0x2c(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x8d20
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0xe48c
movb $0x20, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
movslq -0x38(%rbp), %rdx
leaq 0x2d9fd(%rip), %rdi     # 0x3be98
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x8ae0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xe4b7
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe4cb
jmp 0xe4b9
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xe45a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/vendor/termbox2/termbox2.h
// Function: bytebuf_reserve
static int bytebuf_reserve(struct bytebuf_t *b, size_t sz) {
    if (b->cap >= sz) {
        return TB_OK;
    }
    size_t newcap = b->cap > 0 ? b->cap : 1;
    while (newcap < sz) {
        newcap *= 2;
    }
    char *newbuf;
    if (b->buf) {
        newbuf = tb_realloc(b->buf, newcap);
    } else {
        newbuf = tb_malloc(newcap);
    }
    if (!newbuf) {
        return TB_ERR_MEM;
    }
    b->buf = newbuf;
    b->cap = newcap;
    return TB_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0xe52a
movl $0x0, -0x4(%rbp)
jmp 0xe5c8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0xe543
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xe54e
movl $0x1, %eax
movq %rax, -0x30(%rbp)
jmp 0xe54e
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe56d
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0xe556
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe58d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x6420
movq %rax, -0x28(%rbp)
jmp 0xe59a
movq -0x20(%rbp), %rdi
callq 0x63e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe5aa
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xe5c8
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: atoi_with_min_or_exit
static int atoi_with_min_or_exit(const char *name, const char *str, int min) {
    long result = strtol_with_min_or_exit(name, str, min);
    #if LONG_MAX > INT_MAX
    if (result > INT_MAX) {
        log_error("Expected value that could fit in a C int for %s, got '%s'\n", name, str);
        usage(stderr, 1);
    }
    #endif
    return (int)result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xe650
movq %rax, -0x20(%rbp)
cmpq $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
jle 0xe63b
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x264bd(%rip), %rdi     # 0x34add
movb $0x0, %al
callq 0x9cc0
movq 0x2b9c2(%rip), %rax     # 0x39ff0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x9d70
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: strtol_with_min_or_exit
static long strtol_with_min_or_exit(const char *name, const char *str, int min) {
    long result;
    char *end;
    errno = 0;
    result = strtol(str, &end, 10);
    if (end <= str || *end != '\0') {
        /* e.g. reject -H '', -H invalid, -H 5000suffix */
        log_error("Expected integer for %s, got '%s'\n", name, str);
        usage(stderr, 1);
    }
    if (result < min) {
        /* e.g. reject -H 0 */
        log_error("Expected integer >= %d for %s, got '%s'\n", min, name, str);
        usage(stderr, 1);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x6060
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x6340
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0xe69a
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xe6c4
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x2646f(%rip), %rdi     # 0x34b18
movb $0x0, %al
callq 0x9cc0
movq 0x2b939(%rip), %rax     # 0x39ff0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x9d70
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jge 0xe6fe
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x26458(%rip), %rdi     # 0x34b3b
movb $0x0, %al
callq 0x9cc0
movq 0x2b8ff(%rip), %rax     # 0x39ff0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x9d70
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: redirect_child_stdio
static void redirect_child_stdio(int proc_fd, char *opt_path) {
    char *redir_path;
    FILE *redir_file;
    if (strcmp(opt_path, "-") == 0) {
        return;
    } else if (strstr(opt_path, "%d") != NULL) {
        if (asprintf(&redir_path, opt_path, getpid()) < 0) {
            errno = ENOMEM;
            perror("asprintf");
            exit(1);
        }
    } else {
        if ((redir_path = strdup(opt_path)) == NULL) {
            perror("strdup");
            exit(1);
        }
    }
    if ((redir_file = fopen(redir_path, "w")) == NULL) {
        perror("fopen");
        free(redir_path);
        exit(1);
    }
    dup2(fileno(redir_file), proc_fd);
    fclose(redir_file);
    free(redir_path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20d40(%rip), %rsi     # 0x32afa
callq 0x6310
cmpl $0x0, %eax
jne 0x11dc9
jmp 0x11eb0
movq -0x10(%rbp), %rdi
leaq 0x2378b(%rip), %rsi     # 0x3555f
callq 0x65f0
cmpq $0x0, %rax
je 0x11e25
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x6130
movq -0x28(%rbp), %rsi
movl %eax, %edx
leaq -0x18(%rbp), %rdi
movb $0x0, %al
callq 0x6450
cmpl $0x0, %eax
jge 0x11e23
callq 0x6060
movl $0xc, (%rax)
leaq 0x237f8(%rip), %rdi     # 0x3560c
callq 0x6520
movl $0x1, %edi
callq 0x6580
jmp 0x11e50
movq -0x10(%rbp), %rdi
callq 0x65a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x11e4e
leaq 0x22e17(%rip), %rdi     # 0x34c56
callq 0x6520
movl $0x1, %edi
callq 0x6580
jmp 0x11e50
jmp 0x11e52
movq -0x18(%rbp), %rdi
leaq 0x22e00(%rip), %rsi     # 0x34c5d
callq 0x6510
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x11e8b
leaq 0x22dec(%rip), %rdi     # 0x34c5f
callq 0x6520
movq -0x18(%rbp), %rdi
callq 0x6050
movl $0x1, %edi
callq 0x6580
movq -0x20(%rbp), %rdi
callq 0x6380
movl %eax, %edi
movl -0x4(%rbp), %esi
callq 0x6180
movq -0x20(%rbp), %rdi
callq 0x6140
movq -0x18(%rbp), %rdi
callq 0x6050
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adsr[P]phpspy/phpspy.c
// Function: copy_proc_mem
static int copy_proc_mem(pid_t pid, const char *what, void *raddr, void *laddr, size_t size) {
    struct iovec local[1];
    struct iovec remote[1];

    if (raddr == NULL) {
        log_error("copy_proc_mem: Not copying %s; raddr is NULL\n", what);
        return PHPSPY_ERR;
    }

    local[0].iov_base = laddr;
    local[0].iov_len = size;
    remote[0].iov_base = raddr;
    remote[0].iov_len = size;

    if (process_vm_readv(pid, local, 1, remote, 1, 0) == -1) {
        if (errno == ESRCH) { /* No such process */
            perror("process_vm_readv");
            return PHPSPY_ERR | PHPSPY_ERR_PID_DEAD;
        }
        log_error("copy_proc_mem: Failed to copy %s; err=%s raddr=%p size=%lu\n", what, strerror(errno), raddr, size);
        return PHPSPY_ERR;
    }

    return PHPSPY_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x126c0
movq -0x10(%rbp), %rsi
leaq 0x22863(%rip), %rdi     # 0x34f10
movb $0x0, %al
callq 0x9cc0
movl $0x1, -0x4(%rbp)
jmp 0x12764
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x8(%rbp), %edi
leaq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rcx
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
movq %r8, %rdx
callq 0x6300
cmpq $-0x1, %rax
jne 0x1275d
callq 0x6060
cmpl $0x3, (%rax)
jne 0x12723
leaq 0x22829(%rip), %rdi     # 0x34f3e
callq 0x6520
movl $0x3, -0x4(%rbp)
jmp 0x12764
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x6060
movl (%rax), %edi
callq 0x65b0
movq -0x58(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x22802(%rip), %rdi     # 0x34f4f
movb $0x0, %al
callq 0x9cc0
movl $0x1, -0x4(%rbp)
jmp 0x12764
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)