LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/mousefunc.c
// Function: mousefunc_menu_cmd
void
mousefunc_menu_cmd(struct client_ctx *cc, void *arg)
{
	struct screen_ctx	*sc = cc->sc;
	struct menu		*mi;
	struct menu_q		 menuq;
	struct cmd		*cmd;

	TAILQ_INIT(&menuq);
	TAILQ_FOREACH(cmd, &Conf.cmdq, entry) {
		mi = xcalloc(1, sizeof(*mi));
		(void)strlcpy(mi->text, cmd->label, sizeof(mi->text));
		mi->ctx = cmd;
		TAILQ_INSERT_TAIL(&menuq, mi, entry);
	}
	if (TAILQ_EMPTY(&menuq))
		return;

	mi = menu_filter(sc, &menuq, NULL, NULL, 0, NULL, NULL);
	if (mi != NULL)
		u_spawn(((struct cmd *)mi->ctx)->image);
	else
		while ((mi = TAILQ_FIRST(&menuq)) != NULL) {
			TAILQ_REMOVE(&menuq, mi, entry);
			xfree(mi);
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x30(%rdi), %rbx
leaq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
leaq 0x8727(%rip), %rax      # 0x14770
movq 0x30(%rax), %r15
testq %r15, %r15
je 0xc09d
movl $0x1, %edi
movl $0x98, %esi
callq 0x61a8
movq %rax, %r14
leaq 0x20(%rax), %rdi
leaq 0x1014(%r15), %rsi
movl $0x33, %edx
callq 0xd500
movq %r15, 0x88(%r14)
movq $0x0, (%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x18(%rsp)
movq (%r15), %r15
jmp 0xc04d
cmpq $0x0, 0x10(%rsp)
je 0xc109
movq $0x0, (%rsp)
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x74d7
testq %rax, %rax
je 0xc0ff
movq 0x88(%rax), %rdi
addq $0x14, %rdi
callq 0x87a4
jmp 0xc109
movq (%rdi), %rax
testq %rax, %rax
movq %rax, %rcx
cmoveq %r14, %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x61c8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
jne 0xc0de
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/font.c
// Function: font_init
void
font_init(struct screen_ctx *sc, const char *color)
{
	sc->xftdraw = XftDrawCreate(X_Dpy, sc->rootwin,
	    DefaultVisual(X_Dpy, sc->which), DefaultColormap(X_Dpy, sc->which));
	if (sc->xftdraw == NULL)
		errx(1, "XftDrawCreate");

	if (!XftColorAllocName(X_Dpy, DefaultVisual(X_Dpy, sc->which),
	    DefaultColormap(X_Dpy, sc->which), color, &sc->xftcolor))
		errx(1, "XftColorAllocName");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa710(%rip), %r15      # 0x16858
movq (%r15), %rdi
movq 0x18(%r14), %rsi
movq 0xe8(%rdi), %rax
movl 0x10(%r14), %ecx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rdx
movq 0x50(%rax,%rcx), %rcx
callq 0x5840
movq %rax, 0xf8(%r14)
testq %rax, %rax
je 0xc1b1
movq (%r15), %rdi
movq 0xe8(%rdi), %rax
movl 0x10(%r14), %ecx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rsi
movq 0x50(%rax,%rcx), %rdx
addq $0xe8, %r14
movq %rbx, %rcx
movq %r14, %r8
callq 0x5520
testl %eax, %eax
je 0xc1ba
popq %rbx
popq %r14
popq %r15
retq
leaq 0x288d(%rip), %rsi      # 0xea45
jmp 0xc1c1
leaq 0x2892(%rip), %rsi      # 0xea53
movl $0x1, %edi
xorl %eax, %eax
callq 0x5700
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/font.c
// Function: font_make
XftFont *
font_make(struct screen_ctx *sc, const char *name)
{
	XftFont		*fn = NULL;
	FcPattern	*pat, *patx;
	XftResult	 res;

	if ((pat = FcNameParse((const FcChar8*)name)) == NULL)
		return (NULL);

	if ((patx = XftFontMatch(X_Dpy, sc->which, pat, &res)) != NULL)
		fn = XftFontOpenPattern(X_Dpy, patx);

	FcPatternDestroy(pat);

	return (fn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5890
testq %rax, %rax
je 0xc2ae
movq %rax, %rbx
leaq 0xa5d3(%rip), %r15      # 0x16858
movq (%r15), %rdi
movl 0x10(%r14), %esi
leaq 0xc(%rsp), %rcx
movq %rax, %rdx
callq 0x5470
testq %rax, %rax
je 0xc2b3
movq (%r15), %rdi
movq %rax, %rsi
callq 0x56e0
movq %rax, %r14
jmp 0xc2b6
xorl %r14d, %r14d
jmp 0xc2be
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x5030
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/linux.c
// Function: strlcat
size_t
strlcat(char *dst, const char *src, size_t siz)
{
	char *d = dst;
	const char *s = src;
	size_t n = siz;
	size_t dlen;

	/* Find the end of dst and adjust bytes left but don't go past end */
	while (n-- != 0 && *d != '\0')
		d++;
	dlen = d - dst;
	n = siz - dlen;

	if (n == 0)
		return(dlen + strlen(s));
	while (*s != '\0') {
		if (n != 1) {
			*d++ = *s;
			n--;
		}
		s++;
	}
	*d = '\0';

	return(dlen + (s - src));	/* count does not include NUL */
}

// Assembly:
pushq %rbx
movq %rdi, %rcx
testq %rdx, %rdx
je 0xd582
leaq (%rdi,%rdx), %rax
movq %rdx, %r8
movq %rdi, %rcx
cmpb $0x0, (%rcx)
je 0xd582
incq %rcx
decq %r8
jne 0xd572
movq %rax, %rcx
movq %rcx, %rbx
subq %rdi, %rbx
subq %rbx, %rdx
je 0xd5c6
movb (%rsi), %dil
movq %rsi, %rax
testb %dil, %dil
je 0xd5be
movl $0x1, %r8d
cmpq $0x1, %rdx
jne 0xd5a9
movq %r8, %rdx
jmp 0xd5b2
movb %dil, (%rcx)
incq %rcx
decq %rdx
movb 0x1(%rax), %dil
incq %rax
testb %dil, %dil
jne 0xd59e
movb $0x0, (%rcx)
subq %rsi, %rax
jmp 0xd5ce
movq %rsi, %rdi
callq 0x5330
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/zenlinux[P]cwm/linux.c
// Function: strtonum
long long
strtonum(const char *numstr, long long minval, long long maxval,
    const char **errstrp)
{
	long long ll = 0;
	char *ep;
	int error = 0;
	struct errval {
		const char *errstr;
		int err;
	} ev[4] = {
		{ NULL,		0 },
		{ "invalid",	EINVAL },
		{ "too small",	ERANGE },
		{ "too large",	ERANGE },
	};

	ev[0].err = errno;
	errno = 0;
	if (minval > maxval)
		error = INVALID;
	else {
		ll = strtoll(numstr, &ep, 10);
		if (numstr == ep || *ep != '\0')
			error = INVALID;
		else if ((ll == LLONG_MIN && errno == ERANGE) || ll < minval)
			error = TOOSMALL;
		else if ((ll == LLONG_MAX && errno == ERANGE) || ll > maxval)
			error = TOOLARGE;
	}
	if (errstrp != NULL)
		*errstrp = ev[error].errstr;
	errno = ev[error].err;
	if (error)
		ll = 0;

	return (ll);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq $0x0, 0x40(%rsp)
xorl %r15d, %r15d
movl %r15d, 0x8(%rsp)
leaq 0x1432(%rip), %rax      # 0xee8a
leaq 0x60(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, (%rcx)
movq %rsp, %rax
movl $0x16, (%rax)
leaq 0x141d(%rip), %rax      # 0xee92
movq %rax, 0x30(%rsp)
movl $0x22, %eax
movl %eax, 0x18(%rsp)
leaq 0x1412(%rip), %rcx      # 0xee9c
movq %rcx, 0x50(%rsp)
movl %eax, 0x28(%rsp)
callq 0x5590
movq %rax, %r14
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movl %r15d, (%r14)
movq %r12, 0x48(%rsp)
cmpq %r12, %r13
jg 0xdae0
movq %rbx, 0x20(%rsp)
leaq 0x70(%rsp), %rbx
movq %rbp, %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x57d0
movq %rax, %r15
movq (%rbx), %rax
cmpq %rbp, %rax
je 0xdad8
cmpb $0x0, (%rax)
je 0xdb0a
xorl %r15d, %r15d
movq 0x20(%rsp), %rbx
movq %rsp, %rcx
testq %rbx, %rbx
je 0xdaf3
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rbx)
movl (%rcx), %eax
movl %eax, (%r14)
movq %r15, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%rax), %rcx
cmpq %rcx, %r15
jne 0xdb3f
cmpl $0x22, (%r14)
sete %cl
cmpq %r13, %r15
setl %dl
orb %cl, %dl
movq 0x20(%rsp), %rbx
je 0xdb49
leaq 0x18(%rsp), %rcx
leaq 0x30(%rsp), %rax
jmp 0xdb86
cmpq %r13, %r15
movq 0x20(%rsp), %rbx
jl 0xdb33
cmpq %rax, %r15
jne 0xdb75
cmpl $0x22, (%r14)
sete %al
cmpq 0x48(%rsp), %r15
setg %cl
orb %al, %cl
jne 0xdb7c
leaq 0x8(%rsp), %rcx
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xdae3
cmpq 0x48(%rsp), %r15
jle 0xdb61
leaq 0x28(%rsp), %rcx
leaq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
jmp 0xdae3
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/test_svd2.c
// Function: prod2
void
prod2 (double R [4], double A [4], double B [4])
{
  R[0] = A[0]*B[0] + A[2]*B[1] ;
  R[1] = A[1]*B[0] + A[3]*B[1] ;
  R[2] = A[0]*B[2] + A[2]*B[3] ;
  R[3] = A[1]*B[2] + A[3]*B[3] ;
}

// Assembly:
movsd (%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
mulsd 0x8(%rdx), %xmm1
mulsd (%rdx), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
movsd 0x18(%rsi), %xmm1
mulsd 0x8(%rdx), %xmm1
mulsd (%rdx), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rsi), %xmm0
movsd 0x10(%rsi), %xmm1
mulsd 0x18(%rdx), %xmm1
mulsd 0x10(%rdx), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x8(%rsi), %xmm0
movsd 0x18(%rsi), %xmm1
mulsd 0x18(%rdx), %xmm1
mulsd 0x10(%rdx), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/test_svd2.c
// Function: transp2
void
transp2 (double R [4], double A [4])
{
  R[0] = A[0] ;
  R[1] = A[2] ;
  R[2] = A[1] ;
  R[3] = A[3] ;
}

// Assembly:
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/test_svd2.c
// Function: main
int
main (int argc VL_UNUSED, char ** argv VL_UNUSED)
{
  double M [] = {
    0.864397318249258,
    0.094202610858281,
    -0.851909224508774,
    0.873504449150106 } ;
  double S [4] ;
  double U [4] ;
  double V [4] ;

  vl_svd2(S, U, V, M) ;
  check_svd(M, U, S, V) ;

  M[1] = 0 ;

  vl_svd2(S, U, V, M) ;
  check_svd(M, U, S, V) ;

  vl_lapack_dlasv2(S+3, S,
                   V+1, V,
                   U+1, U,
                   M[0], M[2], M[3]) ;
  V[2] = -V[1] ;
  V[3] = V[0] ;
  U[2] = -U[1] ;
  U[3] = U[0] ;
  check_svd(M, U, S, V) ;
  return 0 ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movaps 0xb61(%rip), %xmm0      # 0x20a0
leaq 0x60(%rsp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps 0xb41(%rip), %xmm0      # 0x2090
movaps %xmm0, (%rbx)
leaq 0x40(%rsp), %r14
leaq 0x20(%rsp), %r12
movq %rsp, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1050
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1242
movq $0x0, 0x8(%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1050
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1242
leaq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %rbp
movsd (%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movsd 0x18(%rbx), %xmm2
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %rbp, %r8
movq %r12, %r9
callq 0x1060
movaps 0xa2d(%rip), %xmm0      # 0x2010
movsd (%r13), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, 0x8(%r13)
movsd -0x8(%r13), %xmm1
movsd %xmm1, 0x10(%r13)
movsd (%rbp), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, 0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x10(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1242
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrBitmap2
Tigr* tigrBitmap2(int w, int h, int extra) {
    Tigr* tigr = (Tigr*)calloc(1, sizeof(Tigr) + extra);
    tigr->w = w;
    tigr->h = h;
    tigr->cw = -1;
    tigr->ch = -1;
    tigr->pix = (TPixel*)calloc(w * h, sizeof(TPixel));
    tigr->blitMode = TIGR_BLEND_ALPHA;
    return tigr;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movslq %edx, %rsi
addq $0x30, %rsi
movl $0x1, %edi
callq 0x3270
movq %rax, %r14
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
movq $-0x1, 0x10(%rax)
imull %ebp, %ebx
movslq %ebx, %rdi
movl $0x4, %esi
callq 0x3270
movq %rax, 0x18(%r14)
movl $0x1, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrResize
void tigrResize(Tigr* bmp, int w, int h) {
    if (bmp->w == w && bmp->h == h) {
        return;
    }

    int y, cw, ch;
    TPixel* newpix = (TPixel*)calloc(w * h, sizeof(TPixel));
    cw = (w < bmp->w) ? w : bmp->w;
    ch = (h < bmp->h) ? h : bmp->h;

    // Copy any old data across.
    for (y = 0; y < ch; y++)
        memcpy(newpix + y * w, bmp->pix + y * bmp->w, cw * sizeof(TPixel));

    free(bmp->pix);
    bmp->pix = newpix;
    bmp->w = w;
    bmp->h = h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %r14
movslq (%rdi), %rbx
cmpl %esi, %ebx
jne 0x3964
cmpl %ebp, 0x4(%r14)
je 0x39fd
movl %ebp, %eax
movl %esi, (%rsp)
imull %esi, %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3270
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl 0x4(%r14), %eax
cmpl %ebp, %eax
movl %ebp, 0x4(%rsp)
cmovgel %ebp, %eax
testl %eax, %eax
jle 0x39da
movl (%rsp), %esi
cmpl %esi, %ebx
movl %esi, %ecx
cmovll %ebx, %ecx
movq 0x10(%rsp), %rdx
movq 0x18(%rdx), %r12
movslq %ecx, %r13
shlq $0x2, %r13
movslq %esi, %rbp
movl %eax, %r14d
shlq $0x2, %rbx
shlq $0x2, %rbp
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x32d0
addq %rbx, %r12
addq %rbp, %r15
decq %r14
jne 0x39c1
movq 0x10(%rsp), %rbx
movq 0x18(%rbx), %rdi
callq 0x3410
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rbx)
movl (%rsp), %eax
movl %eax, (%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x4(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrEnforceScale
int tigrEnforceScale(int scale, int flags) {
    if ((flags & TIGR_4X) && scale < 4)
        scale = 4;
    if ((flags & TIGR_3X) && scale < 3)
        scale = 3;
    if ((flags & TIGR_2X) && scale < 2)
        scale = 2;
    return scale;
}

// Assembly:
cmpl $0x5, %edi
movl $0x4, %eax
cmovgel %edi, %eax
testb $0x8, %sil
cmovel %edi, %eax
cmpl $0x4, %eax
movl $0x3, %ecx
cmovgel %eax, %ecx
testb $0x4, %sil
cmovel %eax, %ecx
cmpl $0x3, %ecx
movl $0x2, %eax
cmovgel %ecx, %eax
testb $0x2, %sil
cmovel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrPosition
void tigrPosition(Tigr* bmp, int scale, int windowW, int windowH, int out[4]) {
    // Center the image on screen at this scale.
    out[0] = (windowW - bmp->w * scale) / 2;
    out[1] = (windowH - bmp->h * scale) / 2;
    out[2] = out[0] + bmp->w * scale;
    out[3] = out[1] + bmp->h * scale;
}

// Assembly:
movl (%rdi), %eax
imull %esi, %eax
subl %eax, %edx
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
movl %eax, (%r8)
movl 0x4(%rdi), %edx
imull %esi, %edx
subl %edx, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movl %edx, 0x4(%r8)
movl (%rdi), %ecx
imull %esi, %ecx
addl %eax, %ecx
movl %ecx, 0x8(%r8)
imull 0x4(%rdi), %esi
addl %edx, %esi
movl %esi, 0xc(%r8)
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrClear
void tigrClear(Tigr* bmp, TPixel color) {
    int count = bmp->w * bmp->h;
    int n;
    for (n = 0; n < count; n++)
        bmp->pix[n] = color;
}

// Assembly:
movl 0x4(%rdi), %eax
imull (%rdi), %eax
testl %eax, %eax
jle 0x3ac6
movl %eax, %eax
xorl %ecx, %ecx
movq 0x18(%rdi), %rdx
movl %esi, (%rdx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x3ab7
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrFill
void tigrFill(Tigr* bmp, int x, int y, int w, int h, TPixel color) {
    TPixel* td;
    int dt, i;

    if (x < 0) {
        w += x;
        x = 0;
    }
    if (y < 0) {
        h += y;
        y = 0;
    }
    if (x + w > bmp->w) {
        w = bmp->w - x;
    }
    if (y + h > bmp->h) {
        h = bmp->h - y;
    }
    if (w <= 0 || h <= 0)
        return;

    td = &bmp->pix[y * bmp->w + x];
    dt = bmp->w;
    do {
        for (i = 0; i < w; i++)
            td[i] = color;
        td += dt;
    } while (--h);
}

// Assembly:
pushq %rbx
movl %esi, %r11d
sarl $0x1f, %r11d
andl %esi, %r11d
addl %ecx, %r11d
xorl %ebx, %ebx
testl %esi, %esi
cmovlel %ebx, %esi
testl %edx, %edx
movl $0x0, %r10d
cmovgl %edx, %r10d
cmovsl %edx, %ebx
addl %r8d, %ebx
leal (%r11,%rsi), %ecx
movslq (%rdi), %rax
movl %eax, %r8d
subl %esi, %r8d
cmpl %eax, %ecx
cmovlel %r11d, %r8d
leal (%rbx,%r10), %edx
movl 0x4(%rdi), %r11d
movl %r11d, %ecx
subl %r10d, %ecx
cmpl %r11d, %edx
cmovlel %ebx, %ecx
testl %r8d, %r8d
jle 0x3b4c
testl %ecx, %ecx
jle 0x3b4c
imull %eax, %r10d
addl %esi, %r10d
movslq %r10d, %rdx
shlq $0x2, %rdx
addq 0x18(%rdi), %rdx
movl %r8d, %esi
shlq $0x2, %rax
xorl %edi, %edi
movl %r9d, (%rdx,%rdi,4)
incq %rdi
cmpq %rsi, %rdi
jb 0x3b39
addq %rax, %rdx
decl %ecx
jne 0x3b37
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrLine
void tigrLine(Tigr* bmp, int x0, int y0, int x1, int y1, TPixel color) {
    int sx, sy, dx, dy, err, e2;
    dx = abs(x1 - x0);
    dy = abs(y1 - y0);
    if (x0 < x1)
        sx = 1;
    else
        sx = -1;
    if (y0 < y1)
        sy = 1;
    else
        sy = -1;
    err = dx - dy;

    do {
        tigrPlot(bmp, x0, y0, color);
        e2 = 2 * err;
        if (e2 > -dy) {
            err -= dy;
            x0 += sx;
        }
        if (e2 < dx) {
            err += dx;
            y0 += sy;
        }
    } while (x0 != x1 || y0 != y1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x1c(%rsp)
movq %rdi, 0x20(%rsp)
xorl %eax, %eax
movl %r8d, 0xc(%rsp)
movl %r8d, %r9d
subl %edx, %r9d
setg %al
xorl %edi, %edi
movl %ecx, 0x18(%rsp)
movl %ecx, %r8d
subl %esi, %r8d
setg %dil
movl %r8d, %ebp
negl %ebp
cmovsl %r8d, %ebp
movl %r9d, %r15d
negl %r15d
cmovsl %r9d, %r15d
leal -0x1(,%rdi,2), %ecx
movl %ecx, 0x14(%rsp)
leal -0x1(,%rax,2), %eax
movl %eax, 0x10(%rsp)
movl %ebp, %r14d
subl %r15d, %r14d
movl %r15d, %ebx
negl %ebx
movl %esi, %r12d
movl %edx, %r13d
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %ecx
callq 0x3c26
leal (%r14,%r14), %eax
cmpl %ebx, %eax
movl $0x0, %ecx
cmovgl %r15d, %ecx
movl $0x0, %esi
cmovgl 0x14(%rsp), %esi
movl %r14d, %edi
subl %ecx, %edi
addl %r12d, %esi
cmpl %ebp, %eax
movl $0x0, %edx
cmovll 0x10(%rsp), %edx
movl $0x0, %r14d
cmovll %ebp, %r14d
addl %r13d, %edx
addl %edi, %r14d
cmpl 0x18(%rsp), %esi
jne 0x3bba
cmpl 0xc(%rsp), %edx
jne 0x3bba
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrPlot
void tigrPlot(Tigr* bmp, int x, int y, TPixel pix) {
    int xa, i, a;

    int cx = bmp->cx;
    int cy = bmp->cy;
    int cw = bmp->cw >= 0 ? bmp->cw : bmp->w;
    int ch = bmp->ch >= 0 ? bmp->ch : bmp->h;

    if (x >= cx && y >= cy && x < cx + cw && y < cy + ch) {
        xa = EXPAND(pix.a);
        a = xa * xa;
        i = y * bmp->w + x;

        bmp->pix[i].r += (unsigned char)((pix.r - bmp->pix[i].r) * a >> 16);
        bmp->pix[i].g += (unsigned char)((pix.g - bmp->pix[i].g) * a >> 16);
        bmp->pix[i].b += (unsigned char)((pix.b - bmp->pix[i].b) * a >> 16);
        bmp->pix[i].a += (bmp->blitMode) * (unsigned char)((pix.a - bmp->pix[i].a) * a >> 16);
    }
}

// Assembly:
movl 0x10(%rdi), %eax
testl %eax, %eax
jns 0x3c2f
movl (%rdi), %eax
movl 0x8(%rdi), %r9d
movl 0x14(%rdi), %r8d
testl %r8d, %r8d
jns 0x3c40
movl 0x4(%rdi), %r8d
cmpl %esi, %r9d
jg 0x3d08
movl 0xc(%rdi), %r10d
cmpl %edx, %r10d
jg 0x3d08
addl %r9d, %eax
cmpl %esi, %eax
jle 0x3d08
addl %r10d, %r8d
cmpl %edx, %r8d
jle 0x3d08
pushq %rbx
movl %ecx, %r10d
shrl $0x8, %r10d
movl %ecx, %r9d
shrl $0x10, %r9d
movl %ecx, %eax
shrl $0x18, %eax
cmpl $0x1000000, %ecx        # imm = 0x1000000
movl %eax, %r8d
sbbl $-0x1, %r8d
imull %r8d, %r8d
imull (%rdi), %edx
addl %esi, %edx
movl $0xff, %r11d
andl %r11d, %ecx
movq 0x18(%rdi), %rsi
movslq %edx, %rdx
movzbl (%rsi,%rdx,4), %ebx
subl %ebx, %ecx
imull %r8d, %ecx
shrl $0x10, %ecx
addb %bl, %cl
movb %cl, (%rsi,%rdx,4)
andl %r11d, %r10d
movzbl 0x1(%rsi,%rdx,4), %ecx
subl %ecx, %r10d
imull %r8d, %r10d
shrl $0x10, %r10d
addb %cl, %r10b
movb %r10b, 0x1(%rsi,%rdx,4)
andl %r11d, %r9d
movzbl 0x2(%rsi,%rdx,4), %ecx
subl %ecx, %r9d
imull %r8d, %r9d
shrl $0x10, %r9d
addb %cl, %r9b
movb %r9b, 0x2(%rsi,%rdx,4)
movzbl 0x3(%rsi,%rdx,4), %ecx
subl %ecx, %eax
imull %r8d, %eax
shrl $0x10, %eax
imull 0x28(%rdi), %eax
addb %cl, %al
movb %al, 0x3(%rsi,%rdx,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrFillRect
void tigrFillRect(Tigr* bmp, int x, int y, int w, int h, TPixel color) {
    x += 1;
    y += 1;
    w -= 2;
    h -= 2;

    int cx = bmp->cx;
    int cy = bmp->cy;
    int cw = bmp->cw >= 0 ? bmp->cw : bmp->w;
    int ch = bmp->ch >= 0 ? bmp->ch : bmp->h;

    if (x < cx) {
        w += (x - cx);
        x = cx;
    }
    if (y < cy) {
        h += (y - cy);
        y = cy;
    }
    if (x + w > cx + cw) {
        w -= (x + w) - (cx + cw);
    }
    if (y + h > cy + ch) {
        h -= (y + h) - (cy + ch);
    }
    if (w <= 0 || h <= 0)
        return;

    TPixel* td = &bmp->pix[y * bmp->w + x];
    int dt = bmp->w;
    int xa = EXPAND(color.a);
    int a = xa * xa;

    do {
        for (int i = 0; i < w; i++) {
            td[i].r += (unsigned char)((color.r - td[i].r) * a >> 16);
            td[i].g += (unsigned char)((color.g - td[i].g) * a >> 16);
            td[i].b += (unsigned char)((color.b - td[i].b) * a >> 16);
            td[i].a += (bmp->blitMode) * (unsigned char)((color.a - td[i].a) * a >> 16);
        }
        td += dt;
    } while (--h);
}

// Assembly:
movl 0x10(%rdi), %r11d
testl %r11d, %r11d
jns 0x3d15
movl (%rdi), %r11d
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
incl %esi
incl %edx
addl $-0x2, %ecx
addl $-0x2, %r8d
movl 0x8(%rdi), %ebp
movl 0xc(%rdi), %r10d
movl 0x14(%rdi), %eax
testl %eax, %eax
jns 0x3d37
movl 0x4(%rdi), %eax
xorl %ebx, %ebx
movl %esi, %r14d
subl %ebp, %r14d
cmovgel %ebx, %r14d
cmovlel %ebp, %esi
addl %r14d, %ecx
movl %edx, %r14d
subl %r10d, %r14d
cmovgel %ebx, %r14d
cmovlel %r10d, %edx
addl %r14d, %r8d
leal (%rcx,%rsi), %r14d
addl %ebp, %r11d
subl %r14d, %r11d
cmovgel %ebx, %r11d
addl %ecx, %r11d
leal (%r8,%rdx), %ecx
addl %r10d, %eax
subl %ecx, %eax
cmovgel %ebx, %eax
testl %r11d, %r11d
jle 0x3e61
addl %r8d, %eax
testl %eax, %eax
jle 0x3e61
movl %r9d, %ecx
shrl $0x8, %ecx
movl %r9d, %r8d
shrl $0x10, %r8d
movl %r9d, %r10d
shrl $0x18, %r10d
movslq (%rdi), %rbx
imull %ebx, %edx
addl %esi, %edx
movslq %edx, %rdx
shlq $0x2, %rdx
addq 0x18(%rdi), %rdx
cmpl $0x1000000, %r9d        # imm = 0x1000000
movl %r10d, %esi
sbbl $-0x1, %esi
imull %esi, %esi
movl $0xff, %ebp
andl %ebp, %r9d
andl %ebp, %ecx
andl %ebp, %r8d
movl %r11d, %r11d
movl 0x28(%rdi), %edi
shlq $0x2, %rbx
xorl %r14d, %r14d
movzbl (%rdx,%r14,4), %ebp
movl %r9d, %r15d
subl %ebp, %r15d
imull %esi, %r15d
shrl $0x10, %r15d
addb %bpl, %r15b
movb %r15b, (%rdx,%r14,4)
movzbl 0x1(%rdx,%r14,4), %ebp
movl %ecx, %r15d
subl %ebp, %r15d
imull %esi, %r15d
shrl $0x10, %r15d
addb %bpl, %r15b
movb %r15b, 0x1(%rdx,%r14,4)
movzbl 0x2(%rdx,%r14,4), %ebp
movl %r8d, %r15d
subl %ebp, %r15d
imull %esi, %r15d
shrl $0x10, %r15d
addb %bpl, %r15b
movb %r15b, 0x2(%rdx,%r14,4)
movzbl 0x3(%rdx,%r14,4), %ebp
movl %r10d, %r15d
subl %ebp, %r15d
imull %esi, %r15d
shrl $0x10, %r15d
imull %edi, %r15d
addb %bpl, %r15b
movb %r15b, 0x3(%rdx,%r14,4)
incq %r14
cmpq %r11, %r14
jb 0x3ddc
addq %rbx, %rdx
decl %eax
jne 0x3dd9
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrRect
void tigrRect(Tigr* bmp, int x, int y, int w, int h, TPixel color) {
    int x1, y1;
    if (w <= 0 || h <= 0)
        return;

    x1 = x + w - 1;
    y1 = y + h - 1;
    tigrLine(bmp, x, y, x1, y, color);
    tigrLine(bmp, x1, y, x1, y1, color);
    tigrLine(bmp, x1, y1, x, y1, color);
    tigrLine(bmp, x, y1, x, y, color);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
testl %ecx, %ecx
setle %al
testl %r8d, %r8d
setle %dl
orb %al, %dl
je 0x3e94
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r9d, %ebx
movl %esi, %r15d
movq %rdi, %r12
leal (%r15,%rcx), %ebp
decl %ebp
leal -0x1(%r14,%r8), %r13d
movl %r14d, %edx
movl %ebp, %ecx
movl %r14d, %r8d
callq 0x3b4e
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r13d, %r8d
movl %ebx, %r9d
callq 0x3b4e
movq %r12, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r15d, %ecx
movl %r13d, %r8d
movl %ebx, %r9d
callq 0x3b4e
movq %r12, %rdi
movl %r15d, %esi
movl %r13d, %edx
movl %r15d, %ecx
movl %r14d, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b4e
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrFillCircle
void tigrFillCircle(Tigr* bmp, int x0, int y0, int r, TPixel color) {
    if (r <= 0) {
        return;
    }

    int E = 1 - r;
    int dx = 0;
    int dy = -2 * r;
    int x = 0;
    int y = r;

    tigrLine(bmp, x0 - r + 1, y0, x0 + r, y0, color);

    while (x < y - 1) {
        x++;

        if (E >= 0) {
            y--;
            dy += 2;
            E += dy;
            tigrLine(bmp, x0 - x + 1, y0 + y, x0 + x, y0 + y, color);
            tigrLine(bmp, x0 - x + 1, y0 - y, x0 + x, y0 - y, color);
        }

        dx += 2;
        E += dx + 1;

        if (x != y) {
            tigrLine(bmp, x0 - y + 1, y0 + x, x0 + y, y0 + x, color);
            tigrLine(bmp, x0 - y + 1, y0 - x, x0 + y, y0 - x, color);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, 0x10(%rsp)
movq %rdx, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
testl %ecx, %ecx
jle 0x408f
movl %ecx, %r14d
movq 0x30(%rsp), %rax
movl %eax, %esi
subl %ecx, %esi
incl %esi
leal (%r14,%rax), %ecx
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rdx
movl %edx, %r8d
movl 0x10(%rsp), %r9d
callq 0x3b4e
cmpl $0x1, %r14d
je 0x408f
leal -0x1(%r14), %ebp
leal (%r14,%r14), %esi
negl %esi
movl $0x1, %r15d
movl $0x1, %r12d
subl %r14d, %r12d
xorl %ecx, %ecx
movl $0x3, %edx
testl %r12d, %r12d
movq %rcx, 0x40(%rsp)
movl %edx, 0x14(%rsp)
js 0x3ffc
movl %esi, %eax
addl $0x2, %eax
movl %eax, 0x20(%rsp)
addl %esi, %r12d
addl $0x2, %r12d
movq 0x30(%rsp), %rax
leal (%rax,%rcx), %esi
movl %esi, 0x18(%rsp)
movq 0x38(%rsp), %rbx
leal (%rbp,%rbx), %edx
leal (%rax,%r15), %ecx
movl %ecx, 0xc(%rsp)
movq 0x28(%rsp), %r14
movq %r14, %rdi
movl %edx, %r8d
movl 0x10(%rsp), %r13d
movl %r13d, %r9d
callq 0x3b4e
movl %ebx, %edx
subl %ebp, %edx
movq %r14, %rdi
movl 0x18(%rsp), %esi
movl 0xc(%rsp), %ecx
movl %edx, %r8d
movl %r13d, %r9d
callq 0x3b4e
movl 0x14(%rsp), %edx
movl 0x20(%rsp), %eax
movl %eax, %esi
movl %ebp, %r14d
cmpl %r14d, %r15d
je 0x406e
movq 0x30(%rsp), %rax
movl %eax, %ebp
subl %r14d, %ebp
incl %ebp
movq 0x38(%rsp), %rbx
leal (%rbx,%r15), %edx
leal (%r14,%rax), %ecx
movl %ecx, 0xc(%rsp)
movq %r14, 0x20(%rsp)
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rsi, 0x18(%rsp)
movl %ebp, %esi
movl %edx, %r8d
movl 0x10(%rsp), %r13d
movl %r13d, %r9d
callq 0x3b4e
movq 0x40(%rsp), %rax
leal (%rbx,%rax), %edx
decl %edx
movq %r14, %rdi
movq 0x20(%rsp), %r14
movl %ebp, %esi
movl 0xc(%rsp), %ecx
movl %edx, %r8d
movl %r13d, %r9d
callq 0x3b4e
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
addl %edx, %r12d
leal -0x1(%r14), %ebp
leal 0x1(%r15), %eax
movq 0x40(%rsp), %rcx
decl %ecx
addl $0x2, %edx
cmpl %ebp, %r15d
movl %eax, %r15d
jl 0x3f82
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrClip
void tigrClip(Tigr* bmp, int cx, int cy, int cw, int ch) {
    bmp->cx = cx;
    bmp->cy = cy;
    bmp->cw = cw;
    bmp->ch = ch;
}

// Assembly:
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %r8d, 0x14(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrBlit
void tigrBlit(Tigr* dst, Tigr* src, int dx, int dy, int sx, int sy, int w, int h) {
    int cw = dst->cw >= 0 ? dst->cw : dst->w;
    int ch = dst->ch >= 0 ? dst->ch : dst->h;

    CLIP();

    TPixel* ts = &src->pix[sy * src->w + sx];
    TPixel* td = &dst->pix[dy * dst->w + dx];
    int st = src->w;
    int dt = dst->w;
    do {
        memcpy(td, ts, w * sizeof(TPixel));
        ts += st;
        td += dt;
    } while (--h);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movl 0x10(%rdi), %ebx
testl %ebx, %ebx
jns 0x4303
movl (%rdi), %ebx
movl 0x58(%rsp), %eax
movl 0x50(%rsp), %r15d
movl 0x14(%rdi), %r11d
testl %r11d, %r11d
jns 0x4319
movl 0x4(%rdi), %r11d
movl 0x8(%rdi), %ebp
movq %rdi, 0x10(%rsp)
movl 0xc(%rdi), %r13d
xorl %esi, %esi
movl %ebp, %r10d
subl %edx, %r10d
cmovlel %esi, %r10d
cmovgl %ebp, %edx
subl %r10d, %r15d
addl %r8d, %r10d
movl %r13d, %r12d
subl %ecx, %r12d
cmovlel %esi, %r12d
movl %ecx, (%rsp)
movl %ecx, %edi
cmovgl %r13d, %edi
movl %eax, %ecx
subl %r12d, %ecx
addl %r9d, %r12d
movl %r10d, %r8d
sarl $0x1f, %r8d
andl %r10d, %r8d
addl %r8d, %r15d
testl %r10d, %r10d
cmovlel %esi, %r10d
movl %edx, 0x4(%rsp)
subl %r8d, %edx
movl %r12d, %r14d
sarl $0x1f, %r14d
andl %r12d, %r14d
addl %r14d, %ecx
testl %r12d, %r12d
cmovlel %esi, %r12d
movl %edi, %r9d
subl %r14d, %r9d
addl %ebp, %ebx
movl %ebx, %ebp
subl %edx, %ebp
addl %r15d, %edx
cmpl %ebx, %edx
cmovlel %r15d, %ebp
leal (%r9,%rcx), %edx
addl %r13d, %r11d
movl %r11d, %r15d
subl %r9d, %r15d
cmpl %r11d, %edx
cmovlel %ecx, %r15d
leal (%rbp,%r10), %ecx
movq 0x8(%rsp), %rbx
movslq (%rbx), %r13
movl %r13d, %esi
subl %r10d, %esi
cmpl %r13d, %ecx
cmovlel %ebp, %esi
leal (%r15,%r12), %edx
movl 0x4(%rbx), %ecx
movl %ecx, %ebx
subl %r12d, %ebx
cmpl %ecx, %edx
cmovlel %r15d, %ebx
testl %esi, %esi
jle 0x4460
testl %ebx, %ebx
jle 0x4460
movl %r12d, %r15d
imull %r13d, %r15d
addl (%rsp), %eax
movq 0x10(%rsp), %rdx
movslq (%rdx), %rbp
imull %ebp, %r9d
movl %esi, %ebx
shlq $0x2, %rbx
cmpl %eax, %r11d
cmovll %r11d, %eax
addl %r14d, %eax
addl %r12d, %eax
subl %edi, %eax
cmpl %eax, %ecx
cmovll %ecx, %eax
subl %eax, %r12d
addl %r15d, %r10d
movslq %r10d, %r14
shlq $0x2, %r14
movq 0x8(%rsp), %rax
addq 0x18(%rax), %r14
movl 0x4(%rsp), %eax
addl %r9d, %eax
subl %r8d, %eax
movslq %eax, %r15
shlq $0x2, %r15
addq 0x18(%rdx), %r15
shlq $0x2, %r13
shlq $0x2, %rbp
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x32d0
addq %r13, %r14
addq %rbp, %r15
incl %r12d
jne 0x4447
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrLoadImage
Tigr* tigrLoadImage(const char* fileName) {
    int len;
    void* data;
    Tigr* bmp;

    data = tigrReadFile(fileName, &len);
    if (!data)
        return NULL;

    bmp = tigrLoadImageMem(data, len);
    free(data);
    return bmp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rsi
callq 0x4a72
testq %rax, %rax
je 0x4a64
movq %rax, %rbx
movl 0x4(%rsp), %esi
movq %rax, %rdi
callq 0x4716
movq %rax, %r14
movq %rbx, %rdi
callq 0x3410
jmp 0x4a67
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrReadFile
void* tigrReadFile(const char* fileName, int* length) {
#endif
    // TODO - unicode?
    FILE* file;
    char* data;
    size_t len;

    if (length)
        *length = 0;

    file = fopen(fileName, "rb");
    if (!file)
        return NULL;

    fseek(file, 0, SEEK_END);
    len = ftell(file);
    fseek(file, 0, SEEK_SET);

    data = (char*)malloc(len + 1);
    if (!data) {
        fclose(file);
        return NULL;
    }

    if (fread(data, 1, len, file) != len) {
        free(data);
        fclose(file);
        return NULL;
    }
    data[len] = '\0';
    fclose(file);

    if (length)
        *length = len;

    return data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4a88
movl $0x0, (%rbx)
leaq 0x810b(%rip), %rsi      # 0xcb9a
callq 0x3400
testq %rax, %rax
je 0x4b13
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x33a0
movq %r14, %rdi
callq 0x3030
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33a0
leaq 0x1(%r12), %rdi
callq 0x34f0
testq %rax, %rax
je 0x4b0b
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x3600
cmpq %r12, %rax
jne 0x4b03
movb $0x0, (%r15,%r12)
movq %r14, %rdi
callq 0x3350
testq %rbx, %rbx
je 0x4b16
movl %r12d, (%rbx)
jmp 0x4b16
movq %r15, %rdi
callq 0x3410
movq %r14, %rdi
callq 0x3350
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: putbits
void putbits(Save* s, unsigned data, unsigned bitcount) {
    while (bitcount--) {
        unsigned prev = s->bits;
        s->bits = (s->bits >> 1) | ((data & 1) << 7);
        data >>= 1;
        if (prev & 1) {
            put(s, s->bits);
            s->bits = 0x80;
        }
    }
}

// Assembly:
testl %edx, %edx
je 0x4b6a
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl 0x8(%r14), %eax
movl %eax, %ecx
shrl %ecx
movl %ebp, %edx
shll $0x7, %edx
movzbl %dl, %esi
orl %ecx, %esi
movl %esi, 0x8(%r14)
testb $0x1, %al
je 0x4b5e
movq %r14, %rdi
callq 0x4b6b
movl $0x80, 0x8(%r14)
decl %ebx
shrl %ebp
testl %ebx, %ebx
jne 0x4b34
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: begin
static void begin(Save* s, const char* id, unsigned len) {
    put32(s, len);
    s->crc = 0xffffffff;
    put(s, id[0]);
    put(s, id[1]);
    put(s, id[2]);
    put(s, id[3]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
callq 0x5015
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
movsbl (%rbx), %esi
movq %r14, %rdi
callq 0x4b6b
movsbl 0x1(%rbx), %esi
movq %r14, %rdi
callq 0x4b6b
movsbl 0x2(%rbx), %esi
movq %r14, %rdi
callq 0x4b6b
movsbl 0x3(%rbx), %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b6b
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: put32
static void put32(Save* s, unsigned v) {
    put(s, (v >> 24) & 0xff);
    put(s, (v >> 16) & 0xff);
    put(s, (v >> 8) & 0xff);
    put(s, v & 0xff);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
shrl $0x18, %esi
callq 0x4b6b
movl %ebx, %esi
shrl $0x10, %esi
movl $0xff, %ebp
andl %ebp, %esi
movq %r14, %rdi
callq 0x4b6b
movl %ebx, %esi
shrl $0x8, %esi
andl %ebp, %esi
movq %r14, %rdi
callq 0x4b6b
andl %ebp, %ebx
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x4b6b
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: bits
static int bits(State* s, int n) {
    int v = s->bits & ((1 << n) - 1);
    s->bits >>= n;
    s->count -= n;
    while (s->count < 16) {
        CHECK(s->in != s->inend);
        s->bits |= (*s->in++) << s->count;
        s->count += 8;
    }
    return v;
}

// Assembly:
pushq %rax
movl (%rdi), %eax
movl 0x4(%rdi), %edx
movl %eax, %r8d
movl %esi, %ecx
shrl %cl, %r8d
movl %r8d, (%rdi)
subl %esi, %edx
movl %edx, 0x4(%rdi)
cmpl $0xf, %edx
ja 0x54fe
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r8
cmpq %r8, %rcx
je 0x550d
leaq 0x1(%rcx), %r9
movq %r9, 0x8(%rdi)
movzbl (%rcx), %r10d
movl %edx, %ecx
shll %cl, %r10d
orl %r10d, (%rdi)
leal 0x8(%rdx), %r10d
movl %r10d, 0x4(%rdi)
movq %r9, %rcx
cmpl $0x8, %edx
movl %r10d, %edx
jb 0x54d2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %edx
notl %edx
andl %edx, %eax
popq %rcx
retq
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3100
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: block
static void block(State* s) {
    for (;;) {
        int sym = decode(s, s->litcodes, s->tlit);
        if (sym < 256)
            *emit(s, 1) = (unsigned char)sym;
        else if (sym > 256)
            run(s, sym - 257);
        else
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xf0(%rdi), %r14
leaq 0x570(%rdi), %r15
leaq 0x73a2(%rip), %r13      # 0xc8e0
movl 0x63c(%rbx), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8043
movl %eax, %r12d
cmpl $0xff, %eax
ja 0x5574
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rbx)
cmpq 0x20(%rbx), %rcx
ja 0x55fc
movb %r12b, (%rax)
jmp 0x553e
cmpl $0x100, %r12d           # imm = 0x100
je 0x55ed
addl $0xfffffeff, %r12d      # imm = 0xFFFFFEFF
leaq 0x72b5(%rip), %rax      # 0xc840
movsbl (%r12,%rax), %esi
movq %rbx, %rdi
callq 0x54af
movl %eax, %ebp
leaq 0x72bf(%rip), %rax      # 0xc860
addl (%rax,%r12,4), %ebp
movl 0x640(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8043
movl %eax, %r12d
leaq 0x7760(%rip), %rax      # 0xcd20
movsbl (%r12,%rax), %esi
movq %rbx, %rdi
callq 0x54af
movslq (%r13,%r12,4), %rcx
cltq
addq %rcx, %rax
movq 0x18(%rbx), %rsi
subq %rax, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x7f09
jmp 0x553e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x28, %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3100
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: border
TPixel tigrGet(Tigr* bmp, int x, int y) {
    TPixel empty = { 0, 0, 0, 0 };
    if (x >= 0 && y >= 0 && x < bmp->w && y < bmp->h)
        return bmp->pix[y * bmp->w + x];
    return empty;
}

// Assembly:
movl (%rdi), %ecx
xorl %r8d, %r8d
movl $0x0, %r9d
testl %ecx, %ecx
jle 0x5894
cmpl $0x0, 0x4(%rdi)
jle 0x5894
movq 0x18(%rdi), %rax
movl (%rax), %r9d
movl %edx, %eax
orl %esi, %eax
sets %al
cmpl %esi, %ecx
setle %r10b
orb %al, %r10b
jne 0x58bd
cmpl %edx, 0x4(%rdi)
jle 0x58bd
movq 0x18(%rdi), %rax
movl %ecx, %r8d
imull %edx, %r8d
addl %esi, %r8d
movl (%rax,%r8,4), %r8d
movl $0x1, %eax
cmpl %esi, %ecx
jle 0x58da
xorl %r9d, %r8d
andl $0xffffff, %r8d         # imm = 0xFFFFFF
je 0x58da
xorl %eax, %eax
cmpl %edx, 0x4(%rdi)
setle %al
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrLoadFont
TigrFont* tigrLoadFont(Tigr* bitmap, int codepage) {
    TigrFont* font = (TigrFont*)calloc(1, sizeof(TigrFont));
    font->bitmap = bitmap;
    if (!tigrLoadGlyphs(font, codepage)) {
        tigrFreeFont(font);
        return NULL;
    }
    return font;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x3270
movq %rax, %rbx
movq %r14, (%rax)
movq %rax, %rdi
movl %ebp, %esi
callq 0x560d
testl %eax, %eax
jne 0x5911
movq %rbx, %rdi
callq 0x5919
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrFree
void tigrFree(Tigr* bmp) {
    if (bmp->handle) {
        TigrInternal* win = tigrInternal(bmp);
        if (win->win) {
            glXMakeCurrent(win->dpy, None, NULL);
            glXDestroyContext(win->dpy, win->glc);
            XDestroyWindow(win->dpy, win->win);
            win->win = 0;
        }
    }
    free(bmp->pix);
    free(bmp);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x5978
cmpq $0x0, 0x68(%rbx)
je 0x5978
movq 0x60(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32c0
movq 0x60(%rbx), %rdi
movq 0x70(%rbx), %rsi
callq 0x3250
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rsi
callq 0x3660
movq $0x0, 0x68(%rbx)
movq 0x18(%rbx), %rdi
callq 0x3410
movq %rbx, %rdi
popq %rbx
jmp 0x3410
// File: /workspace/github_c_makefile_star2_O1/nkanaev[P]tipsy/src/tigr.c
// Function: tigrPrint
void tigrPrint(Tigr* dest, TigrFont* font, int x, int y, TPixel color, const char* text, ...) {
    char tmp[1024];
    TigrGlyph* g;
    va_list args;
    const char* p;
    int start = x, c;

    tigrSetupFont(font);

    // Expand the formatting string.
    va_start(args, text);
    vsnprintf(tmp, sizeof(tmp), text, args);
    tmp[sizeof(tmp) - 1] = 0;
    va_end(args);

    // Print each glyph.
    p = tmp;
    while (*p) {
        p = tigrDecodeUTF8(p, &c);
        if (c == '\r')
            continue;
        if (c == '\n') {
            x = start;
            y += tigrTextHeight(font, "");
            continue;
        }
        g = get(font, c);
        tigrBlitTint(dest, font->bitmap, x, y, g->x, g->y, g->w, g->h, color);
        x += g->w;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4f8, %rsp            # imm = 0x4F8
movq %r9, %rbx
movq %r8, 0x18(%rsp)
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
testb %al, %al
je 0x5a33
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsi, %rdi
callq 0x598a
leaq 0x40(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x530(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000030, %rax     # imm = 0x3000000030
movq %rax, (%rcx)
leaq 0xf0(%rsp), %r13
movl $0x400, %esi            # imm = 0x400
movq %r13, %rdi
movq %rbx, %rdx
callq 0x3230
movb $0x0, 0x3ff(%r13)
leaq 0xc(%rsp), %rbx
movl %r12d, %r14d
cmpb $0x0, (%r13)
je 0x5b0d
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5b1f
movq %rax, %r13
movl 0xc(%rsp), %esi
cmpl $0xd, %esi
je 0x5a8a
movq %r15, %rdi
cmpl $0xa, %esi
je 0x5afa
callq 0x5c46
movl %r12d, 0x8(%rsp)
movq %rax, %r12
movq (%r15), %rsi
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
movl 0xc(%rax), %eax
movl 0x10(%r12), %r10d
subq $0x8, %rsp
movq 0x18(%rsp), %rdi
movl %r14d, %edx
movl %ebp, %ecx
pushq 0x20(%rsp)
pushq %r10
pushq %rax
callq 0x446f
addq $0x20, %rsp
addl 0xc(%r12), %r14d
movl 0x8(%rsp), %r12d
jmp 0x5a8a
leaq 0x70a4(%rip), %rsi      # 0xcba5
callq 0x5bd7
addl %eax, %ebp
jmp 0x5a87
addq $0x4f8, %rsp            # imm = 0x4F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movzbl (%rdi), %edx
movl $0x0, (%rsi)
cmpl $0xf0, %edx
jb 0x5b42
andl $0x7, %edx
movl $0x10000, %ecx          # imm = 0x10000
movl $0x2, %edi
jmp 0x5b54
cmpb $-0x20, %dl
jb 0x5bad
andl $0xf, %edx
movl $0x800, %ecx            # imm = 0x800
movl $0x1, %edi
xorl %r8d, %r8d
movl %edx, (%rsi)
testb %r8b, %r8b
je 0x5b63
incq %rax
jmp 0x5ba2
incl %edi
addq $0x2, %rax
movq %rax, %rdx
movq %rdx, %rax
movzbl -0x1(%rdx), %edx
movl %edx, %r8d
andl $-0x40, %r8d
cmpl $0x80, %r8d
jne 0x5b9c
movl (%rsi), %r8d
shll $0x6, %r8d
andl $0x3f, %edx
orl %r8d, %edx
movl %edx, (%rsi)
leaq 0x1(%rax), %rdx
decl %edi
jne 0x5b6c
jmp 0x5ba2
movl $0xfffd, (%rsi)         # imm = 0xFFFD
cmpl %ecx, (%rsi)
jge 0x5bac
movl $0xfffd, (%rsi)         # imm = 0xFFFD
retq
cmpb $-0x40, %dl
jb 0x5bc1
andl $0x1f, %edx
movl $0x80, %ecx
xorl %r8d, %r8d
xorl %edi, %edi
jmp 0x5b57
testb %dl, %dl
movl $0xfffd, %ecx           # imm = 0xFFFD
cmovsl %ecx, %edx
xorl %ecx, %ecx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movb $0x1, %r8b
jmp 0x5b57
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x598a
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x5c46
movl 0x10(%rax), %r12d
cmpb $0x0, (%rbx)
je 0x5c34
leaq 0xc(%rsp), %r14
movl %r12d, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b1f
movq %rax, %rbx
cmpl $0xa, 0xc(%rsp)
jne 0x5c2d
cmpb $0x0, (%rbx)
movl %r12d, %eax
cmovel %r15d, %eax
addl %eax, %ebp
cmpb $0x0, (%rbx)
jne 0x5c0c
jmp 0x5c37
movl %r12d, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
je 0x5c75
movq 0x10(%rdi), %rdx
xorl %eax, %eax
leal (%rcx,%rax), %r8d
shrl %r8d
leaq (%r8,%r8,4), %r9
cmpl %esi, (%rdx,%r9,4)
jg 0x5c6c
incl %r8d
movl %r8d, %eax
jmp 0x5c6f
movl %r8d, %ecx
cmpl %ecx, %eax
jb 0x5c53
jmp 0x5c77
xorl %eax, %eax
testl %eax, %eax
je 0x5c8f
movq 0x10(%rdi), %rcx
decl %eax
leaq (%rax,%rax,4), %rax
cmpl %esi, (%rcx,%rax,4)
jne 0x5c8f
leaq (%rcx,%rax,4), %rax
retq
movl $0x26c, %eax            # imm = 0x26C
addq 0x10(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x598a
cmpb $0x0, (%r14)
je 0x5cfc
xorl %ebp, %ebp
leaq 0xc(%rsp), %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5b1f
movq %rax, %r14
movl 0xc(%rsp), %esi
cmpl $0xa, %esi
je 0x5cdc
cmpl $0xd, %esi
jne 0x5ce1
xorl %r12d, %r12d
jmp 0x5cf4
movq %rbx, %rdi
callq 0x5c46
addl 0xc(%rax), %r12d
cmpl %ebp, %r12d
cmovgl %r12d, %ebp
cmpb $0x0, (%r14)
jne 0x5cc0
jmp 0x5cfe
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
cmpl $0x100, %esi            # imm = 0x100
jge 0x6724
cmpq $0x0, 0x20(%rdi)
je 0x6743
movslq %esi, %rcx
cmpb $0x0, 0xc0(%rdi,%rcx)
je 0x6720
xorl %eax, %eax
cmpb $0x0, 0x1c0(%rdi,%rcx)
sete %al
jmp 0x6722
xorl %eax, %eax
popq %rcx
retq
leaq 0x6344(%rip), %rdi      # 0xca6f
leaq 0x62da(%rip), %rsi      # 0xca0c
leaq 0x6340(%rip), %rcx      # 0xca79
movl $0x1203, %edx           # imm = 0x1203
callq 0x3260
leaq 0x62b6(%rip), %rdi      # 0xca00
leaq 0x62bb(%rip), %rsi      # 0xca0c
leaq 0x62bf(%rip), %rcx      # 0xca17
movl $0x741, %edx            # imm = 0x741
callq 0x3260
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x20(%rdi)
je 0x67d5
movl 0xbc(%rdi), %eax
movl $0x0, 0xbc(%rdi)
retq
pushq %rax
leaq 0x6223(%rip), %rdi      # 0xca00
leaq 0x6228(%rip), %rsi      # 0xca0c
leaq 0x622c(%rip), %rcx      # 0xca17
movl $0x741, %edx            # imm = 0x741
callq 0x3260