LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
movsd (%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd (%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x18(%rax), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x18(%rax), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x18(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rsi
leaq 0xca3(%rip), %rdi       # 0x2027
callq 0x1160
movq 0x58(%rsp), %rsi
leaq 0xc9d(%rip), %rdi       # 0x2032
callq 0x1160
movq 0x50(%rsp), %rsi
leaq 0xc83(%rip), %rdi       # 0x2029
callq 0x1160
movq 0x48(%rsp), %rsi
leaq 0xc7f(%rip), %rdi       # 0x2036
callq 0x1160
leaq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x12b0
movq %rsp, %rdi
movq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x11b0
leaq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq %rsp, %rdx
callq 0x11b0
leaq 0x20(%rsp), %rsi
leaq 0xc30(%rip), %rdi       # 0x202b
callq 0x1160
leaq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x12b0
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x11b0
movq %rsp, %rsi
leaq 0xc05(%rip), %rdi       # 0x2030
callq 0x1160
leaq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x12b0
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x11b0
movq %rsp, %rsi
leaq 0xbd9(%rip), %rdi       # 0x2034
callq 0x1160
movq 0x60(%rsp), %rdi
callq 0x1310
leaq 0xbc7(%rip), %rdi       # 0x2038
movb $0x1, %al
callq 0x1030
movq 0x58(%rsp), %rdi
callq 0x1310
leaq 0xbbc(%rip), %rdi       # 0x2045
movb $0x1, %al
callq 0x1030
movq 0x48(%rsp), %rdi
callq 0x1310
leaq 0xbb1(%rip), %rdi       # 0x2052
movb $0x1, %al
callq 0x1030
movq 0x50(%rsp), %rdi
callq 0x1310
leaq 0xba6(%rip), %rdi       # 0x205f
movb $0x1, %al
callq 0x1030
leaq 0xb5e(%rip), %rdi       # 0x2025
movb $0x0, %al
callq 0x1030
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x98, %rsp
movl $0x0, 0x94(%rsp)
movl %edi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0xb68(%rip), %rax       # 0x2070
movq %rax, 0x60(%rsp)
movq 0xb64(%rip), %rax       # 0x2078
movq %rax, 0x68(%rsp)
movq 0xb60(%rip), %rax       # 0x2080
movq %rax, 0x70(%rsp)
movq 0xb5c(%rip), %rax       # 0x2088
movq %rax, 0x78(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
leaq 0x60(%rsp), %rcx
callq 0x1040
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rsp, %rcx
callq 0x1360
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
leaq 0x60(%rsp), %rcx
callq 0x1040
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rsp, %rcx
callq 0x1360
leaq 0x40(%rsp), %rdi
addq $0x18, %rdi
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
addq $0x8, %rdx
movq %rsp, %rcx
leaq 0x20(%rsp), %r8
addq $0x8, %r8
leaq 0x20(%rsp), %r9
movsd 0x60(%rsp), %xmm0
movsd 0x70(%rsp), %xmm1
movsd 0x78(%rsp), %xmm2
callq 0x1050
movsd 0x8(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rsp, %rcx
callq 0x1360
xorl %eax, %eax
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movslq -0xc(%rbp), %rsi
addq $0x30, %rsi
movl $0x1, %edi
callq 0x3270
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3270
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x39de
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x39de
jmp 0x3abe
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x3270
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3a09
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3a12
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3a2c
movl -0x10(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x3a36
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3a92
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
imull -0xc(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
imull (%rcx), %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
movslq -0x18(%rbp), %rdx
shlq $0x2, %rdx
callq 0x32d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3a43
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3410
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrCalcScale
int tigrCalcScale(int bmpW, int bmpH, int areaW, int areaH) {
    // We want it as big as possible in the window, but still
    // maintaining the correct aspect ratio, and always
    // having an integer pixel size.
    int scale = 0;
    for (;;) {
        scale++;
        if (bmpW * scale > areaW || bmpH * scale > areaH) {
            scale--;
            break;
        }
    }
    return (scale > 1) ? scale : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
imull -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x3b08
movl -0x8(%rbp), %eax
imull -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x3b13
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3b15
jmp 0x3ae7
cmpl $0x1, -0x14(%rbp)
jle 0x3b23
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3b2d
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3b2d
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3b62
cmpl $0x4, -0x4(%rbp)
jge 0x3b62
movl $0x4, -0x4(%rbp)
movl -0x8(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x3b7a
cmpl $0x3, -0x4(%rbp)
jge 0x3b7a
movl $0x3, -0x4(%rbp)
movl -0x8(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3b92
cmpl $0x2, -0x4(%rbp)
jge 0x3b92
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
imull -0xc(%rbp), %ecx
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
imull -0xc(%rbp), %ecx
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl (%rax), %eax
imull -0xc(%rbp), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
imull -0xc(%rbp), %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %esi, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x4(%rcx), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3c78
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
movl -0x4(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3c53
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl %r9d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x3caf
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x3cc5
movl -0x18(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x3cdf
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x3cfb
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x3d07
cmpl $0x0, -0x20(%rbp)
jg 0x3d09
jmp 0x3d80
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull (%rdx), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3d5d
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl -0x4(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3d3c
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jne 0x3d35
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %r9d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3dde
movl $0x1, -0x24(%rbp)
jmp 0x3de5
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3df6
movl $0x1, -0x28(%rbp)
jmp 0x3dfd
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl -0x2c(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x4(%rbp), %ecx
callq 0x3e90
movl -0x34(%rbp), %eax
shll %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
xorl %ecx, %ecx
subl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jle 0x3e40
movl -0x30(%rbp), %ecx
movl -0x34(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x24(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x3e5a
movl -0x2c(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3e5c
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl -0x1c(%rbp), %ecx
movb %al, -0x39(%rbp)
jne 0x3e75
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3e06
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %r9d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x4319
cmpl $0x0, -0x20(%rbp)
jg 0x431e
jmp 0x439e
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
addl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x4(%rbp), %r9d
callq 0x3d90
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x4(%rbp), %r9d
callq 0x3d90
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x4(%rbp), %r9d
callq 0x3d90
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x4(%rbp), %r9d
callq 0x3d90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrGet
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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x31d0
cmpl $0x0, -0x14(%rbp)
jl 0x4755
cmpl $0x0, -0x18(%rbp)
jl 0x4755
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x4755
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x4755
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull (%rdx), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x475b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrLoadImageMem
Tigr* tigrLoadImageMem(const void* data, int length) {
    PNG png;
    png.p = (unsigned char*)data;
    png.end = (unsigned char*)data + length;
    return tigrLoadPng(&png);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5010
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5510
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x54de
movq $0x0, -0x8(%rbp)
jmp 0x54ff
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4fd0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3410
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5531
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0xb0ee(%rip), %rsi      # 0x1062a
callq 0x3400
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5559
movq $0x0, -0x8(%rbp)
jmp 0x561a
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x33a0
movq -0x20(%rbp), %rdi
callq 0x3030
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x33a0
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0x34f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x55b2
movq -0x20(%rbp), %rdi
callq 0x3350
movq $0x0, -0x8(%rbp)
jmp 0x561a
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x3610
cmpq -0x30(%rbp), %rax
je 0x55ea
movq -0x28(%rbp), %rdi
callq 0x3410
movq -0x20(%rbp), %rdi
callq 0x3350
movq $0x0, -0x8(%rbp)
jmp 0x561a
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
callq 0x3350
cmpq $0x0, -0x18(%rbp)
je 0x5612
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
je 0x56a7
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
shrl %ecx
movl -0xc(%rbp), %eax
andl $0x1, %eax
shll $0x7, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x56a5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x56b0
movq -0x8(%rbp), %rax
movl $0x80, 0x8(%rax)
jmp 0x5642
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrSaveImage
int tigrSaveImage(const char* fileName, Tigr* bmp) {
    Save s;
    long dataPos, dataSize, err;

    // TODO - unicode?
    FILE* out = fopen(fileName, "wb");
    if (!out)
        return 1;

    s.out = out;
    s.adler = 1;
    s.bits = 0x80;
    s.prev = 0xffff;
    s.runlen = 0;

    savePngHeader(&s, bmp);
    dataPos = ftell(s.out);
    dataSize = savePngData(&s, bmp, dataPos);

    // End chunk.
    begin(&s, "IEND", 0);
    put32(&s, ~s.crc);

    // Write back payload size.
    fseek(out, dataPos, SEEK_SET);
    put32(&s, dataSize);

    err = ferror(out);
    fclose(out);
    return !err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xacca(%rip), %rsi      # 0x10468
callq 0x3400
movq %rax, -0x458(%rbp)
cmpq $0x0, -0x458(%rbp)
jne 0x57c0
movl $0x1, -0x4(%rbp)
jmp 0x58c1
movq -0x458(%rbp), %rax
movq %rax, -0x420(%rbp)
movl $0x1, -0x434(%rbp)
movl $0x80, -0x430(%rbp)
movl $0xffff, -0x42c(%rbp)   # imm = 0xFFFF
movl $0x0, -0x428(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x438(%rbp), %rdi
callq 0x58d0
movq -0x420(%rbp), %rdi
callq 0x3030
movq %rax, -0x440(%rbp)
movq -0x18(%rbp), %rsi
movq -0x440(%rbp), %rdx
leaq -0x438(%rbp), %rdi
callq 0x5990
movq %rax, -0x448(%rbp)
leaq -0x438(%rbp), %rdi
leaq 0xac26(%rip), %rsi      # 0x1046b
xorl %edx, %edx
callq 0x5b70
movl -0x438(%rbp), %esi
xorl $-0x1, %esi
leaq -0x438(%rbp), %rdi
callq 0x5bf0
movq -0x458(%rbp), %rdi
movq -0x440(%rbp), %rsi
xorl %edx, %edx
callq 0x33a0
movq -0x448(%rbp), %rax
movl %eax, %esi
leaq -0x438(%rbp), %rdi
callq 0x5bf0
movq -0x458(%rbp), %rdi
callq 0x3780
cltq
movq %rax, -0x450(%rbp)
movq -0x458(%rbp), %rdi
callq 0x3350
cmpq $0x0, -0x450(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: savePngHeader
static void savePngHeader(Save* s, Tigr* bmp) {
    fwrite("\211PNG\r\n\032\n", 8, 1, s->out);
    begin(s, "IHDR", 13);
    put32(s, bmp->w);
    put32(s, bmp->h);
    put(s, 8);  // bit depth
    put(s, 6);  // RGBA
    put(s, 0);  // compression (deflate)
    put(s, 0);  // filter (standard)
    put(s, 0);  // interlace off
    put32(s, ~s->crc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xad3e(%rip), %rdi      # 0x1062d
movl $0x8, %esi
movl $0x1, %edx
callq 0x37e0
movq -0x8(%rbp), %rdi
leaq 0xad2d(%rip), %rsi      # 0x10636
movl $0xd, %edx
callq 0x5b70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x5bf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x5bf0
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
xorl $-0x1, %esi
callq 0x5bf0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5bf0
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %esi
callq 0x56b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
shrl $0x18, %esi
andl $0xff, %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
shrl $0x10, %esi
andl $0xff, %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
shrl $0x8, %esi
andl $0xff, %esi
callq 0x56b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
andl $0xff, %esi
callq 0x56b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrInflate
int tigrInflate(void* out, unsigned outlen, const void* in, unsigned inlen) {
    int last;
    State* s = (State*)calloc(1, sizeof(State));

    // We assume we can buffer 2 extra bytes from off the end of 'in'.
    s->in = (unsigned char*)in;
    s->inend = s->in + inlen + 2;
    s->out = (unsigned char*)out;
    s->outend = s->out + outlen;
    s->bits = 0;
    s->count = 0;
    bits(s, 0);

    if (setjmp(s->jmp) == 1) {
        free(s);
        return 0;
    }

    do {
        last = bits(s, 1);
        switch (bits(s, 2)) {
            case 0:
                stored(s);
                break;
            case 1:
                fixed(s);
                block(s);
                break;
            case 2:
                dynamic(s);
                block(s);
                break;
            case 3:
                FAIL();
        }
    } while (!last);

    free(s);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x1, %edi
movl $0x648, %esi            # imm = 0x648
callq 0x3270
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x24(%rbp), %eax
addq %rax, %rcx
addq $0x2, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movl -0x14(%rbp), %eax
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x5dd0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x35d0
cmpl $0x1, %eax
jne 0x5d18
movq -0x30(%rbp), %rdi
callq 0x3410
movl $0x0, -0x4(%rbp)
jmp 0x5dc0
jmp 0x5d1a
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x5dd0
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x5dd0
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x3, %eax
ja 0x5d9d
movq -0x38(%rbp), %rax
leaq 0x92ed(%rip), %rcx      # 0xf03c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rdi
callq 0x5e90
jmp 0x5d9d
movq -0x30(%rbp), %rdi
callq 0x5f50
movq -0x30(%rbp), %rdi
callq 0x6090
jmp 0x5d9d
movq -0x30(%rbp), %rdi
callq 0x6110
movq -0x30(%rbp), %rdi
callq 0x6090
jmp 0x5d9d
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3100
jmp 0x5d9f
cmpl $0x0, -0x28(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5d1a
movq -0x30(%rbp), %rdi
callq 0x3410
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl (%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x10, 0x4(%rax)
jae 0x5e7d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x5e45
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3100
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x4(%rax)
jmp 0x5e17
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: stored
static void stored(State* s) {
    // Uncompressed data block.
    int len;
    bits(s, s->count & 7);
    len = bits(s, 16);
    CHECK(((len ^ s->bits) & 0xffff) == 0xffff);
    CHECK(s->in + len <= s->inend);

    copy(s, s->in, len);
    s->in += len;
    bits(s, 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
andl $0x7, %esi
callq 0x5dd0
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x5dd0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl (%rcx), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x5ee7
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3100
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x5f12
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
callq 0x3100
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0xc(%rbp), %edx
callq 0xa110
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x5dd0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: fixed
static void fixed(State* s) {
    // Fixed set of Huffman codes.
    int n;
    unsigned char lens[288 + 32];
    for (n = 0; n <= 143; n++)
        lens[n] = 8;
    for (n = 144; n <= 255; n++)
        lens[n] = 9;
    for (n = 256; n <= 279; n++)
        lens[n] = 7;
    for (n = 280; n <= 287; n++)
        lens[n] = 8;
    for (n = 0; n < 32; n++)
        lens[288 + n] = 5;

    // Build lit/dist trees.
    s->tlit = build(s, s->litcodes, lens, 288);
    s->tdist = build(s, s->distcodes, lens + 288, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8f, -0xc(%rbp)
jg 0x5f86
movslq -0xc(%rbp), %rax
movb $0x8, -0x150(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5f66
movl $0x90, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jg 0x5fad
movslq -0xc(%rbp), %rax
movb $0x9, -0x150(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5f8d
movl $0x100, -0xc(%rbp)      # imm = 0x100
cmpl $0x117, -0xc(%rbp)      # imm = 0x117
jg 0x5fd4
movslq -0xc(%rbp), %rax
movb $0x7, -0x150(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5fb4
movl $0x118, -0xc(%rbp)      # imm = 0x118
cmpl $0x11f, -0xc(%rbp)      # imm = 0x11F
jg 0x5ffb
movslq -0xc(%rbp), %rax
movb $0x8, -0x150(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5fdb
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x6025
movl -0xc(%rbp), %eax
addl $0x120, %eax            # imm = 0x120
cltq
movb $0x5, -0x150(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6002
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xf0, %rsi
leaq -0x150(%rbp), %rdx
movl $0x120, %ecx            # imm = 0x120
callq 0xa1e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x63c(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x570, %rsi            # imm = 0x570
leaq -0x150(%rbp), %rdx
addq $0x120, %rdx            # imm = 0x120
movl $0x20, %ecx
callq 0xa1e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x640(%rax)
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xf0, %rsi
movq -0x8(%rbp), %rax
movl 0x63c(%rax), %edx
callq 0xa3a0
movl %eax, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x60e1
movl -0xc(%rbp), %eax
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xa170
movb -0xd(%rbp), %cl
movb %cl, (%rax)
jmp 0x6102
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jle 0x60fe
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x101, %esi            # imm = 0x101
callq 0xa470
jmp 0x6100
jmp 0x6104
jmp 0x6102
jmp 0x609c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: scan
static void scan(Tigr* bmp, int* x, int* y, int* rowh) {
    while (*y < bmp->h) {
        if (*x >= bmp->w) {
            *x = 0;
            (*y) += *rowh;
            *rowh = 1;
        }
        if (!border(bmp, *x, *y))
            return;
        (*x)++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6740
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x6717
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x6750
cmpl $0x0, %eax
jne 0x6733
jmp 0x6740
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x66d8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x3270
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6390
cmpl $0x0, %eax
jne 0x6831
movq -0x20(%rbp), %rdi
callq 0x6850
movq $0x0, -0x8(%rbp)
jmp 0x6839
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x690b
movq -0x8(%rbp), %rdi
callq 0x6e60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x6909
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x32c0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x3250
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x3660
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x690b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3410
movq -0x8(%rbp), %rdi
callq 0x3410
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nkanaev[P]tipsy/src/tigr.c
// Function: tigrSetupFont
void tigrSetupFont(TigrFont* font) {
    // Load the stock font if needed.
    if (font == tfont && !tfont->bitmap) {
        tfont->bitmap = tigrLoadImageMem(tigr_font, tigr_font_size);
        tigrLoadGlyphs(tfont, 1252);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0xdad1(%rip), %rax      # 0x14418
jne 0x6986
movq 0xdac8(%rip), %rax      # 0x14418
cmpq $0x0, (%rax)
jne 0x6986
movl 0xdab4(%rip), %esi      # 0x14410
leaq 0x8a3d(%rip), %rdi      # 0xf3a0
callq 0x4fd0
movq %rax, %rcx
movq 0xdaa6(%rip), %rax      # 0x14418
movq %rcx, (%rax)
movq 0xda9c(%rip), %rdi      # 0x14418
movl $0x4e4, %esi            # imm = 0x4E4
callq 0x6390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x530, %rsp            # imm = 0x530
testb %al, %al
je 0x69d7
movaps %xmm0, -0x4e0(%rbp)
movaps %xmm1, -0x4d0(%rbp)
movaps %xmm2, -0x4c0(%rbp)
movaps %xmm3, -0x4b0(%rbp)
movaps %xmm4, -0x4a0(%rbp)
movaps %xmm5, -0x490(%rbp)
movaps %xmm6, -0x480(%rbp)
movaps %xmm7, -0x470(%rbp)
movl %r8d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x45c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6930
leaq -0x450(%rbp), %rax
leaq -0x510(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x30, (%rax)
leaq -0x430(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x450(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x3230
movb $0x0, -0x31(%rbp)
leaq -0x450(%rbp), %rax
leaq -0x430(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x458(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6b37
movq -0x458(%rbp), %rdi
leaq -0x460(%rbp), %rsi
callq 0x6b40
movq %rax, -0x458(%rbp)
cmpl $0xd, -0x460(%rbp)
jne 0x6a90
jmp 0x6a5b
cmpl $0xa, -0x460(%rbp)
jne 0x6aba
movl -0x45c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x9b88(%rip), %rsi      # 0x10635
callq 0x6c90
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x6a5b
movq -0x18(%rbp), %rdi
movl -0x460(%rbp), %esi
callq 0x6d00
movq %rax, -0x438(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x438(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x438(%rbp), %rax
movl 0x8(%rax), %r9d
movq -0x438(%rbp), %rax
movl 0xc(%rax), %r11d
movq -0x438(%rbp), %rax
movl 0x10(%rax), %r10d
movl -0x4(%rbp), %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x4a20
movq -0x438(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x6a5b
addq $0x530, %rsp            # imm = 0x530
popq %rbp
retq