LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: TimerStop
void TimerStop(
    struct ble_npl_callout *timer)  //  Pointer to timer to stop. Cannot be NULL.
{
    puts("TimerStop");
    assert(timer != NULL);

    //  If Callout Timer is still running...
    if (ble_npl_callout_is_active(timer)) {
        //  Stop the Callout Timer
        ble_npl_callout_stop(timer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x24ec(%rip), %rdi      # 0x9a1f
callq 0x22a0
cmpq $0x0, -0x8(%rbp)
je 0x7541
jmp 0x7560
leaq 0x2482(%rip), %rdi      # 0x99ca
leaq 0x21e4(%rip), %rsi      # 0x9733
movl $0x183, %edx            # imm = 0x183
leaq 0x24ce(%rip), %rcx      # 0x9a29
callq 0x2130
movq -0x8(%rbp), %rdi
callq 0x79a0
testb $0x1, %al
jne 0x756f
jmp 0x7578
movq -0x8(%rbp), %rdi
callq 0x7af0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: TimerStart
void TimerStart(
    struct ble_npl_callout *timer,  //  Pointer to timer. Cannot be NULL.
    uint32_t millisecs)             //  The number of milliseconds from now at which the timer will expire.
{
    puts("TimerStart");
    assert(timer != NULL);

    //  Stop the timer if running
    TimerStop(timer);

    //  Convert milliseconds to ticks
    ble_npl_time_t ticks = ble_npl_time_ms_to_ticks32(
        millisecs  //  Duration in milliseconds
    );

    //  Wait at least 1 tick
    if (ticks == 0) { ticks = 1; }

    //  Trigger the Callout Timer after the elapsed ticks
    ble_npl_error_t rc = ble_npl_callout_reset(
        timer,  //  Callout Timer
        ticks   //  Number of ticks
    );
    assert(rc == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x24bc(%rip), %rdi      # 0x9a52
callq 0x22a0
cmpq $0x0, -0x8(%rbp)
je 0x75a4
jmp 0x75c3
leaq 0x241f(%rip), %rdi      # 0x99ca
leaq 0x2181(%rip), %rsi      # 0x9733
movl $0x192, %edx            # imm = 0x192
leaq 0x249f(%rip), %rcx      # 0x9a5d
callq 0x2130
movq -0x8(%rbp), %rdi
callq 0x7520
movl -0xc(%rbp), %edi
callq 0x8050
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x75e4
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x79e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x75fb
jmp 0x761a
leaq 0x2129(%rip), %rdi      # 0x972b
leaq 0x212a(%rip), %rsi      # 0x9733
movl $0x1a4, %edx            # imm = 0x1A4
leaq 0x2448(%rip), %rcx      # 0x9a5d
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/src/sx126x-linux.c
// Function: DelayMs
void DelayMs(uint32_t millisecs)  //  The number of milliseconds to wait.
{
    //  Implement with Timer Functions from NimBLE Porting Layer.
    //  Convert milliseconds to ticks.
    ble_npl_time_t ticks = ble_npl_time_ms_to_ticks32(
        millisecs  //  Duration in milliseconds
    );

    //  Wait at least 1 tick
    if (ticks == 0) { ticks = 1; }

    //  Wait for the ticks
    ble_npl_time_delay(ticks);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x8050
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x7643
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x8070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_callout.c
// Function: ble_npl_callout_init
void ble_npl_callout_init(struct ble_npl_callout *c, 
                          struct ble_npl_eventq *evq,
                          ble_npl_event_fn *ev_cb, 
                          void *ev_arg)
{
    struct sigevent         event;

    /* Initialize the callout. */
    memset(c, 0, sizeof(*c));
    c->c_ev.ev_cb = ev_cb;
    c->c_ev.ev_arg = ev_arg;
    c->c_evq = evq;
    c->c_active = false;

    event.sigev_notify = SIGEV_THREAD;
    event.sigev_value.sival_ptr = c;     // put callout obj in signal args
    event.sigev_notify_function = ble_npl_callout_timer_cb;
    event.sigev_notify_attributes = NULL;

    timer_create(CLOCK_REALTIME, &event, &c->c_timer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2100
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x30(%rax)
movl $0x2, -0x54(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x26(%rip), %rax        # 0x7930
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdx
addq $0x28, %rdx
xorl %edi, %edi
leaq -0x60(%rbp), %rsi
callq 0x2080
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_callout.c
// Function: ble_npl_callout_timer_cb
static void
ble_npl_callout_timer_cb(union sigval sv)
{
    struct ble_npl_callout *c = (struct ble_npl_callout *)sv.sival_ptr;
    assert(c);

    if (c->c_evq) {
        ble_npl_eventq_put(c->c_evq, &c->c_ev);
    } else {
        c->c_ev.ev_cb(&c->c_ev);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x794d
jmp 0x796c
leaq 0x23d6(%rip), %rdi      # 0x9d2a
leaq 0x236f(%rip), %rsi      # 0x9cca
movl $0x22, %edx
leaq 0x237e(%rip), %rcx      # 0x9ce5
callq 0x2130
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x798a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2560
jmp 0x7998
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_callout.c
// Function: ble_npl_callout_reset
ble_npl_error_t ble_npl_callout_reset(struct ble_npl_callout *c,
				      ble_npl_time_t ticks)
{
    struct itimerspec       its;

    if (ticks < 0) {
        return BLE_NPL_EINVAL;
    }

    if (ticks == 0) {
        ticks = 1;
    }

    c->c_ticks = ble_npl_time_get() + ticks;

    its.it_interval.tv_sec = 0;
    its.it_interval.tv_nsec = 0;                     // one shot
    its.it_value.tv_sec = (ticks / 1000);
    its.it_value.tv_nsec = (ticks % 1000) * 1000000; // expiration
    its.it_value.tv_nsec %= 1000000000;
    c->c_active = true;
    timer_settime(c->c_timer, 0, &its, NULL);

    return BLE_NPL_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jae 0x7a01
movl $0x2, -0x4(%rbp)
jmp 0x7a91
cmpl $0x0, -0x14(%rbp)
jne 0x7a0e
movl $0x1, -0x14(%rbp)
callq 0x7fb0
movl %eax, %ecx
addl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
leaq -0x38(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x22b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_callout.c
// Function: ble_npl_callout_queued
int ble_npl_callout_queued(struct ble_npl_callout *c)
{
    struct itimerspec its;
    timer_gettime(c->c_timer, &its);

    return ((its.it_value.tv_sec > 0) ||
            (its.it_value.tv_nsec > 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20e0
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
jg 0x7ad4
cmpq $0x0, -0x10(%rbp)
setg %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_callout.c
// Function: ble_npl_callout_stop
void ble_npl_callout_stop(struct ble_npl_callout *c)
{
    if (!ble_npl_callout_inited(c)) {
        return;
    }

    struct itimerspec its;
    its.it_interval.tv_sec = 0;
    its.it_interval.tv_nsec = 0;
    its.it_value.tv_sec = 0;
    its.it_value.tv_nsec = 0;
    timer_settime(c->c_timer, 0, &its, NULL);
    c->c_active = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x79c0
cmpl $0x0, %eax
jne 0x7b0c
jmp 0x7b4b
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
leaq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x22b0
movq -0x8(%rbp), %rax
movb $0x0, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_callout.c
// Function: ble_npl_callout_remaining_ticks
uint32_t
ble_npl_callout_remaining_ticks(struct ble_npl_callout *co,
                                ble_npl_time_t now)
{
    ble_npl_time_t rt;
    uint32_t exp;

    struct itimerspec its;
    timer_gettime(co->c_timer, &its);

    exp = its.it_value.tv_sec * 1000;

    if (exp > now) {
        rt = exp - now;
    } else {
        rt = 0;
    }

    return rt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x20e0
imulq $0x3e8, -0x28(%rbp), %rax # imm = 0x3E8
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x7bde
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x7be5
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_sem.c
// Function: ble_npl_sem_init
ble_npl_error_t
ble_npl_sem_init(struct ble_npl_sem *sem, uint16_t tokens)
{
    if (!sem) {
        return BLE_NPL_INVALID_PARAM;
    }

    sem_init(&sem->lock, 0, tokens);

    return BLE_NPL_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7c13
movl $0x3, -0x4(%rbp)
jmp 0x7c29
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %edx
xorl %esi, %esi
callq 0x2190
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_sem.c
// Function: ble_npl_sem_release
ble_npl_error_t
ble_npl_sem_release(struct ble_npl_sem *sem)
{
    int err;

    if (!sem) {
        return BLE_NPL_INVALID_PARAM;
    }

    err = sem_post(&sem->lock);

    return (err) ? BLE_NPL_ERROR : BLE_NPL_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7c5c
movl $0x3, -0x4(%rbp)
jmp 0x7c7b
movq -0x10(%rbp), %rdi
callq 0x22e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl $0xc, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_sem.c
// Function: ble_npl_sem_pend
ble_npl_error_t
ble_npl_sem_pend(struct ble_npl_sem *sem, uint32_t timeout)
{
    int err = 0;
    struct timespec wait;

    if (!sem) {
        return BLE_NPL_INVALID_PARAM;
    }

    if (timeout == BLE_NPL_TIME_FOREVER) {
        err = sem_wait(&sem->lock);
    } else {
        err = clock_gettime(CLOCK_REALTIME, &wait);
        if (err) {
            return BLE_NPL_ERROR;
        }

        wait.tv_sec  += timeout / 1000;
        wait.tv_nsec += (timeout % 1000) * 1000000;

        err = sem_timedwait(&sem->lock, &wait);
        if (err && errno == ETIMEDOUT) {
            return BLE_NPL_TIMEOUT;
        }
    }

    return (err) ? BLE_NPL_ERROR : BLE_NPL_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7cb9
movl $0x3, -0x4(%rbp)
jmp 0x7d5d
cmpl $0x7fffffff, -0x14(%rbp) # imm = 0x7FFFFFFF
jne 0x7cd0
movq -0x10(%rbp), %rdi
callq 0x2120
movl %eax, -0x18(%rbp)
jmp 0x7d4a
xorl %edi, %edi
leaq -0x28(%rbp), %rsi
callq 0x21b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x7ced
movl $0xc, -0x4(%rbp)
jmp 0x7d5d
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movl %eax, %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x7d48
callq 0x2040
cmpl $0x6e, (%rax)
jne 0x7d48
movl $0x6, -0x4(%rbp)
jmp 0x7d5d
jmp 0x7d4a
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl $0xc, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_sem.c
// Function: ble_npl_sem_get_count
uint16_t
ble_npl_sem_get_count(struct ble_npl_sem *sem)
{
    int count;

    assert(sem);
    assert(&sem->lock);
    sem_getvalue(&sem->lock, &count);

    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7d85
jmp 0x7da4
leaq 0x1f85(%rip), %rdi      # 0x9d11
leaq 0x1f82(%rip), %rsi      # 0x9d15
movl $0x58, %edx
leaq 0x1f8d(%rip), %rcx      # 0x9d2c
callq 0x2130
movq -0x8(%rbp), %rax
cmpq $0x0, %rax
je 0x7db0
jmp 0x7dcf
leaq 0x1faa(%rip), %rdi      # 0x9d61
leaq 0x1f57(%rip), %rsi      # 0x9d15
movl $0x59, %edx
leaq 0x1f62(%rip), %rcx      # 0x9d2c
callq 0x2130
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x2280
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_task.c
// Function: ble_npl_task_init
int
ble_npl_task_init(struct ble_npl_task *t, const char *name, ble_npl_task_func_t func,
        void *arg, uint8_t prio, ble_npl_time_t sanity_itvl,
        ble_npl_stack_t *stack_bottom, uint16_t stack_size)
{
    int err;
    if ((t == NULL) || (func == NULL)) {
        return OS_INVALID_PARM;
    }

    err = pthread_attr_init(&t->attr);
    if (err) return err;
    err = pthread_attr_getschedparam (&t->attr, &t->param);
    if (err) return err;
    err = pthread_attr_setschedpolicy(&t->attr, SCHED_RR);
    if (err) return err;
    t->param.sched_priority = prio;
    err = pthread_attr_setschedparam (&t->attr, &t->param);
    if (err) return err;

    t->name = name;
    err = pthread_create(&t->handle, &t->attr, func, arg);

    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movw 0x18(%rbp), %r8w
movq 0x10(%rbp), %r8
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movl %r9d, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7e29
cmpq $0x0, -0x20(%rbp)
jne 0x7e35
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7f01
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x21f0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x7e56
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f01
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x2320
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x7e7f
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f01
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x2, %esi
callq 0x2200
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x7ea2
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f01
movzbl -0x29(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x7ed3
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f01
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2300
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_time.c
// Function: ble_npl_time_delay
void
ble_npl_time_delay(ble_npl_time_t ticks)
{
    struct timespec sleep_time;
    long ms = ble_npl_time_ticks_to_ms32(ticks);
    uint32_t s = ms / 1000;

    ms -= s * 1000;
    sleep_time.tv_sec = s;
    sleep_time.tv_nsec = ms * 1000000;

    nanosleep(&sleep_time, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x8060
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movl %eax, -0x24(%rbp)
imull $0x3e8, -0x24(%rbp), %eax # imm = 0x3E8
movl %eax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x18(%rbp)
imulq $0xf4240, -0x20(%rbp), %rax # imm = 0xF4240
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_mutex.c
// Function: ble_npl_mutex_init
ble_npl_error_t
ble_npl_mutex_init(struct ble_npl_mutex *mu)
{
    if (!mu) {
        return BLE_NPL_INVALID_PARAM;
    }

    pthread_mutexattr_init(&mu->attr);
    pthread_mutexattr_settype(&mu->attr, PTHREAD_MUTEX_RECURSIVE_NP);
    pthread_mutex_init(&mu->lock, &mu->attr);

    return BLE_NPL_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x80fc
movl $0x3, -0x4(%rbp)
jmp 0x8133
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x2060
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x2260
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2270
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lupyuen[P]lora-sx1262/npl/linux/src/os_mutex.c
// Function: ble_npl_mutex_release
ble_npl_error_t
ble_npl_mutex_release(struct ble_npl_mutex *mu)
{
    if (!mu) {
        return BLE_NPL_INVALID_PARAM;
    }

    if (pthread_mutex_unlock(&mu->lock)) {
        return BLE_NPL_BAD_MUTEX;
    }

    return BLE_NPL_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x815c
movl $0x3, -0x4(%rbp)
jmp 0x817a
movq -0x10(%rbp), %rdi
callq 0x2160
cmpl $0x0, %eax
je 0x8173
movl $0x5, -0x4(%rbp)
jmp 0x817a
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/lupyuen[P]lora-sx1262/npl/linux/src/os_mutex.c
// Function: ble_npl_mutex_pend
ble_npl_error_t
ble_npl_mutex_pend(struct ble_npl_mutex *mu, uint32_t timeout)
{
    int err;

    if (!mu) {
        return BLE_NPL_INVALID_PARAM;
    }

    if (timeout == BLE_NPL_TIME_FOREVER) {
        err = pthread_mutex_lock(&mu->lock);
    } else {
        err = clock_gettime(CLOCK_REALTIME, &mu->wait);
        if (err) {
            return BLE_NPL_ERROR;
        }

        mu->wait.tv_sec  += timeout / 1000;
        mu->wait.tv_nsec += (timeout % 1000) * 1000000;

        err = pthread_mutex_timedlock(&mu->lock, &mu->wait);
        if (err == ETIMEDOUT) {
            return BLE_NPL_TIMEOUT;
        }
    }

    return (err) ? BLE_NPL_ERROR : BLE_NPL_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x81b2
movl $0x3, -0x4(%rbp)
jmp 0x8263
cmpl $0x7fffffff, -0x14(%rbp) # imm = 0x7FFFFFFF
jne 0x81cc
movq -0x10(%rbp), %rdi
callq 0x2250
movl %eax, -0x18(%rbp)
jmp 0x8250
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
xorl %edi, %edi
callq 0x21b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x81ed
movl $0xc, -0x4(%rbp)
jmp 0x8263
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movl %eax, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x2310
movl %eax, -0x18(%rbp)
cmpl $0x6e, -0x18(%rbp)
jne 0x824e
movl $0x6, -0x4(%rbp)
jmp 0x8263
jmp 0x8250
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl $0xc, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: ui_build
static void
ui_build(game_t *game, panel_t *terrain)
{
    uint16_t building;
    while ((building = popup_build_select(game, terrain))) {
        yield_t cost = building_cost(building);
        if (!can_afford(game, cost)) {
            popup_message(font_error, "Not enough funding/materials!");
        } else {
            int x = MAP_WIDTH / 2;
            int y = MAP_HEIGHT / 2;
            while (select_position(game, terrain, &x, &y)) {
                if (!game_build(game, building, x, y))
                    popup_message(font_error, "Invalid building location!");
                else
                    break;
            }
            break;
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2df0
movw %ax, -0x12(%rbp)
cmpw $0x0, %ax
je 0x1f35
movzwl -0x12(%rbp), %edi
callq 0x6bf0
movl %edx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movl -0x38(%rbp), %edx
callq 0x3780
testb $0x1, %al
jne 0x1ed1
movl 0x72cb(%rip), %edi      # 0x918c
leaq 0x746a(%rip), %rsi      # 0x9332
movb $0x0, %al
callq 0x3810
jmp 0x1f30
movl $0x1e, -0x44(%rbp)
movl $0xc, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x44(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x39c0
testb $0x1, %al
jne 0x1efa
jmp 0x1f2e
movq -0x8(%rbp), %rdi
movw -0x12(%rbp), %ax
movl -0x44(%rbp), %edx
movl -0x48(%rbp), %ecx
movzwl %ax, %esi
callq 0x6720
testb $0x1, %al
jne 0x1f2a
movl 0x7272(%rip), %edi      # 0x918c
leaq 0x742f(%rip), %rsi      # 0x9350
movb $0x0, %al
callq 0x3810
jmp 0x1f2c
jmp 0x1f2e
jmp 0x1edf
jmp 0x1f35
jmp 0x1e60
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: popup_quit
static bool
popup_quit(bool saving)
{
    panel_t popup;
    char *message;
    if (saving)
        message = "Really save and quit? (Rk{y}/Rk{n})";
    else
        message = "Really quit Yk{without saving}? (Rk{y}/Rk{n})";
    size_t length = strlen(message) - 8;
    panel_center_init(&popup, length + 2, 3);
    panel_printf(&popup, 1, 1, message);
    display_push(&popup);
    display_refresh();
    int input = device_getch();
    display_pop_free();
    display_refresh();
    if (input == 'y' || input == 'Y')
        return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3c40, %rsp           # imm = 0x3C40
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
testb $0x1, -0x2(%rbp)
je 0x2809
leaq 0x6e98(%rip), %rax      # 0x9698
movq %rax, -0x3c28(%rbp)
jmp 0x2817
leaq 0x6eac(%rip), %rax      # 0x96bc
movq %rax, -0x3c28(%rbp)
movq -0x3c28(%rbp), %rdi
callq 0x10c0
subq $0x8, %rax
movq %rax, -0x3c30(%rbp)
movq -0x3c30(%rbp), %rax
addq $0x2, %rax
movl %eax, %esi
leaq -0x3c20(%rbp), %rdi
movl $0x3, %edx
callq 0x48e0
movq -0x3c28(%rbp), %rcx
leaq -0x3c20(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x4c10
leaq -0x3c20(%rbp), %rdi
callq 0x47b0
callq 0x4510
callq 0x8b60
movl %eax, -0x3c34(%rbp)
callq 0x4820
callq 0x4510
cmpl $0x79, -0x3c34(%rbp)
je 0x28a0
cmpl $0x59, -0x3c34(%rbp)
jne 0x28a6
movb $0x1, -0x1(%rbp)
jmp 0x28aa
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x3c40, %rsp           # imm = 0x3C40
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: persist
static bool
persist(game_t *game)
{
    FILE *save = fopen(PERSIST_FILE, "wb");
    if (save) {
        game_save(game, save);
        return fclose(save) == 0;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x692a(%rip), %rdi      # 0x91fd
leaq 0x6933(%rip), %rsi      # 0x920d
callq 0x1220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x290d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x65f0
movq -0x18(%rbp), %rdi
callq 0x10b0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2911
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: text_numlines
static inline int
text_numlines(const char *p)
{
    int count = 0;
    for (; *p != '@'; p = text_next_line(p))
        count++;
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
je 0x2ca7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2cb0
movq %rax, -0x8(%rbp)
jmp 0x2c83
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: text_linelen
static inline int
text_linelen(const char *p)
{
    int count = 0;
    for (; *p != '\n'; p++)
        count++;
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x2d52
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2d2f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: game_getch
static int
game_getch(game_t *game, panel_t *terrain)
{
    for (;;) {
        map_draw_terrain(game->map, terrain);
        display_refresh();
        uint64_t wait = device_uepoch() % PERIOD;
        if (device_kbhit(wait))
            return device_getch();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x5e70
callq 0x4510
callq 0x8cb0
movl $0x1046a, %ecx          # imm = 0x1046A
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8bf0
testb $0x1, %al
jne 0x2dd8
jmp 0x2de3
callq 0x8b60
addq $0x20, %rsp
popq %rbp
retq
jmp 0x2da0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: can_afford
static bool
can_afford(game_t *game, yield_t yield)
{
    return
        (yield.food == 0 || game->food >= yield.food) &&
        (yield.wood == 0 || game->wood >= yield.wood) &&
        (yield.gold == 0 || game->gold >= yield.gold);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x37bc
movq -0x28(%rbp), %rax
movsd 0x28(%rax), %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jb 0x3804
cmpl $0x0, -0x4(%rbp)
je 0x37db
movq -0x28(%rbp), %rax
movsd 0x20(%rax), %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jb 0x3804
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x2a(%rbp)
je 0x37fe
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: popup_message
static void
popup_message(font_t font, char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    int length = vsnprintf(NULL, 0, format, ap);
    va_end(ap);
    va_start(ap, format);
    char buffer[length + 1];
    vsprintf(buffer, format, ap);
    va_end(ap);
    int width = length + 2;
    int height = 3;
    panel_t popup;
    panel_center_init(&popup, width, height);
    panel_puts(&popup, 1, 1, font, buffer);
    display_push(&popup);
    for (;;) {
        int key = display_getch();
        if (is_exit_key(key) || key == 13 || key == ' ')
            break;
    }
    display_pop_free();
    display_refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3d40, %rsp           # imm = 0x3D40
testb %al, %al
je 0x3857
movaps %xmm0, -0x3cf0(%rbp)
movaps %xmm1, -0x3ce0(%rbp)
movaps %xmm2, -0x3cd0(%rbp)
movaps %xmm3, -0x3cc0(%rbp)
movaps %xmm4, -0x3cb0(%rbp)
movaps %xmm5, -0x3ca0(%rbp)
movaps %xmm6, -0x3c90(%rbp)
movaps %xmm7, -0x3c80(%rbp)
movq %r9, -0x3cf8(%rbp)
movq %r8, -0x3d00(%rbp)
movq %rcx, -0x3d08(%rbp)
movq %rdx, -0x3d10(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x3d20(%rbp), %rax
movq %rax, -0x3d38(%rbp)
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x3d30(%rbp)
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rcx
movq %rsi, %rdi
callq 0x1090
movq -0x3d38(%rbp), %rcx
movl %eax, %edx
movq -0x3d30(%rbp), %rax
movl %edx, -0x34(%rbp)
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movl -0x34(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x3d28(%rbp)
movq %rdi, %rsp
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11f0
leaq -0x30(%rbp), %rax
movl -0x34(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4c(%rbp)
movl $0x3, -0x50(%rbp)
movl -0x4c(%rbp), %esi
movl -0x50(%rbp), %edx
leaq -0x3c68(%rbp), %rdi
callq 0x48e0
movq -0x3d28(%rbp), %r8
movl -0x4(%rbp), %ecx
leaq -0x3c68(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x49e0
leaq -0x3c68(%rbp), %rdi
callq 0x47b0
callq 0x48d0
movl %eax, -0x3c6c(%rbp)
movl -0x3c6c(%rbp), %edi
callq 0x2d60
testb $0x1, %al
jne 0x3999
cmpl $0xd, -0x3c6c(%rbp)
je 0x3999
cmpl $0x20, -0x3c6c(%rbp)
jne 0x399b
jmp 0x399d
jmp 0x396d
callq 0x4820
callq 0x4510
movq -0x40(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: select_position
static bool
select_position(game_t *game, panel_t *world, int *x, int *y)
{
    panel_t info;
    int sidey = sideinfo(&info, "Yk{Select Location}");
    panel_printf(&info, 6, sidey + 1, "Use Rk{←↑→↓}");

    font_t highlight = FONT(W, r);
    bool selected = false;
    panel_t overlay;
    panel_init(&overlay, 0, 0, MAP_WIDTH, MAP_HEIGHT);
    panel_putc(&overlay, *x, *y, highlight, panel_getc(world, *x, *y));
    display_push(&overlay);
    int input;
    while (!selected && !is_exit_key(input = game_getch(game, world))) {
        panel_erase(&overlay, *x, *y);
        arrow_adjust(input, x, y);
        panel_putc(&overlay, *x, *y, highlight, panel_getc(world, *x, *y));
        if (input == 13)
            selected = true;
    }

    display_pop_free(); // overlay
    display_pop_free(); // info
    return selected;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7880, %rsp           # imm = 0x7880
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x3c38(%rbp), %rdi
leaq 0x5b54(%rip), %rsi      # 0x953d
callq 0x3d70
movl %eax, -0x3c3c(%rbp)
movl -0x3c3c(%rbp), %edx
addl $0x1, %edx
leaq -0x3c38(%rbp), %rdi
movl $0x6, %esi
leaq 0x5b41(%rip), %rcx      # 0x9551
movb $0x0, %al
callq 0x4c10
movl 0x5d2e(%rip), %eax      # 0x974b
movl %eax, -0x3c40(%rbp)
movb $0x0, -0x3c41(%rbp)
leaq -0x7860(%rbp), %rdi
xorl %edx, %edx
movl $0x3c, %ecx
movl $0x18, %r8d
movl %edx, %esi
callq 0x4340
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x786c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x7868(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0x5110
movl -0x786c(%rbp), %esi
movl -0x7868(%rbp), %edx
movl -0x3c40(%rbp), %ecx
leaq -0x7860(%rbp), %rdi
movzwl %ax, %r8d
callq 0x4440
leaq -0x7860(%rbp), %rdi
callq 0x47b0
xorl %eax, %eax
testb $0x1, -0x3c41(%rbp)
movb %al, -0x786d(%rbp)
jne 0x3ad3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d90
movl %eax, %edi
movl %edi, -0x7864(%rbp)
callq 0x2d60
xorb $-0x1, %al
movb %al, -0x786d(%rbp)
movb -0x786d(%rbp), %al
testb $0x1, %al
jne 0x3ae2
jmp 0x3b71
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
leaq -0x7860(%rbp), %rdi
callq 0x5070
movl -0x7864(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3e40
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x7878(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x7874(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0x5110
movl -0x7878(%rbp), %esi
movl -0x7874(%rbp), %edx
movl -0x3c40(%rbp), %ecx
leaq -0x7860(%rbp), %rdi
movzwl %ax, %r8d
callq 0x4440
cmpl $0xd, -0x7864(%rbp)
jne 0x3b6c
movb $0x1, -0x3c41(%rbp)
jmp 0x3aa0
callq 0x4820
callq 0x4820
movb -0x3c41(%rbp), %al
andb $0x1, %al
addq $0x7880, %rsp           # imm = 0x7880
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/utf.h
// Function: utf32_to_8
static inline size_t
utf32_to_8(uint32_t utf32, uint8_t *utf8)
{
    if (utf32 < 0x80) {
        *utf8 = (uint8_t)utf32;
        return 1;
    }
    if (utf32 < 0x800) {
        utf8[0] = 0xc0 | ((utf32 & 0x07c0) >> 6);
        utf8[1] = 0x80 |  (utf32 & 0x003f);
        return 2;
    }
    if (utf32 < 0x10000) {
        utf8[0] = 0xe0 | ((utf32 & 0xf000) >> 12);
        utf8[1] = 0x80 | ((utf32 & 0x0fc0) >>  6);
        utf8[2] = 0x80 |  (utf32 & 0x003f);
        return 3;
    }
    if (utf32 < 0x110000) {
        utf8[0] = 0xf0 | ((utf32 & 0x1c0000) >> 18);
        utf8[1] = 0x80 | ((utf32 & 0x03f000) >> 12);
        utf8[2] = 0x80 | ((utf32 & 0x000fc0) >>  6);
        utf8[3] = 0x80 |  (utf32 & 0x00003f);
        return 4;
    }
    return 0; /* invalid utf32 */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x80, -0xc(%rbp)
jae 0x3c4c
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0x3d5f
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jae 0x3c8e
movl -0xc(%rbp), %eax
andl $0x7c0, %eax            # imm = 0x7C0
shrl $0x6, %eax
orl $0xc0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq $0x2, -0x8(%rbp)
jmp 0x3d5f
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jae 0x3ce6
movl -0xc(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
shrl $0xc, %eax
orl $0xe0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0xfc0, %eax            # imm = 0xFC0
shrl $0x6, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq $0x3, -0x8(%rbp)
jmp 0x3d5f
cmpl $0x110000, -0xc(%rbp)   # imm = 0x110000
jae 0x3d57
movl -0xc(%rbp), %eax
andl $0x1c0000, %eax         # imm = 0x1C0000
shrl $0x12, %eax
orl $0xf0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0x3f000, %eax          # imm = 0x3F000
shrl $0xc, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
andl $0xfc0, %eax            # imm = 0xFC0
shrl $0x6, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movq $0x4, -0x8(%rbp)
jmp 0x3d5f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: sideinfo
static int
sideinfo(panel_t *p, char *message)
{
    panel_init(p, DISPLAY_WIDTH - SIDEMENU_WIDTH, 0,
               SIDEMENU_WIDTH, DISPLAY_HEIGHT);
    display_push(p);
    panel_fill(p, FONT(K, k), 0x2591);
    panel_border(p, FONT(K, k));
    int y = DISPLAY_HEIGHT / 2 - 1;
    int x = p->w / 2 - panel_strlen(message) / 2 - 1;
    panel_printf(p, x, y, message);
    return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3c, %esi
xorl %edx, %edx
movl $0x14, %ecx
movl $0x18, %r8d
callq 0x4340
movq -0x8(%rbp), %rdi
callq 0x47b0
movq -0x8(%rbp), %rdi
movb $0x0, -0x14(%rbp)
movb $0x0, -0x13(%rbp)
movb $0x1, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
movl -0x14(%rbp), %esi
movl $0x2591, %edx           # imm = 0x2591
callq 0x4960
movq -0x8(%rbp), %rdi
movb $0x0, -0x18(%rbp)
movb $0x0, -0x17(%rbp)
movb $0x1, -0x16(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x18(%rbp), %esi
callq 0x5150
movl $0xb, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cltq
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5290
movq %rax, %rcx
movq -0x28(%rbp), %rax
shrq %rcx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rcx
movb $0x0, %al
callq 0x4c10
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: arrow_adjust
static bool
arrow_adjust(int input, int *x, int *y)
{
    switch (input) {
    case ARROW_U:
        (*y)--;
        return true;
    case ARROW_D:
        (*y)++;
        return true;
    case ARROW_L:
        (*x)--;
        return true;
    case ARROW_R:
        (*x)++;
        return true;
    case ARROW_UL:
        (*x)--;
        (*y)--;
        return true;
    case ARROW_UR:
        (*x)++;
        (*y)--;
        return true;
    case ARROW_DL:
        (*x)--;
        (*y)++;
        return true;
    case ARROW_DR:
        (*x)++;
        (*y)++;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %eax
addl $0xfffffecf, %eax       # imm = 0xFFFFFECF
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x13, %eax
ja 0x3f37
movq -0x20(%rbp), %rax
leaq 0x52cb(%rip), %rcx      # 0x913c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f3b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f3b
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f3b
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f3b
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f3b
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f3b
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f3b
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3f3b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/main.c
// Function: select_target
static int
select_target(game_t *game, panel_t *terrain, panel_t *units)
{
    panel_t info;
    sideinfo(&info, "Yk{Select Target}");

    int key = 0;
    int result = -1;
    do {
        if (key >= 'a' && key < 'a' + (int)(countof(game->invaders))) {
            result = key - 'a';
            break;
        }
        game_draw_units(game, units, true);
    } while (!is_exit_key(key = game_getch(game, terrain)));

    display_pop_free();
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3c40, %rsp           # imm = 0x3C40
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x3c30(%rbp), %rdi
leaq 0x564a(%rip), %rsi      # 0x95bf
callq 0x3d70
movl $0x0, -0x3c34(%rbp)
movl $0xffffffff, -0x3c38(%rbp) # imm = 0xFFFFFFFF
cmpl $0x61, -0x3c34(%rbp)
jl 0x3fb1
cmpl $0x71, -0x3c34(%rbp)
jge 0x3fb1
movl -0x3c34(%rbp), %eax
subl $0x61, %eax
movl %eax, -0x3c38(%rbp)
jmp 0x3fe3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x7f90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d90
movl %eax, %edi
movl %edi, -0x3c34(%rbp)
callq 0x2d60
xorb $-0x1, %al
testb $0x1, %al
jne 0x3f8e
callq 0x4820
movl -0x3c38(%rbp), %eax
addq $0x3c40, %rsp           # imm = 0x3C40
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/display.c
// Function: display_init
void
display_init(void)
{
    device_init();
    panel_init(&display.base, 0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT);
    for (int y = 0; y < DISPLAY_HEIGHT; y++)
        for (int x = 0; x < DISPLAY_WIDTH; x++)
            panel_putc(&display.base, x, y, FONT_DEFAULT, ' ');
    display.panels = &display.base;
    display_refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8760
leaq 0xb644(%rip), %rdi      # 0xf8d8
addq $0x2d00, %rdi           # imm = 0x2D00
xorl %edx, %edx
movl $0x50, %ecx
movl $0x18, %r8d
movl %edx, %esi
callq 0x4340
movl $0x0, -0x4(%rbp)
cmpl $0x18, -0x4(%rbp)
jge 0x4313
movl $0x0, -0x8(%rbp)
cmpl $0x50, -0x8(%rbp)
jge 0x4306
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
movb $0x7, -0xc(%rbp)
movb $0x0, -0xb(%rbp)
movb $0x1, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
movl -0xc(%rbp), %ecx
leaq 0xb5ef(%rip), %rdi      # 0xf8d8
addq $0x2d00, %rdi           # imm = 0x2D00
movl $0x20, %r8d
callq 0x4440
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x42c3
jmp 0x4308
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x42b6
leaq 0xb5be(%rip), %rax      # 0xf8d8
addq $0x2d00, %rax           # imm = 0x2D00
movq %rax, 0x11ec9(%rip)     # 0x161f0
callq 0x4510
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/display.c
// Function: panel_init
void
panel_init(panel_t *p, int x, int y, int w, int h)
{
    p->x = x;
    p->y = y;
    p->w = w;
    p->h = h;
    assert(w <= DISPLAY_WIDTH);
    assert(h <= DISPLAY_HEIGHT);
    for (int y = 0; y < DISPLAY_HEIGHT; y++)
        for (int x = 0; x < DISPLAY_WIDTH; x++)
            p->tiles[x][y].transparent = true;
    p->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpl $0x50, -0x14(%rbp)
jg 0x4388
jmp 0x43a7
leaq 0x542b(%rip), %rdi      # 0x97ba
leaq 0x5402(%rip), %rsi      # 0x9798
movl $0x71, %edx
leaq 0x542b(%rip), %rcx      # 0x97cd
callq 0x1100
cmpl $0x18, -0x18(%rbp)
jg 0x43af
jmp 0x43ce
leaq 0x5446(%rip), %rdi      # 0x97fc
leaq 0x53db(%rip), %rsi      # 0x9798
movl $0x72, %edx
leaq 0x5404(%rip), %rcx      # 0x97cd
callq 0x1100
movl $0x0, -0x1c(%rbp)
cmpl $0x18, -0x1c(%rbp)
jge 0x441f
movl $0x0, -0x20(%rbp)
cmpl $0x50, -0x20(%rbp)
jge 0x4412
movq -0x8(%rbp), %rax
addq $0x10, %rax
movslq -0x20(%rbp), %rcx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movb $0x1, 0x2(%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x43e2
jmp 0x4414
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x43d5
movq -0x8(%rbp), %rax
movq $0x0, 0x3c10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/display.c
// Function: panel_putc
void
panel_putc(panel_t *p, int x, int y, font_t font, uint16_t c)
{
    x += p->x;
    y += p->y;
    if (x >= 0 && x < p->x + p->w && y >= 0 && y < p->y + p->h) {
        p->tiles[x][y].transparent = false;
        p->tiles[x][y].c = c;
        p->tiles[x][y].font = font;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %r8w, %ax
movl %ecx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x450d
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movq -0x10(%rbp), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jge 0x450d
cmpl $0x0, -0x18(%rbp)
jl 0x450d
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x10(%rbp), %rdx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x450d
movq -0x10(%rbp), %rax
addq $0x10, %rax
movslq -0x14(%rbp), %rcx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb $0x0, 0x2(%rax,%rcx,8)
movw -0x1a(%rbp), %dx
movq -0x10(%rbp), %rax
addq $0x10, %rax
movslq -0x14(%rbp), %rcx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movw %dx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movslq -0x14(%rbp), %rcx
imulq $0xc0, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl -0x4(%rbp), %edx
movl %edx, 0x3(%rax,%rcx,8)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]goblin-com/src/display.c
// Function: display_free
void
display_free()
{
    device_move(0, DISPLAY_HEIGHT);
    panel_free(&display.base);
    device_free();
    assert(display.panels == &display.base);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
movl $0x18, %esi
callq 0x8830
leaq 0xb1d1(%rip), %rdi      # 0xf8d8
addq $0x2d00, %rdi           # imm = 0x2D00
callq 0x4760
callq 0x8800
leaq 0xb1b9(%rip), %rax      # 0xf8d8
addq $0x2d00, %rax           # imm = 0x2D00
cmpq %rax, 0x11ac4(%rip)     # 0x161f0
jne 0x4730
jmp 0x474f
leaq 0x5041(%rip), %rdi      # 0x9778
leaq 0x505a(%rip), %rsi      # 0x9798
movl $0x25, %edx
leaq 0x505c(%rip), %rcx      # 0x97a6
callq 0x1100
popq %rbp
retq
nopw %cs:(%rax,%rax)