LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/src/test_svd2.c
// Function: check_svd
void
check_svd (double *M , double * U, double * S, double *V)
{
  double T1 [4] ;
  double T2 [4] ;

  print_matrix("M",M) ;
  print_matrix("U",U) ;
  print_matrix("S",S) ;
  print_matrix("V",V) ;

  transp2(T1, V) ;
  prod2(T2, S, T1) ;
  prod2(T1, U, T2) ;
  print_matrix("USV'",T1) ;

  transp2(T1, U) ;
  prod2(T2, T1, U) ;
  print_matrix("U'U",T2) ;

  transp2(T1, V) ;
  prod2(T2, T1, V) ;
  print_matrix("V'V",T2) ;

  printf("det(M) = %f\n", det2(M)) ;
  printf("det(U) = %f\n", det2(U)) ;
  printf("det(V) = %f\n", det2(V)) ;
  printf("det(S) = %f\n", det2(S)) ;
  printf("\n") ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xde0(%rip), %rdi       # 0x2043
movq %r12, %rsi
callq 0x116c
leaq 0xddc(%rip), %rdi       # 0x204e
movq %r15, %rsi
callq 0x116c
leaq 0xdc4(%rip), %rdi       # 0x2045
movq %rbx, %rsi
callq 0x116c
leaq 0xdc2(%rip), %rdi       # 0x2052
movq %r14, %rsi
callq 0x116c
movsd (%r14), %xmm0
leaq 0x20(%rsp), %r13
movsd %xmm0, (%r13)
movups 0x8(%r14), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x8(%r13)
movsd 0x18(%r14), %xmm0
movsd %xmm0, 0x18(%r13)
movq %rsp, %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1193
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1193
leaq 0xd5f(%rip), %rdi       # 0x2047
movq %r13, %rsi
callq 0x116c
movsd (%r15), %xmm0
movsd %xmm0, (%r13)
movups 0x8(%r15), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x8(%r13)
movsd 0x18(%r15), %xmm0
movsd %xmm0, 0x18(%r13)
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1193
leaq 0xd22(%rip), %rdi       # 0x204c
movq %rbp, %rsi
callq 0x116c
movsd (%r14), %xmm0
movsd %xmm0, (%r13)
movups 0x8(%r14), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x8(%r13)
movsd 0x18(%r14), %xmm0
movsd %xmm0, 0x18(%r13)
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1193
leaq 0xce4(%rip), %rdi       # 0x2050
movq %rbp, %rsi
callq 0x116c
movsd 0x10(%r12), %xmm1
mulsd 0x8(%r12), %xmm1
movsd (%r12), %xmm0
mulsd 0x18(%r12), %xmm0
subsd %xmm1, %xmm0
leaq 0xcba(%rip), %rdi       # 0x2054
movb $0x1, %al
callq 0x1040
movsd 0x10(%r15), %xmm1
mulsd 0x8(%r15), %xmm1
movsd (%r15), %xmm0
mulsd 0x18(%r15), %xmm0
subsd %xmm1, %xmm0
leaq 0xc9e(%rip), %rdi       # 0x2061
movb $0x1, %al
callq 0x1040
movsd 0x10(%r14), %xmm1
mulsd 0x8(%r14), %xmm1
movsd (%r14), %xmm0
mulsd 0x18(%r14), %xmm0
subsd %xmm1, %xmm0
leaq 0xc82(%rip), %rdi       # 0x206e
movb $0x1, %al
callq 0x1040
movsd 0x10(%rbx), %xmm1
mulsd 0x8(%rbx), %xmm1
movsd (%rbx), %xmm0
mulsd 0x18(%rbx), %xmm0
subsd %xmm1, %xmm0
leaq 0xc6a(%rip), %rdi       # 0x207b
movb $0x1, %al
callq 0x1040
pushq $0xa
popq %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0xc5a(%rip), %xmm0      # 0x20a0
leaq 0x60(%rsp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps 0xc3a(%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
andq $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 0xb29(%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_O2/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
pushq $0x1
popq %rdi
callq 0x3270
movq %rax, %r14
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
orq $-0x1, 0x10(%rax)
imull %ebp, %ebx
movslq %ebx, %rdi
pushq $0x4
popq %rsi
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_O2/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
movslq (%rdi), %r15
movl %r15d, %eax
xorl %esi, %eax
movq %rdi, 0x8(%rsp)
movl 0x4(%rdi), %ebx
movl %ebx, %ecx
xorl %edx, %ecx
orl %eax, %ecx
je 0x3a08
movl %edx, %ebp
movl %esi, %r14d
movl %edx, %eax
imull %esi, %eax
movslq %eax, %rdi
pushq $0x4
popq %rsi
callq 0x3270
movq %rax, %r13
cmpl %r14d, %r15d
movl %r14d, %eax
cmovll %r15d, %eax
cmpl %ebp, %ebx
movl %ebp, 0x4(%rsp)
cmovgel %ebp, %ebx
movslq %eax, %r12
shlq $0x2, %r12
xorl %ebp, %ebp
testl %ebx, %ebx
cmovlel %ebp, %ebx
movl %r14d, (%rsp)
movslq %r14d, %r14
shlq $0x2, %r14
shlq $0x2, %r15
movq %r13, 0x10(%rsp)
subq $0x1, %rbx
jb 0x39e5
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
addq %rbp, %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x32e0
addq %r14, %r13
addq %r15, %rbp
jmp 0x39c0
movq 0x8(%rsp), %rbx
movq 0x18(%rbx), %rdi
callq 0x3430
movq 0x10(%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_O2/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
pushq $0x4
popq %rax
cmovgel %edi, %eax
testb $0x8, %sil
cmovel %edi, %eax
cmpl $0x4, %eax
pushq $0x3
popq %rcx
cmovgel %eax, %ecx
testb $0x4, %sil
cmovel %eax, %ecx
cmpl $0x3, %ecx
pushq $0x2
popq %rax
cmovgel %ecx, %eax
testb $0x2, %sil
cmovel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %edx, %eax
movl (%rdi), %edx
imull %esi, %edx
subl %edx, %eax
pushq $0x2
popq %r10
cltd
idivl %r10d
movl %eax, %r9d
movl %eax, (%r8)
movl 0x4(%rdi), %eax
imull %esi, %eax
subl %eax, %ecx
movl %ecx, %eax
cltd
idivl %r10d
movl %eax, 0x4(%r8)
movl (%rdi), %ecx
imull %esi, %ecx
addl %r9d, %ecx
movl %ecx, 0x8(%r8)
imull 0x4(%rdi), %esi
addl %eax, %esi
movl %esi, 0xc(%r8)
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x3acc
movq 0x18(%rdi), %rdx
movl %esi, (%rdx,%rcx,4)
incq %rcx
jmp 0x3abb
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3b54
testl %ecx, %ecx
jle 0x3b54
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
cmpq %rdi, %rsi
je 0x3b4d
movl %r9d, (%rdx,%rdi,4)
incq %rdi
jmp 0x3b3f
addq %rax, %rdx
decl %ecx
jne 0x3b3d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c2e
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 0x3bc2
cmpl 0xc(%rsp), %edx
jne 0x3bc2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c37
movl (%rdi), %eax
movl 0x8(%rdi), %r9d
movl 0x14(%rdi), %r8d
testl %r8d, %r8d
jns 0x3c48
movl 0x4(%rdi), %r8d
cmpl %esi, %r9d
jg 0x3d10
movl 0xc(%rdi), %r10d
cmpl %edx, %r10d
jg 0x3d10
addl %r9d, %eax
cmpl %esi, %eax
jle 0x3d10
addl %r10d, %r8d
cmpl %edx, %r8d
jle 0x3d10
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_O2/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 0x3d1d
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 0x3d3f
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 0x3e69
addl %r8d, %eax
testl %eax, %eax
jle 0x3e69
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
shlq $0x2, %rbx
xorl %r14d, %r14d
cmpq %r14, %r11
je 0x3e5e
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 0x28(%rdi), %r15d
addb %bpl, %r15b
movb %r15b, 0x3(%rdx,%r14,4)
incq %r14
jmp 0x3de1
addq %rbx, %rdx
decl %eax
jne 0x3dde
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3e9c
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 0x3b56
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r13d, %r8d
movl %ebx, %r9d
callq 0x3b56
movq %r12, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r15d, %ecx
movl %r13d, %r8d
movl %ebx, %r9d
callq 0x3b56
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 0x3b56
// File: /workspace/github_c_makefile_star2_O2/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 $0x58, %rsp
movl %r8d, 0x4(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdi, 0x10(%rsp)
testl %ecx, %ecx
jle 0x40be
movl %ecx, %r13d
pushq $0x1
popq %r15
subl %ecx, %r15d
leal (,%r13,2), %eax
negl %eax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
leal 0x1(%rax), %ecx
movq %rcx, 0x50(%rsp)
movl %ecx, %esi
subl %r13d, %esi
leal (%rax,%r13), %ecx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rbx
movl %ebx, %edx
movl %ebx, %r8d
movl 0x4(%rsp), %r9d
callq 0x3b56
leal 0x1(%rbx), %ebp
xorl %eax, %eax
pushq $-0x1
popq %rcx
xorl %r8d, %r8d
leal -0x1(%r13), %r14d
cmpl %r14d, %r8d
jge 0x40be
testl %r15d, %r15d
movq %rax, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
js 0x4033
movq 0x8(%rsp), %rdx
movl %edx, %r12d
addl $0x2, %r12d
addl %edx, %r15d
addl $0x2, %r15d
movq %r15, 0x38(%rsp)
movq 0x50(%rsp), %rax
leal (%rax,%rcx), %esi
movl %esi, 0x8(%rsp)
movl %ebp, 0x2c(%rsp)
movq 0x18(%rsp), %rbp
leal (%r14,%rbp), %edx
leal (%rax,%r8), %r15d
movq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r8, 0x20(%rsp)
movl %r15d, %ecx
movl %edx, %r8d
movl 0x4(%rsp), %ebx
movl %ebx, %r9d
callq 0x3b56
movl %ebp, %edx
movl 0x2c(%rsp), %ebp
subl %r14d, %edx
movq %r13, %rdi
movl 0x8(%rsp), %esi
movl %r15d, %ecx
movl %edx, %r8d
movl %ebx, %r9d
callq 0x3b56
movq 0x20(%rsp), %r8
movq 0x40(%rsp), %rax
movl %r12d, %ecx
movq %rcx, 0x8(%rsp)
movl %r14d, %r13d
jmp 0x4038
movq %r15, 0x38(%rsp)
incl %r8d
cmpl %r13d, %r8d
je 0x40a1
movq 0x30(%rsp), %rax
movl %eax, %r15d
subl %r13d, %r15d
incl %r15d
leal (%rax,%r13), %r14d
movq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r8, 0x20(%rsp)
movl %r15d, %esi
movl %ebp, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl 0x4(%rsp), %ebx
movl %ebx, %r9d
callq 0x3b56
movq 0x18(%rsp), %rax
movq 0x48(%rsp), %rcx
leal (%rax,%rcx), %edx
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %ecx
movl %edx, %r8d
movl %ebx, %r9d
callq 0x3b56
movq 0x20(%rsp), %r8
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %r15
addl %eax, %r15d
addl $0x3, %r15d
incl %ebp
movq 0x48(%rsp), %rcx
decl %ecx
addl $0x2, %eax
jmp 0x3f8a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %r9d, %r14d
movq %rsi, 0x8(%rsp)
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
jns 0x4313
movl (%rdi), %ebp
movl 0x58(%rsp), %eax
movl 0x50(%rsp), %r15d
movl 0x14(%rdi), %r10d
testl %r10d, %r10d
jns 0x4329
movl 0x4(%rdi), %r10d
movl 0x8(%rdi), %r11d
xorl %r9d, %r9d
movl %r11d, %ebx
subl %edx, %ebx
cmovlel %r9d, %ebx
cmovgl %r11d, %edx
movq %rdi, 0x10(%rsp)
movl 0xc(%rdi), %r13d
subl %ebx, %r15d
addl %r8d, %ebx
movl %r13d, %r12d
subl %ecx, %r12d
cmovlel %r9d, %r12d
movl %ecx, 0x4(%rsp)
movl %ecx, %esi
cmovgl %r13d, %esi
movl %eax, %ecx
subl %r12d, %ecx
addl %r14d, %r12d
movl %ebx, %r8d
sarl $0x1f, %r8d
andl %ebx, %r8d
leal (%r8,%r15), %edi
testl %ebx, %ebx
cmovlel %r9d, %ebx
movl %r12d, %r14d
sarl $0x1f, %r14d
andl %r12d, %r14d
testl %r12d, %r12d
cmovlel %r9d, %r12d
movl %esi, %r9d
subl %r14d, %r9d
addl %edx, %r15d
addl %r11d, %ebp
movl %r8d, %r11d
subl %edx, %r11d
addl %ebp, %r11d
cmpl %ebp, %r15d
cmovlel %edi, %r11d
leal (%r14,%rcx), %edi
addl %esi, %ecx
addl %r13d, %r10d
movl %r10d, %r15d
subl %r9d, %r15d
cmpl %r10d, %ecx
cmovlel %edi, %r15d
leal (%r11,%rbx), %edi
movq 0x8(%rsp), %rbp
movslq (%rbp), %r13
movl %r13d, %ecx
subl %ebx, %ecx
cmpl %r13d, %edi
cmovlel %r11d, %ecx
leal (%r15,%r12), %edi
movl 0x4(%rbp), %r11d
movl %r11d, %ebp
subl %r12d, %ebp
cmpl %r11d, %edi
cmovlel %r15d, %ebp
testl %ecx, %ecx
jle 0x4470
testl %ebp, %ebp
jle 0x4470
movl %r12d, %r15d
imull %r13d, %r15d
addl %ebx, %r15d
addl 0x4(%rsp), %eax
movq 0x10(%rsp), %rdi
movslq (%rdi), %rbp
imull %ebp, %r9d
movl %ecx, %ebx
shlq $0x2, %rbx
cmpl %eax, %r10d
cmovll %r10d, %eax
addl %r14d, %eax
addl %r12d, %eax
subl %esi, %eax
cmpl %eax, %r11d
cmovll %r11d, %eax
subl %eax, %r12d
movslq %r15d, %r14
shlq $0x2, %r14
movq 0x8(%rsp), %rax
addq 0x18(%rax), %r14
addl %r9d, %edx
subl %r8d, %edx
movslq %edx, %r15
shlq $0x2, %r15
addq 0x18(%rdi), %r15
shlq $0x2, %r13
shlq $0x2, %rbp
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x32e0
addq %r13, %r14
addq %rbp, %r15
incl %r12d
jne 0x4457
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e59
testq %rax, %rax
je 0x4e4b
movq %rax, %rbx
movl 0x4(%rsp), %esi
movq %rax, %rdi
callq 0x472c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3430
jmp 0x4e4e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e6c
andl $0x0, (%rbx)
leaq 0x6d07(%rip), %rsi      # 0xbb7a
callq 0x3420
testq %rax, %rax
je 0x4ef3
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x33b0
movq %r14, %rdi
callq 0x3030
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33b0
leaq 0x1(%r12), %rdi
callq 0x3510
testq %rax, %rax
je 0x4eeb
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x3620
cmpq %r12, %rax
jne 0x4ee3
movb $0x0, (%r15,%r12)
movq %r14, %rdi
callq 0x3360
testq %rbx, %rbx
je 0x4ef6
movl %r12d, (%rbx)
jmp 0x4ef6
movq %r15, %rdi
callq 0x3430
movq %r14, %rdi
callq 0x3360
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
subl $0x1, %ebx
jb 0x4f43
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)
shrl %ebp
testb $0x1, %al
je 0x4f10
movq %r14, %rdi
callq 0x4f48
movl $0x80, 0x8(%r14)
jmp 0x4f10
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x52b4
orl $-0x1, (%r14)
movsbl (%rbx), %esi
movq %r14, %rdi
callq 0x4f48
movsbl 0x1(%rbx), %esi
movq %r14, %rdi
callq 0x4f48
movsbl 0x2(%rbx), %esi
movq %r14, %rdi
callq 0x4f48
movsbl 0x3(%rbx), %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f48
// File: /workspace/github_c_makefile_star2_O2/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 0x4f48
movl %ebx, %esi
shrl $0x10, %esi
movl $0xff, %ebp
andl %ebp, %esi
movq %r14, %rdi
callq 0x4f48
movl %ebx, %esi
shrl $0x8, %esi
andl %ebp, %esi
movq %r14, %rdi
callq 0x4f48
andl %ebp, %ebx
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f48
// File: /workspace/github_c_makefile_star2_O2/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 %eax, %edx
movl %esi, %ecx
shrl %cl, %edx
movl 0x4(%rdi), %ecx
movl %edx, (%rdi)
subl %esi, %ecx
movl %ecx, 0x4(%rdi)
cmpl $0xf, %ecx
ja 0x5713
movq 0x8(%rdi), %r8
cmpq 0x10(%rdi), %r8
je 0x5720
leaq 0x1(%r8), %r9
movq %r9, 0x8(%rdi)
movzbl (%r8), %r8d
shll %cl, %r8d
orl %r8d, %edx
movl %edx, (%rdi)
addl $0x8, %ecx
jmp 0x56e8
pushq $-0x1
popq %rdx
movl %esi, %ecx
shll %cl, %edx
notl %edx
andl %edx, %eax
popq %rcx
retq
addq $0x28, %rdi
pushq $0x1
popq %rsi
callq 0x3100
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbp
movl 0x63c(%rbx), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x79b8
movl %eax, %r12d
cmpl $0xff, %eax
ja 0x5775
movq %rbx, %rdi
movl %ebp, %esi
callq 0x78a3
movb %r12b, (%rax)
jmp 0x574b
cmpl $0x100, %r12d           # imm = 0x100
je 0x57f6
addl $0xfffffeff, %r12d      # imm = 0xFFFFFEFF
leaq 0x60b4(%rip), %rax      # 0xb840
movsbl (%r12,%rax), %esi
movq %rbx, %rdi
callq 0x56d8
movl %eax, %r13d
leaq 0x60bd(%rip), %rax      # 0xb860
addl (%rax,%r12,4), %r13d
movl 0x640(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79b8
movl %eax, %r12d
leaq 0x653e(%rip), %rax      # 0xbd00
movsbl (%r12,%rax), %esi
movq %rbx, %rdi
callq 0x56d8
leaq 0x610a(%rip), %rcx      # 0xb8e0
movslq (%rcx,%r12,4), %rcx
cltq
addq %rcx, %rax
movq 0x18(%rbx), %rsi
subq %rax, %rsi
movq %rbx, %rdi
movl %r13d, %edx
callq 0x7878
jmp 0x574b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x3270
movq %rax, %rbx
movq %r14, (%rax)
movq %rax, %rdi
movl %ebp, %esi
callq 0x5805
testl %eax, %eax
jne 0x5ad4
movq %rbx, %rdi
callq 0x5adc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x5b46
movq %rbx, %rdi
callq 0x5e9d
cmpq $0x0, 0x38(%rax)
je 0x5b46
movq %rax, %r14
movq 0x30(%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32d0
movq 0x30(%r14), %rdi
movq 0x40(%r14), %rsi
callq 0x3250
movq 0x30(%r14), %rdi
movq 0x38(%r14), %rsi
callq 0x3680
andq $0x0, 0x38(%r14)
movq 0x18(%rbx), %rdi
callq 0x3430
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3430
// File: /workspace/github_c_makefile_star2_O2/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 0x5c07
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 0x5b5e
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 0x5ce1
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5cf3
movq %rax, %r13
movl 0xc(%rsp), %esi
cmpl $0xd, %esi
je 0x5c5e
movq %r15, %rdi
cmpl $0xa, %esi
je 0x5cce
callq 0x5deb
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 0x447f
addq $0x20, %rsp
addl 0xc(%r12), %r14d
movl 0x8(%rsp), %r12d
jmp 0x5c5e
leaq 0x5eb0(%rip), %rsi      # 0xbb85
callq 0x5d84
addl %eax, %ebp
jmp 0x5c5b
addq $0x4f8, %rsp            # imm = 0x4F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %ecx
cmpl $0xf0, %ecx
jb 0x5d0d
andl $0x7, %ecx
movl $0x10000, %edx          # imm = 0x10000
pushq $0x3
jmp 0x5d2d
cmpb $-0x20, %cl
jb 0x5d1e
andl $0xf, %ecx
movl $0x800, %edx            # imm = 0x800
pushq $0x2
jmp 0x5d2d
cmpb $-0x40, %cl
jb 0x5d74
andl $0x1f, %ecx
movl $0x80, %edx
pushq $0x1
popq %rdi
incq %rax
movl %ecx, (%rsi)
subl $0x1, %edi
jb 0x5d69
movzbl (%rax), %r8d
movl %r8d, %r9d
andl $-0x40, %r9d
cmpl $0x80, %r9d
jne 0x5d5b
incq %rax
shll $0x6, %ecx
andl $0x3f, %r8d
orl %r8d, %ecx
jmp 0x5d31
movl $0xfffd, (%rsi)         # imm = 0xFFFD
incq %rax
movl $0xfffd, %ecx           # imm = 0xFFFD
cmpl %edx, %ecx
jge 0x5d73
movl $0xfffd, (%rsi)         # imm = 0xFFFD
retq
testb %cl, %cl
movl $0xfffd, %edx           # imm = 0xFFFD
cmovsl %edx, %ecx
xorl %edi, %edi
xorl %edx, %edx
jmp 0x5d2e
// File: /workspace/github_c_makefile_star2_O2/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 0x5b5e
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x5deb
movl 0x10(%rax), %r12d
leaq 0xc(%rsp), %r14
movl %r12d, %ebp
cmpb $0x0, (%rbx)
je 0x5ddc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5cf3
movq %rax, %rbx
cmpl $0xa, 0xc(%rsp)
jne 0x5db4
cmpb $0x0, (%rbx)
movl %r12d, %eax
cmovel %r15d, %eax
addl %eax, %ebp
jmp 0x5db4
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %eax
xorl %ecx, %ecx
cmpl %eax, %ecx
jae 0x5e11
leal (%rax,%rcx), %edx
shrl %edx
movq 0x10(%rdi), %r8
imulq $0x14, %rdx, %r9
cmpl %esi, (%r8,%r9)
jg 0x5e0d
incl %edx
movl %edx, %ecx
jmp 0x5df0
movl %edx, %eax
jmp 0x5df0
movq 0x10(%rdi), %rax
testl %ecx, %ecx
je 0x5e28
decl %ecx
imulq $0x14, %rcx, %rcx
cmpl %esi, (%rax,%rcx)
jne 0x5e28
addq %rcx, %rax
retq
addq $0x26c, %rax            # imm = 0x26C
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5b5e
xorl %eax, %eax
leaq 0xc(%rsp), %r15
xorl %ebp, %ebp
cmpb $0x0, (%r14)
je 0x5e8e
movl %eax, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x5cf3
movq %rax, %r14
xorl %eax, %eax
movl 0xc(%rsp), %esi
cmpl $0xa, %esi
je 0x5e4f
cmpl $0xd, %esi
je 0x5e4f
movq %rbx, %rdi
callq 0x5deb
addl 0xc(%rax), %r12d
cmpl %ebp, %r12d
cmovgl %r12d, %ebp
movl %r12d, %eax
jmp 0x5e4f
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpl $0x100, %esi            # imm = 0x100
jge 0x6727
movl %esi, %ebx
callq 0x5e9d
movslq %ebx, %rdx
cmpb $0x0, 0x90(%rax,%rdx)
je 0x6723
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x0, 0x190(%rcx,%rdx)
sete %al
jmp 0x6725
xorl %eax, %eax
popq %rbx
retq
leaq 0x5321(%rip), %rdi      # 0xba4f
leaq 0x52b7(%rip), %rsi      # 0xb9ec
leaq 0x531d(%rip), %rcx      # 0xba59
movl $0x1203, %edx           # imm = 0x1203
callq 0x3260
// File: /workspace/github_c_makefile_star2_O2/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 %rax
callq 0x5e9d
movl 0x8c(%rax), %ecx
andl $0x0, 0x8c(%rax)
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x705d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0x4e0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %r10, %rdx
callq 0x3230
movb $0x0, 0x3ff(%rbx)
leaq 0x49f0(%rip), %rdi      # 0xba93
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3060
pushq $0x1
popq %rdi
callq 0x3440
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3690
cvtsi2sdq (%rbx), %xmm0
cvtsi2sdq 0x8(%rbx), %xmm1
divsd 0x48f6(%rip), %xmm1     # 0xb9d0
addsd %xmm0, %xmm1
movsd 0x83da(%rip), %xmm0     # 0xf4c0
movsd %xmm1, 0x83d2(%rip)     # 0xf4c0
subsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpeqsd %xmm0, %xmm2
andnpd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x5e9d
testq %r15, %r15
je 0x712a
movl 0x294(%rax), %ecx
movl %ecx, (%r15)
testq %r14, %r14
je 0x7138
movl 0x298(%rax), %ecx
movl %ecx, (%r14)
testq %rbx, %rbx
je 0x7145
movl 0x290(%rax), %eax
movl %eax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
andl $0x0, 0xc(%rsp)
testl %edx, %edx
jle 0x7174
leaq 0x4(%rsi), %rdx
leaq 0xc(%rsp), %rbx
movq %rbx, %rcx
callq 0x7109
xorl %eax, %eax
cmpl $0x0, (%rbx)
setne %al
jmp 0x7176
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movl %edi, %ebx
leaq 0xc(%rsp), %r14
movl $0x8b81, %esi           # imm = 0x8B81
movq %r14, %rdx
callq 0x37a0
cmpl $0x0, (%r14)
je 0x71cd
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
retq
leaq 0x10(%rsp), %r14
movl %ebx, %edi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
movq %r14, %rcx
callq 0x30e0
leaq 0x48de(%rip), %rsi      # 0xbac8
movq %r14, %rdx
xorl %eax, %eax
callq 0x7002
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movl %edi, %ebx
leaq 0xc(%rsp), %r14
movl $0x8b82, %esi           # imm = 0x8B82
movq %r14, %rdx
callq 0x3220
cmpl $0x0, (%r14)
je 0x7223
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
retq
leaq 0x10(%rsp), %r14
movl %ebx, %edi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
movq %r14, %rcx
callq 0x3210
leaq 0x48a3(%rip), %rsi      # 0xbae3
movq %r14, %rdx
xorl %eax, %eax
callq 0x7002
// File: /workspace/github_c_makefile_star2_O2/nkanaev[P]tipsy/src/tigr.c
// Function: tigrCreateShaderProgram
void tigrCreateShaderProgram(GLStuff* gl, const char* fxSource, int fxSize) {
    if (gl->program != 0) {
        glDeleteProgram(gl->program);
        gl->program = 0;
    }

    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
    const char* vs_source = (const char*)&tigr_upscale_gl_vs;
    glShaderSource(vs, 1, &vs_source, &tigr_upscale_gl_vs_size);
    glCompileShader(vs);
    tigrCheckShaderErrors(vs);

    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
    const char* fs_sources[] = {
        (const char*)tigr_upscale_gl_fs,
        fxSource,
    };
    const int fs_lengths[] = {
        tigr_upscale_gl_fs_size,
        fxSize,
    };
    glShaderSource(fs, 2, fs_sources, fs_lengths);
    glCompileShader(fs);
    tigrCheckShaderErrors(fs);

    gl->program = glCreateProgram();
    glAttachShader(gl->program, vs);
    glAttachShader(gl->program, fs);
    glLinkProgram(gl->program);
    tigrCheckProgramErrors(gl->program);
    glDeleteShader(vs);
    glDeleteShader(fs);

    gl->uniform_projection = glGetUniformLocation(gl->program, "projection");
    gl->uniform_model = glGetUniformLocation(gl->program, "model");
    gl->uniform_parameters = glGetUniformLocation(gl->program, "parameters");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl 0xc(%rdi), %edi
testl %edi, %edi
je 0x726f
callq 0x3140
andl $0x0, 0xc(%rbx)
movl $0x8b31, %edi           # imm = 0x8B31
callq 0x3330
movl %eax, %ebp
leaq 0x2fde(%rip), %rax      # 0xa260
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x30bd(%rip), %rcx      # 0xa34c
pushq $0x1
popq %rsi
movl %ebp, %edi
callq 0x37e0
movl %ebp, %edi
callq 0x32f0
movl %ebp, %edi
callq 0x719e
movl $0x8b30, %edi           # imm = 0x8B30
callq 0x3330
movl %eax, %r14d
leaq 0x3095(%rip), %rax      # 0xa350
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movq %r12, 0x8(%rdx)
leaq 0x8(%rsp), %rcx
movl $0xae, (%rcx)
movl %r15d, 0x4(%rcx)
pushq $0x2
popq %rsi
movl %r14d, %edi
callq 0x37e0
movl %r14d, %edi
callq 0x32f0
movl %r14d, %edi
callq 0x719e
callq 0x36e0
movl %eax, 0xc(%rbx)
movl %eax, %edi
movl %ebp, %esi
callq 0x36d0
movl 0xc(%rbx), %edi
movl %r14d, %esi
callq 0x36d0
movl 0xc(%rbx), %edi
callq 0x37d0
movl 0xc(%rbx), %edi
callq 0x71f4
movl %ebp, %edi
callq 0x3380
movl %r14d, %edi
callq 0x3380
movl 0xc(%rbx), %edi
leaq 0x47c5(%rip), %rsi      # 0xbafb
callq 0x3180
movl %eax, 0x10(%rbx)
movl 0xc(%rbx), %edi
leaq 0x47be(%rip), %rsi      # 0xbb06
callq 0x3180
movl %eax, 0x14(%rbx)
movl 0xc(%rbx), %edi
leaq 0x47b2(%rip), %rsi      # 0xbb0c
callq 0x3180
movl %eax, 0x18(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq