LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrDecodeUTF8
const char* tigrDecodeUTF8(const char* text, int* cp) {
    unsigned char c = *text++;
    int extra = 0, min = 0;
    *cp = 0;
    if (c >= 0xf0) {
        *cp = c & 0x07;
        extra = 3;
        min = 0x10000;
    } else if (c >= 0xe0) {
        *cp = c & 0x0f;
        extra = 2;
        min = 0x800;
    } else if (c >= 0xc0) {
        *cp = c & 0x1f;
        extra = 1;
        min = 0x80;
    } else if (c >= 0x80) {
        *cp = 0xfffd;
    } else {
        *cp = c;
    }
    while (extra--) {
        c = *text++;
        if ((c & 0xc0) != 0x80) {
            *cp = 0xfffd;
            break;
        }
        (*cp) = ((*cp) << 6) | (c & 0x3f);
    }
    if (*cp < min) {
        *cp = 0xfffd;
    }
    return text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movzbl -0x11(%rbp), %eax
cmpl $0xf0, %eax
jl 0x6ba0
movzbl -0x11(%rbp), %ecx
andl $0x7, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x3, -0x18(%rbp)
movl $0x10000, -0x1c(%rbp)   # imm = 0x10000
jmp 0x6c17
movzbl -0x11(%rbp), %eax
cmpl $0xe0, %eax
jl 0x6bc8
movzbl -0x11(%rbp), %ecx
andl $0xf, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x2, -0x18(%rbp)
movl $0x800, -0x1c(%rbp)     # imm = 0x800
jmp 0x6c15
movzbl -0x11(%rbp), %eax
cmpl $0xc0, %eax
jl 0x6bf0
movzbl -0x11(%rbp), %ecx
andl $0x1f, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x18(%rbp)
movl $0x80, -0x1c(%rbp)
jmp 0x6c13
movzbl -0x11(%rbp), %eax
cmpl $0x80, %eax
jl 0x6c07
movq -0x10(%rbp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
jmp 0x6c11
movzbl -0x11(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x6c13
jmp 0x6c15
jmp 0x6c17
jmp 0x6c19
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x6c73
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
je 0x6c59
movq -0x10(%rbp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
jmp 0x6c73
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shll $0x6, %ecx
movzbl -0x11(%rbp), %eax
andl $0x3f, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x6c19
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6c88
movq -0x10(%rbp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrTextHeight
int tigrTextHeight(TigrFont* font, const char* text) {
    int rowh, h, c;
    tigrSetupFont(font);

    h = rowh = get(font, 0)->h;
    while (*text) {
        text = tigrDecodeUTF8(text, &c);
        if (c == '\n' && *text)
            h += rowh;
    }
    return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6930
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x6d00
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6cf4
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x6b40
movq %rax, -0x10(%rbp)
cmpl $0xa, -0x1c(%rbp)
jne 0x6cf2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6cf2
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x6cbd
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: get
static TigrGlyph* get(TigrFont* font, int code) {
    unsigned lo = 0, hi = font->numGlyphs;
    while (lo < hi) {
        unsigned guess = (lo + hi) / 2;
        if (code < font->glyphs[guess].code)
            hi = guess;
        else
            lo = guess + 1;
    }

    if (lo == 0 || font->glyphs[lo - 1].code != code)
        return &font->glyphs['?' - 32];
    else
        return &font->glyphs[lo - 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x6d5b
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
shrl %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x20(%rbp), %edx
imulq $0x14, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0x6d50
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x6d59
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6d1c
cmpl $0x0, -0x18(%rbp)
je 0x6d7f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x6d93
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x26c, %rax            # imm = 0x26C
movq %rax, -0x8(%rbp)
jmp 0x6dae
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrTextWidth
int tigrTextWidth(TigrFont* font, const char* text) {
    int x = 0, w = 0, c;
    tigrSetupFont(font);

    while (*text) {
        text = tigrDecodeUTF8(text, &c);
        if (c == '\n' || c == '\r') {
            x = 0;
        } else {
            x += get(font, c)->w;
            w = (x > w) ? x : w;
        }
    }
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6930
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6e49
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x6b40
movq %rax, -0x10(%rbp)
cmpl $0xa, -0x1c(%rbp)
je 0x6e0d
cmpl $0xd, -0x1c(%rbp)
jne 0x6e16
movl $0x0, -0x14(%rbp)
jmp 0x6e47
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6d00
movl 0xc(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x6e3b
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x6e41
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x6de7
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: setupVSync
static void setupVSync(Display* display, Window win) {
    if (hasGLXExtension(display, "GLX_EXT_swap_control")) {
        PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT =
            (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
        if (glXSwapIntervalEXT) {
            glXSwapIntervalEXT(display, win, 1);
        }
    } else if (hasGLXExtension(display, "GLX_MESA_swap_control")) {
        PFNGLXSWAPINTERVALMESAPROC glXSwapIntervalMESA =
            (PFNGLXSWAPINTERVALMESAPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalMESA");
        if (glXSwapIntervalMESA) {
            glXSwapIntervalMESA(1);
        }
    } else if (hasGLXExtension(display, "GLX_SGI_swap_control")) {
        PFNGLXSWAPINTERVALSGIPROC glXSwapIntervalSGI =
            (PFNGLXSWAPINTERVALSGIPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalSGI");
        if (glXSwapIntervalSGI) {
            glXSwapIntervalSGI(1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9119(%rip), %rsi      # 0x106f4
callq 0xa720
cmpl $0x0, %eax
je 0x7611
leaq 0x911d(%rip), %rdi      # 0x10709
callq 0x3360
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x760f
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq *%rax
jmp 0x7681
movq -0x8(%rbp), %rdi
leaq 0x9100(%rip), %rsi      # 0x1071c
callq 0xa720
cmpl $0x0, %eax
je 0x7647
leaq 0x9105(%rip), %rdi      # 0x10732
callq 0x3360
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7645
movl $0x1, %edi
callq *-0x20(%rbp)
jmp 0x767f
movq -0x8(%rbp), %rdi
leaq 0x90f4(%rip), %rsi      # 0x10746
callq 0xa720
cmpl $0x0, %eax
je 0x767d
leaq 0x90f8(%rip), %rdi      # 0x1075b
callq 0x3360
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x767b
movl $0x1, %edi
callq *-0x28(%rbp)
jmp 0x767d
jmp 0x767f
jmp 0x7681
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrHideCursor
static void tigrHideCursor(TigrInternal* win) {
    Cursor invisibleCursor;
    Pixmap bitmapNoData;
    XColor black;
    static char noData[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
    black.red = black.green = black.blue = 0;

    bitmapNoData = XCreateBitmapFromData(win->dpy, win->win, noData, 8, 8);
    invisibleCursor = XCreatePixmapCursor(win->dpy, bitmapNoData, bitmapNoData, &black, &black, 0, 0);
    XDefineCursor(win->dpy, win->win, invisibleCursor);
    XFreeCursor(win->dpy, invisibleCursor);
    XFreePixmap(win->dpy, bitmapNoData);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movw $0x0, -0x1c(%rbp)
movw $0x0, -0x1e(%rbp)
movw $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
leaq 0xd167(%rip), %rdx      # 0x1482c
movl $0x8, %r8d
movl %r8d, %ecx
callq 0x33f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %r8
xorl %r9d, %r9d
movq %r8, %rcx
movl $0x0, (%rsp)
callq 0x3290
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x36f0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3380
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3720
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrKeyDown
int tigrKeyDown(Tigr* bmp, int key) {
    TigrInternal* win;
    assert(key < 256);
    win = tigrInternal(bmp);
    return win->keys[key] && !win->prev[key];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x7a0a
jmp 0x7a29
leaq 0x8aee(%rip), %rdi      # 0x104ff
leaq 0x8a64(%rip), %rsi      # 0x1047c
movl $0x1203, %edx           # imm = 0x1203
leaq 0x8ae5(%rip), %rcx      # 0x10509
callq 0x3260
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl 0x90(%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x7a68
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, 0x190(%rax,%rcx)
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrReadChar
int tigrReadChar(Tigr* bmp) {
    TigrInternal* win = tigrInternal(bmp);
    int c = win->lastChar;
    win->lastChar = 0;
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8c(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrUpdate
void tigrUpdate(Tigr* bmp) {
    XWindowAttributes gwa;

    TigrInternal* win = tigrInternal(bmp);

    memcpy(win->prev, win->keys, 256);

    XGetWindowAttributes(win->dpy, win->win, &gwa);

    if (win->flags & TIGR_AUTO)
        tigrResize(bmp, gwa.width / win->scale, gwa.height / win->scale);
    else
        win->scale = tigrEnforceScale(tigrCalcScale(bmp->w, bmp->h, gwa.width, gwa.height), win->flags);

    tigrPosition(bmp, win->scale, gwa.width, gwa.height, win->pos);
    glXMakeCurrent(win->dpy, win->win, win->glc);
    tigrGAPIPresent(bmp, gwa.width, gwa.height);
    glXSwapBuffers(win->dpy, win->win);

    tigrProcessInput(win, gwa.width, gwa.height);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
movq -0x98(%rbp), %rsi
addq $0x90, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x32d0
movq -0x98(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x98(%rbp), %rax
movq 0x38(%rax), %rsi
leaq -0x90(%rbp), %rdx
callq 0x3710
movq -0x98(%rbp), %rax
movl 0x74(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x82ca
movq -0x8(%rbp), %rdi
movl -0x88(%rbp), %eax
movq -0x98(%rbp), %rcx
cltd
idivl 0x78(%rcx)
movl %eax, %esi
movl -0x84(%rbp), %eax
movq -0x98(%rbp), %rcx
cltd
idivl 0x78(%rcx)
movl %eax, %edx
callq 0x39b0
jmp 0x8305
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
movl -0x88(%rbp), %edx
movl -0x84(%rbp), %ecx
callq 0x3ad0
movl %eax, %edi
movq -0x98(%rbp), %rax
movl 0x74(%rax), %esi
callq 0x3b40
movl %eax, %ecx
movq -0x98(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rdi
movq -0x98(%rbp), %rax
movl 0x78(%rax), %esi
movl -0x88(%rbp), %edx
movl -0x84(%rbp), %ecx
movq -0x98(%rbp), %r8
addq $0x7c, %r8
callq 0x3ba0
movq -0x98(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x98(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x98(%rbp), %rax
movq 0x40(%rax), %rdx
callq 0x32c0
movq -0x8(%rbp), %rdi
movl -0x88(%rbp), %esi
movl -0x84(%rbp), %edx
callq 0x83b0
movq -0x98(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x98(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x3750
movq -0x98(%rbp), %rdi
movl -0x88(%rbp), %esi
movl -0x84(%rbp), %edx
callq 0x86d0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrError
void tigrError(Tigr* bmp, const char* message, ...) {
    char tmp[1024];

    va_list args;
    va_start(args, message);
    vsnprintf(tmp, sizeof(tmp), message, args);
    tmp[sizeof(tmp) - 1] = 0;
    va_end(args);

    printf("tigr fatal error: %s\n", tmp);

    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
testb %al, %al
je 0x8aa7
movaps %xmm0, -0x4b0(%rbp)
movaps %xmm1, -0x4a0(%rbp)
movaps %xmm2, -0x490(%rbp)
movaps %xmm3, -0x480(%rbp)
movaps %xmm4, -0x470(%rbp)
movaps %xmm5, -0x460(%rbp)
movaps %xmm6, -0x450(%rbp)
movaps %xmm7, -0x440(%rbp)
movq %r9, -0x4b8(%rbp)
movq %r8, -0x4c0(%rbp)
movq %rcx, -0x4c8(%rbp)
movq %rdx, -0x4d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x430(%rbp), %rax
leaq -0x4e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x430(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x3230
movb $0x0, -0x11(%rbp)
leaq -0x430(%rbp), %rax
leaq -0x410(%rbp), %rsi
leaq 0x7a1c(%rip), %rdi      # 0x10543
movb $0x0, %al
callq 0x3060
movl $0x1, %edi
callq 0x3420
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrTime
float tigrTime() {
    static double lastTime = 0;

    struct timeval tv;
    gettimeofday(&tv, NULL);

    double now = (double)tv.tv_sec + (tv.tv_usec / 1000000.0);
    double elapsed = lastTime == 0 ? 0 : now - lastTime;
    lastTime = now;

    return (float)elapsed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3670
cvtsi2sdq -0x10(%rbp), %xmm0
cvtsi2sdq -0x8(%rbp), %xmm1
movsd 0x78f7(%rip), %xmm2     # 0x10460
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0xbca2(%rip), %xmm0     # 0x14820
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8b93
jp 0x8b93
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x8ba5
movsd -0x18(%rbp), %xmm0
subsd 0xbc80(%rip), %xmm0     # 0x14820
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0xbc64(%rip)     # 0x14820
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrMouse
void tigrMouse(Tigr* bmp, int* x, int* y, int* buttons) {
    TigrInternal* win = tigrInternal(bmp);
    if (x) {
        *x = win->mouseX;
    }
    if (y) {
        *y = win->mouseY;
    }
    if (buttons) {
        *buttons = win->mouseButtons;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8c0c
movq -0x28(%rbp), %rax
movl 0x294(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x8c23
movq -0x28(%rbp), %rax
movl 0x298(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x8c3a
movq -0x28(%rbp), %rax
movl 0x290(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrTouch
int tigrTouch(Tigr* bmp, TigrTouchPoint* points, int maxPoints) {
    int buttons = 0;
    if (maxPoints > 0) {
        tigrMouse(bmp, &points->x, &points->y, &buttons);
    }
    return buttons ? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x8c79
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
leaq -0x18(%rbp), %rcx
callq 0x8bd0
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrCheckShaderErrors
void tigrCheckShaderErrors(GLuint object) {
    GLint success;
    GLchar info[2048];
    glGetShaderiv(object, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(object, sizeof(info), NULL, info);
        tigrError(NULL, "shader compile error : %s\n", info);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x810, %rsp            # imm = 0x810
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x8b81, %esi           # imm = 0x8B81
leaq -0x8(%rbp), %rdx
callq 0x3790
cmpl $0x0, -0x8(%rbp)
jne 0x8d26
movl -0x4(%rbp), %edi
leaq -0x810(%rbp), %rcx
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
movl %eax, %edx
callq 0x30e0
leaq -0x810(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x7859(%rip), %rsi      # 0x10578
movb $0x0, %al
callq 0x8a60
addq $0x810, %rsp            # imm = 0x810
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrCheckProgramErrors
void tigrCheckProgramErrors(GLuint object) {
    GLint success;
    GLchar info[2048];
    glGetProgramiv(object, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(object, sizeof(info), NULL, info);
        tigrError(NULL, "shader link error : %s\n", info);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x810, %rsp            # imm = 0x810
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x8b82, %esi           # imm = 0x8B82
leaq -0x8(%rbp), %rdx
callq 0x3220
cmpl $0x0, -0x8(%rbp)
jne 0x8d86
movl -0x4(%rbp), %edi
leaq -0x810(%rbp), %rcx
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
movl %eax, %edx
callq 0x3210
leaq -0x810(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
leaq 0x7814(%rip), %rsi      # 0x10593
movb $0x0, %al
callq 0x8a60
addq $0x810, %rsp            # imm = 0x810
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrGAPIDestroy
void tigrGAPIDestroy(Tigr* bmp) {
    TigrInternal* win = tigrInternal(bmp);
    GLStuff* gl = &win->gl;

    if (tigrGAPIBegin(bmp) < 0) {
        tigrError(bmp, "Cannot activate OpenGL context.\n");
        return;
    }

    if (!gl->gl_legacy) {
        glDeleteTextures(2, gl->tex);
        glDeleteProgram(gl->program);
    }

    tigrCheckGLError("destroy");

    if (tigrGAPIEnd(bmp) < 0) {
        tigrError(bmp, "Cannot deactivate OpenGL context.\n");
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7940
cmpl $0x0, %eax
jge 0x8f57
movq -0x8(%rbp), %rdi
leaq 0x7688(%rip), %rsi      # 0x105d6
movb $0x0, %al
callq 0x8a60
jmp 0x8fa7
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x8f7b
movq -0x18(%rbp), %rsi
movl $0x2, %edi
callq 0x3520
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x3140
leaq 0x7675(%rip), %rdi      # 0x105f7
callq 0x8c90
movq -0x8(%rbp), %rdi
callq 0x79c0
cmpl $0x0, %eax
jge 0x8fa7
movq -0x8(%rbp), %rdi
leaq 0x765f(%rip), %rsi      # 0x105ff
movb $0x0, %al
callq 0x8a60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrEncodeUTF8
char* tigrEncodeUTF8(char* text, int cp) {
    if (cp < 0 || cp > 0x10ffff) {
        cp = 0xfffd;
    }

#define EMIT(X, Y, Z) *text++ = X | ((cp >> Y) & Z)
    if (cp < 0x80) {
        EMIT(0x00, 0, 0x7f);
    } else if (cp < 0x800) {
        EMIT(0xc0, 6, 0x1f);
        EMIT(0x80, 0, 0x3f);
    } else if (cp < 0x10000) {
        EMIT(0xe0, 12, 0xf);
        EMIT(0x80, 6, 0x3f);
        EMIT(0x80, 0, 0x3f);
    } else {
        EMIT(0xf0, 18, 0x7);
        EMIT(0x80, 12, 0x3f);
        EMIT(0x80, 6, 0x3f);
        EMIT(0x80, 0, 0x3f);
    }
    return text;
#undef EMIT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x91ba
cmpl $0x10ffff, -0xc(%rbp)   # imm = 0x10FFFF
jle 0x91c1
movl $0xfffd, -0xc(%rbp)     # imm = 0xFFFD
cmpl $0x80, -0xc(%rbp)
jge 0x91ee
movl -0xc(%rbp), %eax
sarl $0x0, %eax
andl $0x7f, %eax
orl $0x0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x9337
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jge 0x923e
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x1f, %eax
orl $0xc0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0x0, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x9335
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0x92af
movl -0xc(%rbp), %eax
sarl $0xc, %eax
andl $0xf, %eax
orl $0xe0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0x0, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x9333
movl -0xc(%rbp), %eax
sarl $0x12, %eax
andl $0x7, %eax
orl $0xf0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0x0, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x9335
jmp 0x9337
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrBeginOpenGL
int tigrBeginOpenGL(Tigr* bmp) {
#ifdef TIGR_GAPI_GL
    TigrInternal* win = tigrInternal(bmp);
    win->gl.gl_user_opengl_rendering = 1;
    return tigrGAPIBegin(bmp) == 0;
#else
    return 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x7940
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrSetPostShader
void tigrSetPostShader(Tigr* bmp, const char* code, int size) {
#ifdef TIGR_GAPI_GL
    tigrGAPIBegin(bmp);
    TigrInternal* win = tigrInternal(bmp);
    GLStuff* gl = &win->gl;
    tigrCreateShaderProgram(gl, code, size);
    tigrGAPIEnd(bmp);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7940
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x8d90
movq -0x8(%rbp), %rdi
callq 0x79c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrSetPostFX
void tigrSetPostFX(Tigr* bmp, float p1, float p2, float p3, float p4) {
    TigrInternal* win = tigrInternal(bmp);
    win->p1 = p1;
    win->p2 = p2;
    win->p3 = p3;
    win->p4 = p4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x64(%rax)
movss -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x68(%rax)
movss -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x6c(%rax)
movss -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x70(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: find
static const unsigned char* find(PNG* png, const char* chunk, unsigned minlen) {
    const unsigned char* start;
    while (png->p < png->end) {
        unsigned len = get32(png->p + 0);
        start = png->p;
        png->p += len + 12;
        if (memcmp(start + 4, chunk, 4) == 0 && len >= minlen && png->p <= png->end)
            return start + 8;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x94ec
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x9500
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %edx
addl $0xc, %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x94e7
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jb 0x94e7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x94e7
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x94f4
jmp 0x9463
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: encodeByte
static void encodeByte(Save* s, unsigned char v) {
    updateAdler(s, v);

    // Simple RLE compression. We could do better by doing a search
    // to find matches, but this works pretty well TBH.
    if (s->prev == v && s->runlen < 115) {
        s->runlen++;
    } else {
        if (s->runlen)
            endrun(s);

        s->prev = v;
        s->runlen = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq 0xa050
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x9e27
movq -0x8(%rbp), %rax
cmpl $0x73, 0x10(%rax)
jae 0x9e27
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x9e50
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x9e3a
movq -0x8(%rbp), %rdi
callq 0x9e60
movzbl -0x9(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: endrun
static void endrun(Save* s) {
    s->runlen--;
    literal(s, s->prev);

    if (s->runlen >= 67)
        encodelen(s, 277, 4, s->runlen - 67);
    else if (s->runlen >= 35)
        encodelen(s, 273, 3, s->runlen - 35);
    else if (s->runlen >= 19)
        encodelen(s, 269, 2, s->runlen - 19);
    else if (s->runlen >= 11)
        encodelen(s, 265, 1, s->runlen - 11);
    else if (s->runlen >= 3)
        encodelen(s, 257, 0, s->runlen - 3);
    else
        while (s->runlen--)
            literal(s, s->prev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x9fa0
movq -0x8(%rbp), %rax
cmpl $0x43, 0x10(%rax)
jb 0x9eb5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x43, %ecx
movl $0x115, %esi            # imm = 0x115
movl $0x4, %edx
callq 0xa0c0
jmp 0x9f8b
movq -0x8(%rbp), %rax
cmpl $0x23, 0x10(%rax)
jb 0x9ee1
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x23, %ecx
movl $0x111, %esi            # imm = 0x111
movl $0x3, %edx
callq 0xa0c0
jmp 0x9f89
movq -0x8(%rbp), %rax
cmpl $0x13, 0x10(%rax)
jb 0x9f0a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x13, %ecx
movl $0x10d, %esi            # imm = 0x10D
movl $0x2, %edx
callq 0xa0c0
jmp 0x9f87
movq -0x8(%rbp), %rax
cmpl $0xb, 0x10(%rax)
jb 0x9f33
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0xb, %ecx
movl $0x109, %esi            # imm = 0x109
movl $0x1, %edx
callq 0xa0c0
jmp 0x9f85
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jb 0x9f59
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x3, %ecx
movl $0x101, %esi            # imm = 0x101
xorl %edx, %edx
callq 0xa0c0
jmp 0x9f83
jmp 0x9f5b
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x10(%rcx)
cmpl $0x0, %eax
je 0x9f81
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x9fa0
jmp 0x9f5b
jmp 0x9f83
jmp 0x9f85
jmp 0x9f87
jmp 0x9f89
jmp 0x9f8b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: literal
static void literal(Save* s, unsigned v) {
    // Encode a literal/length using the built-in tables.
    // Could do better with a custom table but whatever.
    if (v < 144)
        putbitsr(s, 0x030 + v - 0, 8);
    else if (v < 256)
        putbitsr(s, 0x190 + v - 144, 9);
    else if (v < 280)
        putbitsr(s, 0x000 + v - 256, 7);
    else
        putbitsr(s, 0x0c0 + v - 280, 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x90, -0xc(%rbp)
jae 0x9fd1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x30, %esi
subl $0x0, %esi
movl $0x8, %edx
callq 0x5740
jmp 0xa03f
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x9ff9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x190, %esi            # imm = 0x190
subl $0x90, %esi
movl $0x9, %edx
callq 0x5740
jmp 0xa03d
cmpl $0x118, -0xc(%rbp)      # imm = 0x118
jae 0xa01e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x0, %esi
subl $0x100, %esi            # imm = 0x100
movl $0x7, %edx
callq 0x5740
jmp 0xa03b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0xc0, %esi
subl $0x118, %esi            # imm = 0x118
movl $0x8, %edx
callq 0x5740
jmp 0xa03d
jmp 0xa03f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: updateAdler
static void updateAdler(Save* s, unsigned v) {
    unsigned s1 = s->adler & 0xffff, s2 = (s->adler >> 16) & 0xffff;
    s1 = (s1 + v) % 65521;
    s2 = (s2 + s1) % 65521;
    s->adler = (s2 << 16) + s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
shll $0x10, %ecx
addl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: build
static int build(State* s, unsigned* tree, unsigned char* lens, int symcount) {
    int n, codes[16], first[16], counts[16] = { 0 };

    // Frequency count.
    for (n = 0; n < symcount; n++)
        counts[lens[n]]++;

    // Distribute codes.
    counts[0] = codes[0] = first[0] = 0;
    for (n = 1; n <= 15; n++) {
        codes[n] = (codes[n - 1] + counts[n - 1]) << 1;
        first[n] = first[n - 1] + counts[n - 1];
    }
    CHECK(first[15] + counts[15] <= symcount);

    // Insert keys into the tree for each symbol.
    for (n = 0; n < symcount; n++) {
        int len = lens[n];
        if (len != 0) {
            int code = codes[len]++, slot = first[len]++;
            tree[slot] = (code << (32 - len)) | (n << 4) | len;
        }
    }

    return first[15];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x31d0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xa244
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl -0xe0(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0xe0(%rbp,%rax,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa214
movl $0x0, -0xa0(%rbp)
movl $0x0, -0x60(%rbp)
movl $0x0, -0xe0(%rbp)
movl $0x1, -0x20(%rbp)
cmpl $0xf, -0x20(%rbp)
jg 0xa2c5
movl -0x20(%rbp), %eax
subl $0x1, %eax
cltq
movl -0x60(%rbp,%rax,4), %ecx
movl -0x20(%rbp), %eax
subl $0x1, %eax
cltq
addl -0xe0(%rbp,%rax,4), %ecx
shll %ecx
movslq -0x20(%rbp), %rax
movl %ecx, -0x60(%rbp,%rax,4)
movl -0x20(%rbp), %eax
subl $0x1, %eax
cltq
movl -0xa0(%rbp,%rax,4), %ecx
movl -0x20(%rbp), %eax
subl $0x1, %eax
cltq
addl -0xe0(%rbp,%rax,4), %ecx
movslq -0x20(%rbp), %rax
movl %ecx, -0xa0(%rbp,%rax,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa266
movl -0x64(%rbp), %eax
addl -0xa4(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0xa2e5
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3100
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xa38c
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x0, -0xe4(%rbp)
je 0xa37c
movslq -0xe4(%rbp), %rcx
movl -0x60(%rbp,%rcx,4), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x60(%rbp,%rcx,4)
movl %eax, -0xe8(%rbp)
movslq -0xe4(%rbp), %rcx
movl -0xa0(%rbp,%rcx,4), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0xa0(%rbp,%rcx,4)
movl %eax, -0xec(%rbp)
movl -0xe8(%rbp), %edx
movl $0x20, %ecx
subl -0xe4(%rbp), %ecx
shll %cl, %edx
movl -0x20(%rbp), %eax
shll $0x4, %eax
orl %eax, %edx
orl -0xe4(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0xec(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xa37e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa2ec
movl -0x64(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: decode
static int decode(State* s, unsigned tree[], int max) {
    // Find the next prefix code.
    unsigned lo = 0, hi = max, key;
    unsigned search = (rev16(s->bits) << 16) | 0xffff;
    while (lo < hi) {
        unsigned guess = (lo + hi) / 2;
        if (search < tree[guess])
            hi = guess;
        else
            lo = guess + 1;
    }

    // Pull out the key and check it.
    key = tree[lo - 1];
    CHECK(((search ^ key) >> (32 - (key & 0xf))) == 0);

    bits(s, key & 0xf);
    return (key >> 4) & 0xfff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0xa520
shll $0x10, %eax
orl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xa40b
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
shrl %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jae 0xa400
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xa409
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa3d6
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
xorl -0x20(%rbp), %eax
movl -0x20(%rbp), %edx
andl $0xf, %edx
movl $0x20, %ecx
subl %edx, %ecx
shrl %cl, %eax
cmpl $0x0, %eax
je 0xa449
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3100
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
andl $0xf, %esi
callq 0x5dd0
movl -0x20(%rbp), %eax
shrl $0x4, %eax
andl $0xfff, %eax            # imm = 0xFFF
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: run
static void run(State* s, int sym) {
    int length = bits(s, lenBits[sym]) + lenBase[sym];
    int dsym = decode(s, s->distcodes, s->tdist);
    int offs = bits(s, distBits[dsym]) + distBase[dsym];
    copy(s, s->out - offs, length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0xa192(%rip), %rax      # 0x14620
movsbl (%rax,%rcx), %esi
callq 0x5dd0
movslq -0xc(%rbp), %rdx
leaq 0xa19e(%rip), %rcx      # 0x14640
addl (%rcx,%rdx,4), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x570, %rsi            # imm = 0x570
movq -0x8(%rbp), %rax
movl 0x640(%rax), %edx
callq 0xa3a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xa1e8(%rip), %rax      # 0x146c0
movsbl (%rax,%rcx), %esi
callq 0x5dd0
movslq -0x14(%rbp), %rdx
leaq 0xa1f4(%rip), %rcx      # 0x146e0
addl (%rcx,%rdx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movslq -0x18(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movl -0x10(%rbp), %edx
callq 0xa110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: hasGLXExtension
static int hasGLXExtension(Display* display, const char* wanted) {
    const char* extensions = glXQueryExtensionsString(display, DefaultScreen(display));
    char* dup = strdup(extensions);
    char* found = 0;

    for (char* start = dup;; start = 0) {
        found = strtok(start, " ");
        if (found == 0 || strcmp(found, wanted) == 0) {
            break;
        }
    }

    free(dup);
    return found != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xe0(%rax), %esi
callq 0x3550
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3740
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x608b(%rip), %rsi      # 0x107fa
callq 0x3640
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa791
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3590
cmpl $0x0, %eax
jne 0xa793
jmp 0xa79f
jmp 0xa795
movq $0x0, -0x30(%rbp)
jmp 0xa764
movq -0x20(%rbp), %rdi
callq 0x3410
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrInterpretChar
static void tigrInterpretChar(TigrInternal* win, Window root, unsigned int keycode, unsigned int mask) {
    XKeyEvent event;
    memset(&event, 0, sizeof(event));
    event.type = KeyPress;
    event.display = win->dpy;
    event.root = root;
    event.window = win->win;
    event.state = mask;
    event.keycode = keycode;
    char inputTextUTF8[10];
    Status status = 0;
    Xutf8LookupString(win->ic, &event, inputTextUTF8, sizeof(inputTextUTF8), NULL, &status);

    if (status == XLookupChars) {
        tigrDecodeUTF8(inputTextUTF8, &win->lastChar);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x31d0
movl $0x2, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
leaq -0x82(%rbp), %rdx
leaq -0x78(%rbp), %rsi
movl $0xa, %ecx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x88(%rbp), %r9
callq 0x3280
cmpl $0x2, -0x88(%rbp)
jne 0xa93f
leaq -0x82(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8c, %rsi
callq 0x6b40
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: relpath
char *relpath(const char *name, const char *path) {
#ifdef _WIN32
  #define DIR_SEP '\\'
#else
  #define DIR_SEP '/'
#endif
  size_t ln = strlen(name);
  size_t lp = strlen(path);

  while (lp>0 && path[lp] != DIR_SEP) lp--;

  size_t lt = ln + lp + 1;

  char *out = malloc(sizeof(char)*(lt+1));
  strncpy(out, path, lp);
  out[lp] = DIR_SEP;
  strncpy(&out[lp+1], name, ln);
  out[lt] = '\0';

  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3150
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3150
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
jbe 0xa99b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xa9a4
jmp 0xa9b2
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa97a
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x34f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x31b0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x2f, (%rax,%rcx)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
addq $0x1, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x31b0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tipsy.c
// Function: project
Vec project(Vec v0, int snap) {
  float ud = DISTANCE;
  float us = ud-1;
  float vs = fminf(HEIGHT, WIDTH)/2 * SCALE;

  Vec v1 = {(v0.x*us)/(v0.z+ud), (v0.y*us)/(v0.z+ud), (v0.z*us)/(v0.z+ud)};
  Vec v2 = {v1.x*vs+WIDTH/2, v1.y*vs+HEIGHT/2, v1.z+DISTANCE};

  if (snap) { v2.x = floorf(v2.x); v2.y = floorf(v2.y); }

  return v2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
movl %edi, -0x2c(%rbp)
movss 0x5499(%rip), %xmm0     # 0x10784
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
movss 0x3d07(%rip), %xmm1     # 0xf004
subss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movss 0x5482(%rip), %xmm0     # 0x10790
movss 0x3cfe(%rip), %xmm1     # 0xf014
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x548a(%rip), %xmm1     # 0x107b0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x18(%rbp), %xmm0
mulss -0x34(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
addss -0x30(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x14(%rbp), %xmm0
mulss -0x34(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
addss -0x30(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x10(%rbp), %xmm0
mulss -0x34(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
addss -0x30(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x44(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
mulss %xmm1, %xmm0
movss 0x53ec(%rip), %xmm1     # 0x1078c
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x40(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
mulss %xmm1, %xmm0
movss 0x53c9(%rip), %xmm1     # 0x10788
addss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss 0x53b4(%rip), %xmm0     # 0x10784
addss -0x3c(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xb3fe
movss -0xc(%rbp), %xmm0
callq 0x3120
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x3120
movss %xmm0, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movss -0x50(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)