void __imlib_RotateAA(unsigned int *src, unsigned int *dest, int sow, int sw,
                      int sh, int dow, int dw, int dh, int x, int y, int dxh,
                      int dyh, int dxv, int dyv) {
  int i;
  if ((dw < 1) || (dh < 1))
    return;
  if (__check_inside_coords(x, y, dxh, dyh, dxv, dyv, dw, dh, sw - 1, sh - 1)) {
    __imlib_RotateAAInside(src, dest, sow, dow, dw, dh, x, y, dxh, dyh, dxv,
                           dyv);
    return;
  }
  sw--;
  sh--;
  sw <<= 12;
  sh <<= 12;
  while (1) {
    i = dw - 1;
    do {
      unsigned int *src_x_y = (src + (x >> 12) + ((y >> 12) * sow));
      if ((unsigned)x < sw) {
        if ((unsigned)y < sh) {
          do {
            ((unsigned char *)((dest)))[2] =
                (((((((((unsigned char *)((src_x_y)))[2]) << 12) +
                     (((((unsigned char *)((src_x_y) + 1))[2]) -
                       (((unsigned char *)((src_x_y)))[2])) *
                      (((x) & ((1 << 12) - 1))))))
                   << 12) +
                  ((((((((unsigned char *)((src_x_y) + (sow)))[2]) << 12) +
                      (((((unsigned char *)((src_x_y) + (sow) + 1))[2]) -
                        (((unsigned char *)((src_x_y) + (sow)))[2])) *
                       (((x) & ((1 << 12) - 1)))))) -
                    ((((((unsigned char *)((src_x_y)))[2]) << 12) +
                      (((((unsigned char *)((src_x_y) + 1))[2]) -
                        (((unsigned char *)((src_x_y)))[2])) *
                       (((x) & ((1 << 12) - 1))))))) *
                   (((y) & ((1 << 12) - 1))))) >>
                 (2 * 12));
            ((unsigned char *)((dest)))[1] =
                (((((((((unsigned char *)((src_x_y)))[1]) << 12) +
                     (((((unsigned char *)((src_x_y) + 1))[1]) -
                       (((unsigned char *)((src_x_y)))[1])) *
                      (((x) & ((1 << 12) - 1))))))
                   << 12) +
                  ((((((((unsigned char *)((src_x_y) + (sow)))[1]) << 12) +
                      (((((unsigned char *)((src_x_y) + (sow) + 1))[1]) -
                        (((unsigned char *)((src_x_y) + (sow)))[1])) *
                       (((x) & ((1 << 12) - 1)))))) -
                    ((((((unsigned char *)((src_x_y)))[1]) << 12) +
                      (((((unsigned char *)((src_x_y) + 1))[1]) -
                        (((unsigned char *)((src_x_y)))[1])) *
                       (((x) & ((1 << 12) - 1))))))) *
                   (((y) & ((1 << 12) - 1))))) >>
                 (2 * 12));
            ((unsigned char *)((dest)))[0] =
                (((((((((unsigned char *)((src_x_y)))[0]) << 12) +
                     (((((unsigned char *)((src_x_y) + 1))[0]) -
                       (((unsigned char *)((src_x_y)))[0])) *
                      (((x) & ((1 << 12) - 1))))))
                   << 12) +
                  ((((((((unsigned char *)((src_x_y) + (sow)))[0]) << 12) +
                      (((((unsigned char *)((src_x_y) + (sow) + 1))[0]) -
                        (((unsigned char *)((src_x_y) + (sow)))[0])) *
                       (((x) & ((1 << 12) - 1)))))) -
                    ((((((unsigned char *)((src_x_y)))[0]) << 12) +
                      (((((unsigned char *)((src_x_y) + 1))[0]) -
                        (((unsigned char *)((src_x_y)))[0])) *
                       (((x) & ((1 << 12) - 1))))))) *
                   (((y) & ((1 << 12) - 1))))) >>
                 (2 * 12));
            ((unsigned char *)((dest)))[3] =
                (((((((((unsigned char *)((src_x_y)))[3]) << 12) +
                     (((((unsigned char *)((src_x_y) + 1))[3]) -
                       (((unsigned char *)((src_x_y)))[3])) *
                      (((x) & ((1 << 12) - 1))))))
                   << 12) +
                  ((((((((unsigned char *)((src_x_y) + (sow)))[3]) << 12) +
                      (((((unsigned char *)((src_x_y) + (sow) + 1))[3]) -
                        (((unsigned char *)((src_x_y) + (sow)))[3])) *
                       (((x) & ((1 << 12) - 1)))))) -
                    ((((((unsigned char *)((src_x_y)))[3]) << 12) +
                      (((((unsigned char *)((src_x_y) + 1))[3]) -
                        (((unsigned char *)((src_x_y)))[3])) *
                       (((x) & ((1 << 12) - 1))))))) *
                   (((y) & ((1 << 12) - 1))))) >>
                 (2 * 12));
          } while (0);
        } else if ((unsigned)(y - sh) < (1 << 12)) {
          do {
            ((unsigned char *)((dest)))[2] =
                ((((((unsigned char *)((src_x_y)))[2]) << 12) +
                  (((((unsigned char *)((src_x_y + 1)))[2]) -
                    (((unsigned char *)((src_x_y)))[2])) *
                   (((x) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)((dest)))[1] =
                ((((((unsigned char *)((src_x_y)))[1]) << 12) +
                  (((((unsigned char *)((src_x_y + 1)))[1]) -
                    (((unsigned char *)((src_x_y)))[1])) *
                   (((x) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)((dest)))[0] =
                ((((((unsigned char *)((src_x_y)))[0]) << 12) +
                  (((((unsigned char *)((src_x_y + 1)))[0]) -
                    (((unsigned char *)((src_x_y)))[0])) *
                   (((x) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)(dest))[3] =
                (((((((unsigned char *)((src_x_y)))[3]) << 12) +
                   (((((unsigned char *)((src_x_y + 1)))[3]) -
                     (((unsigned char *)((src_x_y)))[3])) *
                    (((x) & ((1 << 12) - 1))))) *
                  ((~y) & ((1 << 12) - 1))) >>
                 (2 * 12));
          } while (0);
        } else if ((unsigned)(~y) < (1 << 12)) {
          do {
            ((unsigned char *)((dest)))[2] =
                ((((((unsigned char *)((src_x_y + sow)))[2]) << 12) +
                  (((((unsigned char *)((src_x_y + sow + 1)))[2]) -
                    (((unsigned char *)((src_x_y + sow)))[2])) *
                   (((x) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)((dest)))[1] =
                ((((((unsigned char *)((src_x_y + sow)))[1]) << 12) +
                  (((((unsigned char *)((src_x_y + sow + 1)))[1]) -
                    (((unsigned char *)((src_x_y + sow)))[1])) *
                   (((x) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)((dest)))[0] =
                ((((((unsigned char *)((src_x_y + sow)))[0]) << 12) +
                  (((((unsigned char *)((src_x_y + sow + 1)))[0]) -
                    (((unsigned char *)((src_x_y + sow)))[0])) *
                   (((x) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)(dest))[3] =
                (((((((unsigned char *)((src_x_y + sow)))[3]) << 12) +
                   (((((unsigned char *)((src_x_y + sow + 1)))[3]) -
                     (((unsigned char *)((src_x_y + sow)))[3])) *
                    (((x) & ((1 << 12) - 1))))) *
                  ((y) & ((1 << 12) - 1))) >>
                 (2 * 12));
          } while (0);
        } else
          *dest = 0;
      } else if ((unsigned)(x - sw) < ((1 << 12))) {
        if ((unsigned)y < sh) {
          do {
            ((unsigned char *)((dest)))[2] =
                ((((((unsigned char *)((src_x_y)))[2]) << 12) +
                  (((((unsigned char *)((src_x_y + sow)))[2]) -
                    (((unsigned char *)((src_x_y)))[2])) *
                   (((y) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)((dest)))[1] =
                ((((((unsigned char *)((src_x_y)))[1]) << 12) +
                  (((((unsigned char *)((src_x_y + sow)))[1]) -
                    (((unsigned char *)((src_x_y)))[1])) *
                   (((y) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)((dest)))[0] =
                ((((((unsigned char *)((src_x_y)))[0]) << 12) +
                  (((((unsigned char *)((src_x_y + sow)))[0]) -
                    (((unsigned char *)((src_x_y)))[0])) *
                   (((y) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)(dest))[3] =
                (((((((unsigned char *)((src_x_y)))[3]) << 12) +
                   (((((unsigned char *)((src_x_y + sow)))[3]) -
                     (((unsigned char *)((src_x_y)))[3])) *
                    (((y) & ((1 << 12) - 1))))) *
                  ((~x) & ((1 << 12) - 1))) >>
                 (2 * 12));
          } while (0);
        } else if ((unsigned)(y - sh) < (1 << 12)) {
          do {
            *(dest) = *(src_x_y);
            ((unsigned char *)(dest))[3] =
                (((unsigned char *)(dest))[3] * ((~x) & ((1 << 12) - 1)) *
                 ((~y) & ((1 << 12) - 1))) >>
                (2 * 12);
          } while (0);
        } else if ((unsigned)(~y) < (1 << 12)) {
          do {
            *(dest) = *(src_x_y + sow);
            ((unsigned char *)(dest))[3] =
                (((unsigned char *)(dest))[3] * ((~x) & ((1 << 12) - 1)) *
                 ((y) & ((1 << 12) - 1))) >>
                (2 * 12);
          } while (0);
        } else
          *dest = 0;
      } else if ((unsigned)(~x) < (1 << 12)) {
        if ((unsigned)y < sh) {
          do {
            ((unsigned char *)((dest)))[2] =
                ((((((unsigned char *)((src_x_y + 1)))[2]) << 12) +
                  (((((unsigned char *)((src_x_y + sow + 1)))[2]) -
                    (((unsigned char *)((src_x_y + 1)))[2])) *
                   (((y) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)((dest)))[1] =
                ((((((unsigned char *)((src_x_y + 1)))[1]) << 12) +
                  (((((unsigned char *)((src_x_y + sow + 1)))[1]) -
                    (((unsigned char *)((src_x_y + 1)))[1])) *
                   (((y) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)((dest)))[0] =
                ((((((unsigned char *)((src_x_y + 1)))[0]) << 12) +
                  (((((unsigned char *)((src_x_y + sow + 1)))[0]) -
                    (((unsigned char *)((src_x_y + 1)))[0])) *
                   (((y) & ((1 << 12) - 1))))) >>
                 12);
            ((unsigned char *)(dest))[3] =
                (((((((unsigned char *)((src_x_y + 1)))[3]) << 12) +
                   (((((unsigned char *)((src_x_y + sow + 1)))[3]) -
                     (((unsigned char *)((src_x_y + 1)))[3])) *
                    (((y) & ((1 << 12) - 1))))) *
                  ((x) & ((1 << 12) - 1))) >>
                 (2 * 12));
          } while (0);
        } else if ((unsigned)(y - sh) < (1 << 12)) {
          do {
            *(dest) = *(src_x_y + 1);
            ((unsigned char *)(dest))[3] =
                (((unsigned char *)(dest))[3] * ((x) & ((1 << 12) - 1)) *
                 ((~y) & ((1 << 12) - 1))) >>
                (2 * 12);
          } while (0);
        } else if ((unsigned)(~y) < (1 << 12)) {
          do {
            *(dest) = *(src_x_y + sow + 1);
            ((unsigned char *)(dest))[3] =
                (((unsigned char *)(dest))[3] * ((x) & ((1 << 12) - 1)) *
                 ((y) & ((1 << 12) - 1))) >>
                (2 * 12);
          } while (0);
        } else
          *dest = 0;
      } else
        *dest = 0;
      x += dxh;
      y += dyh;
      dest++;
    } while (--i >= 0);
    if (--dh <= 0)
      break;
    x += dxv - dw * dxh;
    y += dyv - dw * dyh;
    dest += (dow - dw);
  }
}


x86 assembly (clang, -O0):
<__imlib_RotateAA>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x68,%rsp
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %edx,-0x2c(%rbp)
mov    %ecx,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
cmpl   $0x1,0x10(%rbp)
jl     116f <__imlib_RotateAA+0x4f>
cmpl   $0x1,0x18(%rbp)
jge    1174 <__imlib_RotateAA+0x54>
jmp    1c0f <__imlib_RotateAA+0xaef>
mov    0x20(%rbp),%edi
mov    0x28(%rbp),%esi
mov    0x30(%rbp),%edx
mov    0x38(%rbp),%ecx
mov    0x40(%rbp),%r8d
mov    0x48(%rbp),%r9d
mov    0x10(%rbp),%ebx
mov    0x18(%rbp),%r11d
mov    -0x30(%rbp),%r10d
sub    $0x1,%r10d
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1040 <__check_inside_coords@plt>
cmp    $0x0,%eax
je     1211 <__imlib_RotateAA+0xf1>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x2c(%rbp),%edx
mov    -0x38(%rbp),%ecx
mov    0x10(%rbp),%r8d
mov    0x18(%rbp),%r9d
mov    0x20(%rbp),%r15d
mov    0x28(%rbp),%r14d
mov    0x30(%rbp),%ebx
mov    0x38(%rbp),%r11d
mov    0x40(%rbp),%r10d
mov    0x48(%rbp),%eax
mov    %r15d,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %ebx,0x10(%rsp)
mov    %r11d,0x18(%rsp)
mov    %r10d,0x20(%rsp)
mov    %eax,0x28(%rsp)
mov    $0x0,%al
call   1030 <__imlib_RotateAAInside@plt>
jmp    1c0f <__imlib_RotateAA+0xaef>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0xc,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
shl    $0xc,%eax
mov    %eax,-0x34(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%ecx
sar    $0xc,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    0x28(%rbp),%ecx
sar    $0xc,%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    0x20(%rbp),%eax
cmp    -0x30(%rbp),%eax
jae    1799 <__imlib_RotateAA+0x679>
mov    0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    1541 <__imlib_RotateAA+0x421>
jmp    1287 <__imlib_RotateAA+0x167>
mov    -0x48(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x2(%rdx),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x2(%rcx,%rdx,4),%ecx
shl    $0xc,%ecx
mov    -0x48(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movzbl 0x6(%rdx,%rsi,4),%edx
mov    -0x48(%rbp),%rsi
movslq -0x2c(%rbp),%rdi
movzbl 0x2(%rsi,%rdi,4),%esi
sub    %esi,%edx
mov    0x20(%rbp),%esi
and    $0xfff,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x2(%rdx),%edx
shl    $0xc,%edx
mov    -0x48(%rbp),%rsi
movzbl 0x6(%rsi),%esi
mov    -0x48(%rbp),%rdi
movzbl 0x2(%rdi),%edi
sub    %edi,%esi
mov    0x20(%rbp),%edi
and    $0xfff,%edi
imul   %edi,%esi
add    %esi,%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x1(%rdx),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,4),%ecx
shl    $0xc,%ecx
mov    -0x48(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movzbl 0x5(%rdx,%rsi,4),%edx
mov    -0x48(%rbp),%rsi
movslq -0x2c(%rbp),%rdi
movzbl 0x1(%rsi,%rdi,4),%esi
sub    %esi,%edx
mov    0x20(%rbp),%esi
and    $0xfff,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x1(%rdx),%edx
shl    $0xc,%edx
mov    -0x48(%rbp),%rsi
movzbl 0x5(%rsi),%esi
mov    -0x48(%rbp),%rdi
movzbl 0x1(%rdi),%edi
sub    %edi,%esi
mov    0x20(%rbp),%edi
and    $0xfff,%edi
imul   %edi,%esi
add    %esi,%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x48(%rbp),%rax
movzbl (%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
mov    -0x48(%rbp),%rdx
movzbl (%rdx),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl (%rcx,%rdx,4),%ecx
shl    $0xc,%ecx
mov    -0x48(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movzbl 0x4(%rdx,%rsi,4),%edx
mov    -0x48(%rbp),%rsi
movslq -0x2c(%rbp),%rdi
movzbl (%rsi,%rdi,4),%esi
sub    %esi,%edx
mov    0x20(%rbp),%esi
and    $0xfff,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x48(%rbp),%rdx
movzbl (%rdx),%edx
shl    $0xc,%edx
mov    -0x48(%rbp),%rsi
movzbl 0x4(%rsi),%esi
mov    -0x48(%rbp),%rdi
movzbl (%rdi),%edi
sub    %edi,%esi
mov    0x20(%rbp),%edi
and    $0xfff,%edi
imul   %edi,%esi
add    %esi,%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x3(%rdx),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x3(%rcx,%rdx,4),%ecx
shl    $0xc,%ecx
mov    -0x48(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movzbl 0x7(%rdx,%rsi,4),%edx
mov    -0x48(%rbp),%rsi
movslq -0x2c(%rbp),%rdi
movzbl 0x3(%rsi,%rdi,4),%esi
sub    %esi,%edx
mov    0x20(%rbp),%esi
and    $0xfff,%esi
imul   %esi,%edx
add    %edx,%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x3(%rdx),%edx
shl    $0xc,%edx
mov    -0x48(%rbp),%rsi
movzbl 0x7(%rsi),%esi
mov    -0x48(%rbp),%rdi
movzbl 0x3(%rdi),%edi
sub    %edi,%esi
mov    0x20(%rbp),%edi
and    $0xfff,%edi
imul   %edi,%esi
add    %esi,%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    1794 <__imlib_RotateAA+0x674>
mov    0x28(%rbp),%eax
sub    -0x34(%rbp),%eax
cmp    $0x1000,%eax
jae    1644 <__imlib_RotateAA+0x524>
jmp    1557 <__imlib_RotateAA+0x437>
mov    -0x48(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x2(%rdx),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x1(%rdx),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x48(%rbp),%rax
movzbl (%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
mov    -0x48(%rbp),%rdx
movzbl (%rdx),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x3(%rdx),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    0x28(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    178f <__imlib_RotateAA+0x66f>
mov    0x28(%rbp),%eax
xor    $0xffffffff,%eax
cmp    $0x1000,%eax
jae    1780 <__imlib_RotateAA+0x660>
jmp    165a <__imlib_RotateAA+0x53a>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl 0x2(%rax,%rcx,4),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x6(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movzbl 0x2(%rdx,%rsi,4),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl 0x1(%rax,%rcx,4),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x5(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movzbl 0x1(%rdx,%rsi,4),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,4),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x4(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movzbl (%rdx,%rsi,4),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl 0x3(%rax,%rcx,4),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x7(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movzbl 0x3(%rdx,%rsi,4),%edx
sub    %edx,%ecx
mov    0x20(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    0x28(%rbp),%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    178a <__imlib_RotateAA+0x66a>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
jmp    178f <__imlib_RotateAA+0x66f>
jmp    1794 <__imlib_RotateAA+0x674>
jmp    1b87 <__imlib_RotateAA+0xa67>
mov    0x20(%rbp),%eax
sub    -0x30(%rbp),%eax
cmp    $0x1000,%eax
jae    1988 <__imlib_RotateAA+0x868>
mov    0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    18bb <__imlib_RotateAA+0x79b>
jmp    17bb <__imlib_RotateAA+0x69b>
mov    -0x48(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x2(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x2(%rdx),%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x1(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x1(%rdx),%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x48(%rbp),%rax
movzbl (%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl (%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movzbl (%rdx),%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x3(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x3(%rdx),%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    0x20(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    1983 <__imlib_RotateAA+0x863>
mov    0x28(%rbp),%eax
sub    -0x34(%rbp),%eax
cmp    $0x1000,%eax
jae    1914 <__imlib_RotateAA+0x7f4>
jmp    18d1 <__imlib_RotateAA+0x7b1>
mov    -0x48(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    0x20(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
mov    0x28(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    197e <__imlib_RotateAA+0x85e>
mov    0x28(%rbp),%eax
xor    $0xffffffff,%eax
cmp    $0x1000,%eax
jae    196f <__imlib_RotateAA+0x84f>
jmp    192a <__imlib_RotateAA+0x80a>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    0x20(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
mov    0x28(%rbp),%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    1979 <__imlib_RotateAA+0x859>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
jmp    197e <__imlib_RotateAA+0x85e>
jmp    1983 <__imlib_RotateAA+0x863>
jmp    1b82 <__imlib_RotateAA+0xa62>
mov    0x20(%rbp),%eax
xor    $0xffffffff,%eax
cmp    $0x1000,%eax
jae    1b73 <__imlib_RotateAA+0xa53>
mov    0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    1aaa <__imlib_RotateAA+0x98a>
jmp    19aa <__imlib_RotateAA+0x88a>
mov    -0x48(%rbp),%rax
movzbl 0x6(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x6(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x6(%rdx),%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x5(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x5(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x5(%rdx),%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x4(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x4(%rdx),%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0xc,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movzbl 0x7(%rax),%eax
shl    $0xc,%eax
mov    -0x48(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl 0x7(%rcx,%rdx,4),%ecx
mov    -0x48(%rbp),%rdx
movzbl 0x7(%rdx),%edx
sub    %edx,%ecx
mov    0x28(%rbp),%edx
and    $0xfff,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    0x20(%rbp),%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    1b6e <__imlib_RotateAA+0xa4e>
mov    0x28(%rbp),%eax
sub    -0x34(%rbp),%eax
cmp    $0x1000,%eax
jae    1b01 <__imlib_RotateAA+0x9e1>
jmp    1ac0 <__imlib_RotateAA+0x9a0>
mov    -0x48(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    0x20(%rbp),%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
mov    0x28(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    1b69 <__imlib_RotateAA+0xa49>
mov    0x28(%rbp),%eax
xor    $0xffffffff,%eax
cmp    $0x1000,%eax
jae    1b5a <__imlib_RotateAA+0xa3a>
jmp    1b17 <__imlib_RotateAA+0x9f7>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    0x4(%rax,%rcx,4),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    0x20(%rbp),%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
mov    0x28(%rbp),%ecx
and    $0xfff,%ecx
imul   %ecx,%eax
sar    $0x18,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    1b64 <__imlib_RotateAA+0xa44>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
jmp    1b69 <__imlib_RotateAA+0xa49>
jmp    1b6e <__imlib_RotateAA+0xa4e>
jmp    1b7d <__imlib_RotateAA+0xa5d>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
jmp    1b82 <__imlib_RotateAA+0xa62>
jmp    1b87 <__imlib_RotateAA+0xa67>
mov    0x30(%rbp),%eax
add    0x20(%rbp),%eax
mov    %eax,0x20(%rbp)
mov    0x38(%rbp),%eax
add    0x28(%rbp),%eax
mov    %eax,0x28(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
cmp    $0x0,%eax
jge    123e <__imlib_RotateAA+0x11e>
mov    0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,0x18(%rbp)
cmp    $0x0,%eax
jg     1bce <__imlib_RotateAA+0xaae>
jmp    1c0f <__imlib_RotateAA+0xaef>
mov    0x40(%rbp),%eax
mov    0x10(%rbp),%ecx
imul   0x30(%rbp),%ecx
sub    %ecx,%eax
add    0x20(%rbp),%eax
mov    %eax,0x20(%rbp)
mov    0x48(%rbp),%eax
mov    0x10(%rbp),%ecx
imul   0x38(%rbp),%ecx
sub    %ecx,%eax
add    0x28(%rbp),%eax
mov    %eax,0x28(%rbp)
mov    -0x38(%rbp),%ecx
sub    0x10(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    1235 <__imlib_RotateAA+0x115>
add    $0x68,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<__imlib_RotateAA>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,0x10(%rsp)
mov    %edx,0x4(%rsp)
mov    0x80(%rsp),%r15d
test   %r15d,%r15d
jle    170b <__imlib_RotateAA+0x5eb>
mov    0x88(%rsp),%ebp
test   %ebp,%ebp
jle    170b <__imlib_RotateAA+0x5eb>
mov    %ecx,%eax
mov    %rsi,%r13
mov    %rdi,%r12
mov    %r9d,0x8(%rsp)
mov    0xb8(%rsp),%r9d
mov    0xb0(%rsp),%r8d
mov    0xa8(%rsp),%ecx
mov    0xa0(%rsp),%edx
mov    0x98(%rsp),%r14d
mov    0x90(%rsp),%ebx
lea    -0x1(%rax),%r10d
mov    0x10(%rsp),%rsi
lea    -0x1(%rsi),%r11d
mov    %ebx,%edi
mov    %r14d,%esi
mov    %rax,0x18(%rsp)
xor    %eax,%eax
push   %r11
push   %r10
push   %rbp
push   %r15
call   1040 <__check_inside_coords@plt>
add    $0x20,%rsp
test   %eax,%eax
je     1205 <__imlib_RotateAA+0xe5>
mov    %r12,%rdi
mov    %r13,%rsi
mov    0x4(%rsp),%edx
mov    0x8(%rsp),%ecx
mov    %r15d,%r8d
mov    %ebp,%r9d
xor    %eax,%eax
mov    0xb8(%rsp),%ebp
push   %rbp
mov    0xb8(%rsp),%ebp
push   %rbp
mov    0xb8(%rsp),%ebp
push   %rbp
mov    0xb8(%rsp),%ebp
push   %rbp
push   %r14
push   %rbx
call   1030 <__imlib_RotateAAInside@plt>
add    $0x78,%rsp
jmp    170f <__imlib_RotateAA+0x5ef>
mov    %rbp,0x28(%rsp)
mov    0x18(%rsp),%r9
shl    $0xc,%r9d
mov    %r15,%rbp
mov    0x10(%rsp),%r10
shl    $0xc,%r10d
movslq 0x4(%rsp),%r11
mov    0xa0(%rsp),%edi
mov    %edi,%ecx
imul   %ebp,%ecx
mov    0xa8(%rsp),%r15d
mov    %r15d,%edx
imul   %ebp,%edx
mov    0xb8(%rsp),%r8d
sub    %edx,%r8d
mov    $0x1000,%eax
mov    $0x1000,%edx
sub    %r10d,%edx
mov    %rdx,0x20(%rsp)
add    $0xfffff000,%r10d
sub    %r9d,%eax
mov    %rax,0x10(%rsp)
add    $0xfffff000,%r9d
mov    0xb0(%rsp),%edx
sub    %ecx,%edx
movslq 0x8(%rsp),%rax
shl    $0x2,%rax
movslq %ebp,%rcx
add    $0x1,%ebp
shl    $0x2,%rcx
sub    %rcx,%rax
mov    %rax,0x30(%rsp)
mov    %rbp,%rax
mov    %rdx,%rcx
mov    %r9,%rbp
mov    %rax,0x8(%rsp)
mov    %rdx,0x38(%rsp)
mov    %r9,0x18(%rsp)
mov    %r8,0x40(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %eax,%r9d
jmp    13f1 <__imlib_RotateAA+0x2d1>
nopl   0x0(%rax,%rax,1)
movzbl 0x2(%rsi),%ecx
movzbl 0x6(%rsi),%eax
sub    %ecx,%eax
shl    $0xc,%ecx
mov    %ebx,%edx
and    $0xfff,%edx
imul   %edx,%eax
add    %ecx,%eax
movzbl 0x2(%rsi,%r11,4),%r8d
movzbl 0x6(%rsi,%r11,4),%ecx
sub    %r8d,%ecx
shl    $0xc,%r8d
imul   %edx,%ecx
sub    %eax,%r8d
shl    $0xc,%eax
add    %ecx,%r8d
mov    %r14d,%ecx
and    $0xfff,%ecx
imul   %ecx,%r8d
add    %eax,%r8d
shr    $0x18,%r8d
mov    %r8b,0x2(%r13)
movzbl 0x1(%rsi),%eax
mov    %rdi,%r8
movzbl 0x5(%rsi),%edi
sub    %eax,%edi
shl    $0xc,%eax
imul   %edx,%edi
add    %eax,%edi
movzbl 0x1(%rsi,%r11,4),%eax
movzbl 0x5(%rsi,%r11,4),%ebp
sub    %eax,%ebp
shl    $0xc,%eax
imul   %edx,%ebp
sub    %edi,%eax
shl    $0xc,%edi
add    %ebp,%eax
imul   %ecx,%eax
add    %edi,%eax
shr    $0x18,%eax
mov    %al,0x1(%r13)
movzbl (%rsi),%eax
movzbl 0x4(%rsi),%edi
sub    %eax,%edi
shl    $0xc,%eax
imul   %edx,%edi
add    %eax,%edi
movzbl (%rsi,%r11,4),%eax
movzbl 0x4(%rsi,%r11,4),%ebp
sub    %eax,%ebp
shl    $0xc,%eax
imul   %edx,%ebp
sub    %edi,%eax
shl    $0xc,%edi
add    %ebp,%eax
imul   %ecx,%eax
add    %edi,%eax
shr    $0x18,%eax
mov    %al,0x0(%r13)
movzbl 0x3(%rsi),%eax
movzbl 0x7(%rsi),%edi
sub    %eax,%edi
shl    $0xc,%eax
imul   %edx,%edi
add    %eax,%edi
movzbl 0x3(%rsi,%r11,4),%eax
movzbl 0x7(%rsi,%r11,4),%esi
sub    %eax,%esi
shl    $0xc,%eax
imul   %edx,%esi
sub    %edi,%eax
shl    $0xc,%edi
add    %esi,%eax
imul   %ecx,%eax
add    %edi,%eax
mov    %r8,%rdi
mov    0x40(%rsp),%r8
mov    0x18(%rsp),%rbp
shr    $0x18,%eax
mov    %al,0x3(%r13)
add    %edi,%ebx
add    %r15d,%r14d
add    $0x4,%r13
add    $0xffffffff,%r9d
cmp    $0x1,%r9d
jle    16e0 <__imlib_RotateAA+0x5c0>
mov    %ebx,%ecx
sar    $0xc,%ecx
movslq %ecx,%rcx
lea    (%r12,%rcx,4),%rcx
mov    %r14d,%edx
sar    $0xc,%edx
imul   0x4(%rsp),%edx
movslq %edx,%rdx
lea    (%rcx,%rdx,4),%rsi
cmp    %ebp,%ebx
jae    14a0 <__imlib_RotateAA+0x380>
cmp    %r10d,%r14d
jb     12d0 <__imlib_RotateAA+0x1b0>
mov    0x20(%rsp),%rax
add    %r14d,%eax
cmp    $0xfff,%eax
ja     15b1 <__imlib_RotateAA+0x491>
movzbl 0x2(%rsi),%eax
movzbl 0x6(%rsi),%edx
sub    %eax,%edx
mov    %ebx,%ecx
and    $0xfff,%ecx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x2(%r13)
movzbl 0x1(%rsi),%eax
movzbl 0x5(%rsi),%edx
sub    %eax,%edx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x1(%r13)
movzbl (%rsi),%eax
movzbl 0x4(%rsi),%edx
sub    %eax,%edx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x0(%r13)
movzbl 0x3(%rsi),%eax
movzbl 0x7(%rsi),%edx
sub    %eax,%edx
shl    $0xc,%eax
imul   %ecx,%edx
add    %eax,%edx
mov    %r14d,%eax
jmp    1520 <__imlib_RotateAA+0x400>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
add    %ebx,%eax
cmp    $0xfff,%eax
ja     1530 <__imlib_RotateAA+0x410>
cmp    %r10d,%r14d
jae    1631 <__imlib_RotateAA+0x511>
movzbl 0x2(%rsi),%eax
movzbl 0x2(%rsi,%r11,4),%edx
sub    %eax,%edx
mov    %r14d,%ecx
and    $0xfff,%ecx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x2(%r13)
movzbl 0x1(%rsi),%eax
movzbl 0x1(%rsi,%r11,4),%edx
sub    %eax,%edx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x1(%r13)
movzbl (%rsi),%eax
movzbl (%rsi,%r11,4),%edx
sub    %eax,%edx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x0(%r13)
movzbl 0x3(%rsi),%eax
movzbl 0x3(%rsi,%r11,4),%edx
sub    %eax,%edx
shl    $0xc,%eax
imul   %ecx,%edx
add    %eax,%edx
mov    %ebx,%eax
not    %eax
and    $0xfff,%eax
imul   %edx,%eax
jmp    13d3 <__imlib_RotateAA+0x2b3>
nop
cmp    $0xfffff000,%ebx
jb     16d0 <__imlib_RotateAA+0x5b0>
cmp    %r10d,%r14d
jae    164f <__imlib_RotateAA+0x52f>
movzbl 0x6(%rsi),%eax
movzbl 0x6(%rsi,%r11,4),%edx
sub    %eax,%edx
mov    %r14d,%ecx
and    $0xfff,%ecx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x2(%r13)
movzbl 0x5(%rsi),%eax
movzbl 0x5(%rsi,%r11,4),%edx
sub    %eax,%edx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x1(%r13)
movzbl 0x4(%rsi),%eax
movzbl 0x4(%rsi,%r11,4),%edx
sub    %eax,%edx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x0(%r13)
movzbl 0x7(%rsi),%eax
movzbl 0x7(%rsi,%r11,4),%edx
sub    %eax,%edx
shl    $0xc,%eax
imul   %ecx,%edx
add    %eax,%edx
mov    %ebx,%eax
jmp    1522 <__imlib_RotateAA+0x402>
cmp    $0xfffff000,%r14d
jb     16d0 <__imlib_RotateAA+0x5b0>
movzbl 0x2(%rsi,%r11,4),%eax
movzbl 0x6(%rsi,%r11,4),%edx
sub    %eax,%edx
mov    %ebx,%ecx
and    $0xfff,%ecx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x2(%r13)
movzbl 0x1(%rsi,%r11,4),%eax
movzbl 0x5(%rsi,%r11,4),%edx
sub    %eax,%edx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x1(%r13)
movzbl (%rsi,%r11,4),%eax
movzbl 0x4(%rsi,%r11,4),%edx
sub    %eax,%edx
imul   %ecx,%edx
shr    $0xc,%edx
add    %al,%dl
mov    %dl,0x0(%r13)
movzbl 0x3(%rsi,%r11,4),%eax
movzbl 0x7(%rsi,%r11,4),%edx
sub    %eax,%edx
shl    $0xc,%eax
imul   %ecx,%edx
add    %eax,%edx
mov    %r14d,%eax
jmp    1522 <__imlib_RotateAA+0x402>
mov    0x20(%rsp),%rax
add    %r14d,%eax
cmp    $0xfff,%eax
ja     1677 <__imlib_RotateAA+0x557>
mov    (%rsi),%eax
mov    %eax,0x0(%r13)
shr    $0x18,%eax
mov    %ebx,%ecx
not    %ecx
jmp    166a <__imlib_RotateAA+0x54a>
mov    0x20(%rsp),%rax
add    %r14d,%eax
cmp    $0xfff,%eax
ja     1691 <__imlib_RotateAA+0x571>
mov    0x4(%rsi),%eax
mov    %eax,0x0(%r13)
shr    $0x18,%eax
mov    %ebx,%ecx
and    $0xfff,%ecx
mov    %r14d,%edx
not    %edx
jmp    16b1 <__imlib_RotateAA+0x591>
cmp    $0xfffff000,%r14d
jb     16d0 <__imlib_RotateAA+0x5b0>
mov    (%rsi,%r11,4),%eax
mov    %eax,0x0(%r13)
shr    $0x18,%eax
mov    %ebx,%ecx
not    %ecx
jmp    16a8 <__imlib_RotateAA+0x588>
cmp    $0xfffff000,%r14d
jb     16d0 <__imlib_RotateAA+0x5b0>
mov    0x4(%rsi,%r11,4),%eax
mov    %eax,0x0(%r13)
shr    $0x18,%eax
mov    %ebx,%ecx
and    $0xfff,%ecx
mov    %r14d,%edx
and    $0xfff,%edx
imul   %ecx,%edx
imul   %eax,%edx
shr    $0x18,%edx
mov    %dl,0x3(%r13)
jmp    13da <__imlib_RotateAA+0x2ba>
nopl   0x0(%rax)
movl   $0x0,0x0(%r13)
jmp    13da <__imlib_RotateAA+0x2ba>
nopl   (%rax)
mov    0x28(%rsp),%rcx
cmp    $0x2,%ecx
mov    0x8(%rsp),%rax
jl     170b <__imlib_RotateAA+0x5eb>
add    $0xffffffff,%ecx
mov    %rcx,0x28(%rsp)
mov    0x38(%rsp),%rcx
add    %ecx,%ebx
add    %r8d,%r14d
add    0x30(%rsp),%r13
jmp    12c0 <__imlib_RotateAA+0x1a0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @__imlib_RotateAA(i32* %0, i32* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13) {
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32*
store i32* %0, i32** %15
store i32* %1, i32** %16
store i32 %2, i32* %17
store i32 %3, i32* %18
store i32 %4, i32* %19
store i32 %5, i32* %20
store i32 %6, i32* %21
store i32 %7, i32* %22
store i32 %8, i32* %23
store i32 %9, i32* %24
store i32 %10, i32* %25
store i32 %11, i32* %26
store i32 %12, i32* %27
store i32 %13, i32* %28
%31 = load i32, i32* %21
%32 = icmp slt i32 %31, 1
br i1 %32, label %36, label %33
33: ; preds = %14
%34 = load i32, i32* %22
%35 = icmp slt i32 %34, 1
br i1 %35, label %36, label %37
36: ; preds = %33, %14
br label %1168
37: ; preds = %33
%38 = load i32, i32* %23
%39 = load i32, i32* %24
%40 = load i32, i32* %25
%41 = load i32, i32* %26
%42 = load i32, i32* %27
%43 = load i32, i32* %28
%44 = load i32, i32* %21
%45 = load i32, i32* %22
%46 = load i32, i32* %18
%47 = sub nsw i32 %46, 1
%48 = load i32, i32* %19
%49 = sub nsw i32 %48, 1
%50 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @__check_inside_coords to i32 (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ...)*)(i32 %38, i32 %39, i32 %40, i32 %41, i32 %42, i32 %43, i32 %44, i32 %45, i32 %47, i32 %49)
%51 = icmp ne i32 %50, 0
br i1 %51, label %52, label %66
52: ; preds = %37
%53 = load i32*, i32** %15
%54 = load i32*, i32** %16
%55 = load i32, i32* %17
%56 = load i32, i32* %20
%57 = load i32, i32* %21
%58 = load i32, i32* %22
%59 = load i32, i32* %23
%60 = load i32, i32* %24
%61 = load i32, i32* %25
%62 = load i32, i32* %26
%63 = load i32, i32* %27
%64 = load i32, i32* %28
%65 = call i32 (i32*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @__imlib_RotateAAInside to i32 (i32*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ...)*)(i32* %53, i32* %54, i32 %55, i32 %56, i32 %57, i32 %58, i32 %59, i32 %60, i32 %61, i32 %62, i32 %63, i32 %64)
br label %1168
66: ; preds = %37
%67 = load i32, i32* %18
%68 = add nsw i32 %67, -1
store i32 %68, i32* %18
%69 = load i32, i32* %19
%70 = add nsw i32 %69, -1
store i32 %70, i32* %19
%71 = load i32, i32* %18
%72 = shl i32 %71, 12
store i32 %72, i32* %18
%73 = load i32, i32* %19
%74 = shl i32 %73, 12
store i32 %74, i32* %19
br label %75
75: ; preds = %66, %1147
%76 = load i32, i32* %21
%77 = sub nsw i32 %76, 1
store i32 %77, i32* %29
br label %78
78: ; preds = %1138, %75
%79 = load i32*, i32** %15
%80 = load i32, i32* %23
%81 = ashr i32 %80, 12
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i32, i32* %79, i64 %82
%84 = load i32, i32* %24
%85 = ashr i32 %84, 12
%86 = load i32, i32* %17
%87 = mul nsw i32 %85, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32, i32* %83, i64 %88
store i32* %89, i32** %30
%90 = load i32, i32* %23
%91 = load i32, i32* %18
%92 = icmp ult i32 %90, %91
br i1 %92, label %93, label %723
93: ; preds = %78
%94 = load i32, i32* %24
%95 = load i32, i32* %19
%96 = icmp ult i32 %94, %95
br i1 %96, label %97, label %444
97: ; preds = %93
br label %98
98: ; preds = %97
%99 = load i32*, i32** %30
%100 = bitcast i32* %99 to i8*
%101 = getelementptr inbounds i8, i8* %100, i64 2
%102 = load i8, i8* %101
%103 = zext i8 %102 to i32
%104 = shl i32 %103, 12
%105 = load i32*, i32** %30
%106 = getelementptr inbounds i32, i32* %105, i64 1
%107 = bitcast i32* %106 to i8*
%108 = getelementptr inbounds i8, i8* %107, i64 2
%109 = load i8, i8* %108
%110 = zext i8 %109 to i32
%111 = load i32*, i32** %30
%112 = bitcast i32* %111 to i8*
%113 = getelementptr inbounds i8, i8* %112, i64 2
%114 = load i8, i8* %113
%115 = zext i8 %114 to i32
%116 = sub nsw i32 %110, %115
%117 = load i32, i32* %23
%118 = and i32 %117, 4095
%119 = mul nsw i32 %116, %118
%120 = add nsw i32 %104, %119
%121 = shl i32 %120, 12
%122 = load i32*, i32** %30
%123 = load i32, i32* %17
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %122, i64 %124
%126 = bitcast i32* %125 to i8*
%127 = getelementptr inbounds i8, i8* %126, i64 2
%128 = load i8, i8* %127
%129 = zext i8 %128 to i32
%130 = shl i32 %129, 12
%131 = load i32*, i32** %30
%132 = load i32, i32* %17
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %131, i64 %133
%135 = getelementptr inbounds i32, i32* %134, i64 1
%136 = bitcast i32* %135 to i8*
%137 = getelementptr inbounds i8, i8* %136, i64 2
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
%140 = load i32*, i32** %30
%141 = load i32, i32* %17
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %140, i64 %142
%144 = bitcast i32* %143 to i8*
%145 = getelementptr inbounds i8, i8* %144, i64 2
%146 = load i8, i8* %145
%147 = zext i8 %146 to i32
%148 = sub nsw i32 %139, %147
%149 = load i32, i32* %23
%150 = and i32 %149, 4095
%151 = mul nsw i32 %148, %150
%152 = add nsw i32 %130, %151
%153 = load i32*, i32** %30
%154 = bitcast i32* %153 to i8*
%155 = getelementptr inbounds i8, i8* %154, i64 2
%156 = load i8, i8* %155
%157 = zext i8 %156 to i32
%158 = shl i32 %157, 12
%159 = load i32*, i32** %30
%160 = getelementptr inbounds i32, i32* %159, i64 1
%161 = bitcast i32* %160 to i8*
%162 = getelementptr inbounds i8, i8* %161, i64 2
%163 = load i8, i8* %162
%164 = zext i8 %163 to i32
%165 = load i32*, i32** %30
%166 = bitcast i32* %165 to i8*
%167 = getelementptr inbounds i8, i8* %166, i64 2
%168 = load i8, i8* %167
%169 = zext i8 %168 to i32
%170 = sub nsw i32 %164, %169
%171 = load i32, i32* %23
%172 = and i32 %171, 4095
%173 = mul nsw i32 %170, %172
%174 = add nsw i32 %158, %173
%175 = sub nsw i32 %152, %174
%176 = load i32, i32* %24
%177 = and i32 %176, 4095
%178 = mul nsw i32 %175, %177
%179 = add nsw i32 %121, %178
%180 = ashr i32 %179, 24
%181 = trunc i32 %180 to i8
%182 = load i32*, i32** %16
%183 = bitcast i32* %182 to i8*
%184 = getelementptr inbounds i8, i8* %183, i64 2
store i8 %181, i8* %184
%185 = load i32*, i32** %30
%186 = bitcast i32* %185 to i8*
%187 = getelementptr inbounds i8, i8* %186, i64 1
%188 = load i8, i8* %187
%189 = zext i8 %188 to i32
%190 = shl i32 %189, 12
%191 = load i32*, i32** %30
%192 = getelementptr inbounds i32, i32* %191, i64 1
%193 = bitcast i32* %192 to i8*
%194 = getelementptr inbounds i8, i8* %193, i64 1
%195 = load i8, i8* %194
%196 = zext i8 %195 to i32
%197 = load i32*, i32** %30
%198 = bitcast i32* %197 to i8*
%199 = getelementptr inbounds i8, i8* %198, i64 1
%200 = load i8, i8* %199
%201 = zext i8 %200 to i32
%202 = sub nsw i32 %196, %201
%203 = load i32, i32* %23
%204 = and i32 %203, 4095
%205 = mul nsw i32 %202, %204
%206 = add nsw i32 %190, %205
%207 = shl i32 %206, 12
%208 = load i32*, i32** %30
%209 = load i32, i32* %17
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32, i32* %208, i64 %210
%212 = bitcast i32* %211 to i8*
%213 = getelementptr inbounds i8, i8* %212, i64 1
%214 = load i8, i8* %213
%215 = zext i8 %214 to i32
%216 = shl i32 %215, 12
%217 = load i32*, i32** %30
%218 = load i32, i32* %17
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i32, i32* %217, i64 %219
%221 = getelementptr inbounds i32, i32* %220, i64 1
%222 = bitcast i32* %221 to i8*
%223 = getelementptr inbounds i8, i8* %222, i64 1
%224 = load i8, i8* %223
%225 = zext i8 %224 to i32
%226 = load i32*, i32** %30
%227 = load i32, i32* %17
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32, i32* %226, i64 %228
%230 = bitcast i32* %229 to i8*
%231 = getelementptr inbounds i8, i8* %230, i64 1
%232 = load i8, i8* %231
%233 = zext i8 %232 to i32
%234 = sub nsw i32 %225, %233
%235 = load i32, i32* %23
%236 = and i32 %235, 4095
%237 = mul nsw i32 %234, %236
%238 = add nsw i32 %216, %237
%239 = load i32*, i32** %30
%240 = bitcast i32* %239 to i8*
%241 = getelementptr inbounds i8, i8* %240, i64 1
%242 = load i8, i8* %241
%243 = zext i8 %242 to i32
%244 = shl i32 %243, 12
%245 = load i32*, i32** %30
%246 = getelementptr inbounds i32, i32* %245, i64 1
%247 = bitcast i32* %246 to i8*
%248 = getelementptr inbounds i8, i8* %247, i64 1
%249 = load i8, i8* %248
%250 = zext i8 %249 to i32
%251 = load i32*, i32** %30
%252 = bitcast i32* %251 to i8*
%253 = getelementptr inbounds i8, i8* %252, i64 1
%254 = load i8, i8* %253
%255 = zext i8 %254 to i32
%256 = sub nsw i32 %250, %255
%257 = load i32, i32* %23
%258 = and i32 %257, 4095
%259 = mul nsw i32 %256, %258
%260 = add nsw i32 %244, %259
%261 = sub nsw i32 %238, %260
%262 = load i32, i32* %24
%263 = and i32 %262, 4095
%264 = mul nsw i32 %261, %263
%265 = add nsw i32 %207, %264
%266 = ashr i32 %265, 24
%267 = trunc i32 %266 to i8
%268 = load i32*, i32** %16
%269 = bitcast i32* %268 to i8*
%270 = getelementptr inbounds i8, i8* %269, i64 1
store i8 %267, i8* %270
%271 = load i32*, i32** %30
%272 = bitcast i32* %271 to i8*
%273 = getelementptr inbounds i8, i8* %272, i64 0
%274 = load i8, i8* %273
%275 = zext i8 %274 to i32
%276 = shl i32 %275, 12
%277 = load i32*, i32** %30
%278 = getelementptr inbounds i32, i32* %277, i64 1
%279 = bitcast i32* %278 to i8*
%280 = getelementptr inbounds i8, i8* %279, i64 0
%281 = load i8, i8* %280
%282 = zext i8 %281 to i32
%283 = load i32*, i32** %30
%284 = bitcast i32* %283 to i8*
%285 = getelementptr inbounds i8, i8* %284, i64 0
%286 = load i8, i8* %285
%287 = zext i8 %286 to i32
%288 = sub nsw i32 %282, %287
%289 = load i32, i32* %23
%290 = and i32 %289, 4095
%291 = mul nsw i32 %288, %290
%292 = add nsw i32 %276, %291
%293 = shl i32 %292, 12
%294 = load i32*, i32** %30
%295 = load i32, i32* %17
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds i32, i32* %294, i64 %296
%298 = bitcast i32* %297 to i8*
%299 = getelementptr inbounds i8, i8* %298, i64 0
%300 = load i8, i8* %299
%301 = zext i8 %300 to i32
%302 = shl i32 %301, 12
%303 = load i32*, i32** %30
%304 = load i32, i32* %17
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds i32, i32* %303, i64 %305
%307 = getelementptr inbounds i32, i32* %306, i64 1
%308 = bitcast i32* %307 to i8*
%309 = getelementptr inbounds i8, i8* %308, i64 0
%310 = load i8, i8* %309
%311 = zext i8 %310 to i32
%312 = load i32*, i32** %30
%313 = load i32, i32* %17
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %312, i64 %314
%316 = bitcast i32* %315 to i8*
%317 = getelementptr inbounds i8, i8* %316, i64 0
%318 = load i8, i8* %317
%319 = zext i8 %318 to i32
%320 = sub nsw i32 %311, %319
%321 = load i32, i32* %23
%322 = and i32 %321, 4095
%323 = mul nsw i32 %320, %322
%324 = add nsw i32 %302, %323
%325 = load i32*, i32** %30
%326 = bitcast i32* %325 to i8*
%327 = getelementptr inbounds i8, i8* %326, i64 0
%328 = load i8, i8* %327
%329 = zext i8 %328 to i32
%330 = shl i32 %329, 12
%331 = load i32*, i32** %30
%332 = getelementptr inbounds i32, i32* %331, i64 1
%333 = bitcast i32* %332 to i8*
%334 = getelementptr inbounds i8, i8* %333, i64 0
%335 = load i8, i8* %334
%336 = zext i8 %335 to i32
%337 = load i32*, i32** %30
%338 = bitcast i32* %337 to i8*
%339 = getelementptr inbounds i8, i8* %338, i64 0
%340 = load i8, i8* %339
%341 = zext i8 %340 to i32
%342 = sub nsw i32 %336, %341
%343 = load i32, i32* %23
%344 = and i32 %343, 4095
%345 = mul nsw i32 %342, %344
%346 = add nsw i32 %330, %345
%347 = sub nsw i32 %324, %346
%348 = load i32, i32* %24
%349 = and i32 %348, 4095
%350 = mul nsw i32 %347, %349
%351 = add nsw i32 %293, %350
%352 = ashr i32 %351, 24
%353 = trunc i32 %352 to i8
%354 = load i32*, i32** %16
%355 = bitcast i32* %354 to i8*
%356 = getelementptr inbounds i8, i8* %355, i64 0
store i8 %353, i8* %356
%357 = load i32*, i32** %30
%358 = bitcast i32* %357 to i8*
%359 = getelementptr inbounds i8, i8* %358, i64 3
%360 = load i8, i8* %359
%361 = zext i8 %360 to i32
%362 = shl i32 %361, 12
%363 = load i32*, i32** %30
%364 = getelementptr inbounds i32, i32* %363, i64 1
%365 = bitcast i32* %364 to i8*
%366 = getelementptr inbounds i8, i8* %365, i64 3
%367 = load i8, i8* %366
%368 = zext i8 %367 to i32
%369 = load i32*, i32** %30
%370 = bitcast i32* %369 to i8*
%371 = getelementptr inbounds i8, i8* %370, i64 3
%372 = load i8, i8* %371
%373 = zext i8 %372 to i32
%374 = sub nsw i32 %368, %373
%375 = load i32, i32* %23
%376 = and i32 %375, 4095
%377 = mul nsw i32 %374, %376
%378 = add nsw i32 %362, %377
%379 = shl i32 %378, 12
%380 = load i32*, i32** %30
%381 = load i32, i32* %17
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds i32, i32* %380, i64 %382
%384 = bitcast i32* %383 to i8*
%385 = getelementptr inbounds i8, i8* %384, i64 3
%386 = load i8, i8* %385
%387 = zext i8 %386 to i32
%388 = shl i32 %387, 12
%389 = load i32*, i32** %30
%390 = load i32, i32* %17
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i32, i32* %389, i64 %391
%393 = getelementptr inbounds i32, i32* %392, i64 1
%394 = bitcast i32* %393 to i8*
%395 = getelementptr inbounds i8, i8* %394, i64 3
%396 = load i8, i8* %395
%397 = zext i8 %396 to i32
%398 = load i32*, i32** %30
%399 = load i32, i32* %17
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i32, i32* %398, i64 %400
%402 = bitcast i32* %401 to i8*
%403 = getelementptr inbounds i8, i8* %402, i64 3
%404 = load i8, i8* %403
%405 = zext i8 %404 to i32
%406 = sub nsw i32 %397, %405
%407 = load i32, i32* %23
%408 = and i32 %407, 4095
%409 = mul nsw i32 %406, %408
%410 = add nsw i32 %388, %409
%411 = load i32*, i32** %30
%412 = bitcast i32* %411 to i8*
%413 = getelementptr inbounds i8, i8* %412, i64 3
%414 = load i8, i8* %413
%415 = zext i8 %414 to i32
%416 = shl i32 %415, 12
%417 = load i32*, i32** %30
%418 = getelementptr inbounds i32, i32* %417, i64 1
%419 = bitcast i32* %418 to i8*
%420 = getelementptr inbounds i8, i8* %419, i64 3
%421 = load i8, i8* %420
%422 = zext i8 %421 to i32
%423 = load i32*, i32** %30
%424 = bitcast i32* %423 to i8*
%425 = getelementptr inbounds i8, i8* %424, i64 3
%426 = load i8, i8* %425
%427 = zext i8 %426 to i32
%428 = sub nsw i32 %422, %427
%429 = load i32, i32* %23
%430 = and i32 %429, 4095
%431 = mul nsw i32 %428, %430
%432 = add nsw i32 %416, %431
%433 = sub nsw i32 %410, %432
%434 = load i32, i32* %24
%435 = and i32 %434, 4095
%436 = mul nsw i32 %433, %435
%437 = add nsw i32 %379, %436
%438 = ashr i32 %437, 24
%439 = trunc i32 %438 to i8
%440 = load i32*, i32** %16
%441 = bitcast i32* %440 to i8*
%442 = getelementptr inbounds i8, i8* %441, i64 3
store i8 %439, i8* %442
br label %443
443: ; preds = %98
br label %722
444: ; preds = %93
%445 = load i32, i32* %24
%446 = load i32, i32* %19
%447 = sub nsw i32 %445, %446
%448 = icmp ult i32 %447, 4096
br i1 %448, label %449, label %564
449: ; preds = %444
br label %450
450: ; preds = %449
%451 = load i32*, i32** %30
%452 = bitcast i32* %451 to i8*
%453 = getelementptr inbounds i8, i8* %452, i64 2
%454 = load i8, i8* %453
%455 = zext i8 %454 to i32
%456 = shl i32 %455, 12
%457 = load i32*, i32** %30
%458 = getelementptr inbounds i32, i32* %457, i64 1
%459 = bitcast i32* %458 to i8*
%460 = getelementptr inbounds i8, i8* %459, i64 2
%461 = load i8, i8* %460
%462 = zext i8 %461 to i32
%463 = load i32*, i32** %30
%464 = bitcast i32* %463 to i8*
%465 = getelementptr inbounds i8, i8* %464, i64 2
%466 = load i8, i8* %465
%467 = zext i8 %466 to i32
%468 = sub nsw i32 %462, %467
%469 = load i32, i32* %23
%470 = and i32 %469, 4095
%471 = mul nsw i32 %468, %470
%472 = add nsw i32 %456, %471
%473 = ashr i32 %472, 12
%474 = trunc i32 %473 to i8
%475 = load i32*, i32** %16
%476 = bitcast i32* %475 to i8*
%477 = getelementptr inbounds i8, i8* %476, i64 2
store i8 %474, i8* %477
%478 = load i32*, i32** %30
%479 = bitcast i32* %478 to i8*
%480 = getelementptr inbounds i8, i8* %479, i64 1
%481 = load i8, i8* %480
%482 = zext i8 %481 to i32
%483 = shl i32 %482, 12
%484 = load i32*, i32** %30
%485 = getelementptr inbounds i32, i32* %484, i64 1
%486 = bitcast i32* %485 to i8*
%487 = getelementptr inbounds i8, i8* %486, i64 1
%488 = load i8, i8* %487
%489 = zext i8 %488 to i32
%490 = load i32*, i32** %30
%491 = bitcast i32* %490 to i8*
%492 = getelementptr inbounds i8, i8* %491, i64 1
%493 = load i8, i8* %492
%494 = zext i8 %493 to i32
%495 = sub nsw i32 %489, %494
%496 = load i32, i32* %23
%497 = and i32 %496, 4095
%498 = mul nsw i32 %495, %497
%499 = add nsw i32 %483, %498
%500 = ashr i32 %499, 12
%501 = trunc i32 %500 to i8
%502 = load i32*, i32** %16
%503 = bitcast i32* %502 to i8*
%504 = getelementptr inbounds i8, i8* %503, i64 1
store i8 %501, i8* %504
%505 = load i32*, i32** %30
%506 = bitcast i32* %505 to i8*
%507 = getelementptr inbounds i8, i8* %506, i64 0
%508 = load i8, i8* %507
%509 = zext i8 %508 to i32
%510 = shl i32 %509, 12
%511 = load i32*, i32** %30
%512 = getelementptr inbounds i32, i32* %511, i64 1
%513 = bitcast i32* %512 to i8*
%514 = getelementptr inbounds i8, i8* %513, i64 0
%515 = load i8, i8* %514
%516 = zext i8 %515 to i32
%517 = load i32*, i32** %30
%518 = bitcast i32* %517 to i8*
%519 = getelementptr inbounds i8, i8* %518, i64 0
%520 = load i8, i8* %519
%521 = zext i8 %520 to i32
%522 = sub nsw i32 %516, %521
%523 = load i32, i32* %23
%524 = and i32 %523, 4095
%525 = mul nsw i32 %522, %524
%526 = add nsw i32 %510, %525
%527 = ashr i32 %526, 12
%528 = trunc i32 %527 to i8
%529 = load i32*, i32** %16
%530 = bitcast i32* %529 to i8*
%531 = getelementptr inbounds i8, i8* %530, i64 0
store i8 %528, i8* %531
%532 = load i32*, i32** %30
%533 = bitcast i32* %532 to i8*
%534 = getelementptr inbounds i8, i8* %533, i64 3
%535 = load i8, i8* %534
%536 = zext i8 %535 to i32
%537 = shl i32 %536, 12
%538 = load i32*, i32** %30
%539 = getelementptr inbounds i32, i32* %538, i64 1
%540 = bitcast i32* %539 to i8*
%541 = getelementptr inbounds i8, i8* %540, i64 3
%542 = load i8, i8* %541
%543 = zext i8 %542 to i32
%544 = load i32*, i32** %30
%545 = bitcast i32* %544 to i8*
%546 = getelementptr inbounds i8, i8* %545, i64 3
%547 = load i8, i8* %546
%548 = zext i8 %547 to i32
%549 = sub nsw i32 %543, %548
%550 = load i32, i32* %23
%551 = and i32 %550, 4095
%552 = mul nsw i32 %549, %551
%553 = add nsw i32 %537, %552
%554 = load i32, i32* %24
%555 = xor i32 %554, -1
%556 = and i32 %555, 4095
%557 = mul nsw i32 %553, %556
%558 = ashr i32 %557, 24
%559 = trunc i32 %558 to i8
%560 = load i32*, i32** %16
%561 = bitcast i32* %560 to i8*
%562 = getelementptr inbounds i8, i8* %561, i64 3
store i8 %559, i8* %562
br label %563
563: ; preds = %450
br label %721
564: ; preds = %444
%565 = load i32, i32* %24
%566 = xor i32 %565, -1
%567 = icmp ult i32 %566, 4096
br i1 %567, label %568, label %718
568: ; preds = %564
br label %569
569: ; preds = %568
%570 = load i32*, i32** %30
%571 = load i32, i32* %17
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds i32, i32* %570, i64 %572
%574 = bitcast i32* %573 to i8*
%575 = getelementptr inbounds i8, i8* %574, i64 2
%576 = load i8, i8* %575
%577 = zext i8 %576 to i32
%578 = shl i32 %577, 12
%579 = load i32*, i32** %30
%580 = load i32, i32* %17
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds i32, i32* %579, i64 %581
%583 = getelementptr inbounds i32, i32* %582, i64 1
%584 = bitcast i32* %583 to i8*
%585 = getelementptr inbounds i8, i8* %584, i64 2
%586 = load i8, i8* %585
%587 = zext i8 %586 to i32
%588 = load i32*, i32** %30
%589 = load i32, i32* %17
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds i32, i32* %588, i64 %590
%592 = bitcast i32* %591 to i8*
%593 = getelementptr inbounds i8, i8* %592, i64 2
%594 = load i8, i8* %593
%595 = zext i8 %594 to i32
%596 = sub nsw i32 %587, %595
%597 = load i32, i32* %23
%598 = and i32 %597, 4095
%599 = mul nsw i32 %596, %598
%600 = add nsw i32 %578, %599
%601 = ashr i32 %600, 12
%602 = trunc i32 %601 to i8
%603 = load i32*, i32** %16
%604 = bitcast i32* %603 to i8*
%605 = getelementptr inbounds i8, i8* %604, i64 2
store i8 %602, i8* %605
%606 = load i32*, i32** %30
%607 = load i32, i32* %17
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds i32, i32* %606, i64 %608
%610 = bitcast i32* %609 to i8*
%611 = getelementptr inbounds i8, i8* %610, i64 1
%612 = load i8, i8* %611
%613 = zext i8 %612 to i32
%614 = shl i32 %613, 12
%615 = load i32*, i32** %30
%616 = load i32, i32* %17
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds i32, i32* %615, i64 %617
%619 = getelementptr inbounds i32, i32* %618, i64 1
%620 = bitcast i32* %619 to i8*
%621 = getelementptr inbounds i8, i8* %620, i64 1
%622 = load i8, i8* %621
%623 = zext i8 %622 to i32
%624 = load i32*, i32** %30
%625 = load i32, i32* %17
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds i32, i32* %624, i64 %626
%628 = bitcast i32* %627 to i8*
%629 = getelementptr inbounds i8, i8* %628, i64 1
%630 = load i8, i8* %629
%631 = zext i8 %630 to i32
%632 = sub nsw i32 %623, %631
%633 = load i32, i32* %23
%634 = and i32 %633, 4095
%635 = mul nsw i32 %632, %634
%636 = add nsw i32 %614, %635
%637 = ashr i32 %636, 12
%638 = trunc i32 %637 to i8
%639 = load i32*, i32** %16
%640 = bitcast i32* %639 to i8*
%641 = getelementptr inbounds i8, i8* %640, i64 1
store i8 %638, i8* %641
%642 = load i32*, i32** %30
%643 = load i32, i32* %17
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds i32, i32* %642, i64 %644
%646 = bitcast i32* %645 to i8*
%647 = getelementptr inbounds i8, i8* %646, i64 0
%648 = load i8, i8* %647
%649 = zext i8 %648 to i32
%650 = shl i32 %649, 12
%651 = load i32*, i32** %30
%652 = load i32, i32* %17
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds i32, i32* %651, i64 %653
%655 = getelementptr inbounds i32, i32* %654, i64 1
%656 = bitcast i32* %655 to i8*
%657 = getelementptr inbounds i8, i8* %656, i64 0
%658 = load i8, i8* %657
%659 = zext i8 %658 to i32
%660 = load i32*, i32** %30
%661 = load i32, i32* %17
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds i32, i32* %660, i64 %662
%664 = bitcast i32* %663 to i8*
%665 = getelementptr inbounds i8, i8* %664, i64 0
%666 = load i8, i8* %665
%667 = zext i8 %666 to i32
%668 = sub nsw i32 %659, %667
%669 = load i32, i32* %23
%670 = and i32 %669, 4095
%671 = mul nsw i32 %668, %670
%672 = add nsw i32 %650, %671
%673 = ashr i32 %672, 12
%674 = trunc i32 %673 to i8
%675 = load i32*, i32** %16
%676 = bitcast i32* %675 to i8*
%677 = getelementptr inbounds i8, i8* %676, i64 0
store i8 %674, i8* %677
%678 = load i32*, i32** %30
%679 = load i32, i32* %17
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds i32, i32* %678, i64 %680
%682 = bitcast i32* %681 to i8*
%683 = getelementptr inbounds i8, i8* %682, i64 3
%684 = load i8, i8* %683
%685 = zext i8 %684 to i32
%686 = shl i32 %685, 12
%687 = load i32*, i32** %30
%688 = load i32, i32* %17
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds i32, i32* %687, i64 %689
%691 = getelementptr inbounds i32, i32* %690, i64 1
%692 = bitcast i32* %691 to i8*
%693 = getelementptr inbounds i8, i8* %692, i64 3
%694 = load i8, i8* %693
%695 = zext i8 %694 to i32
%696 = load i32*, i32** %30
%697 = load i32, i32* %17
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds i32, i32* %696, i64 %698
%700 = bitcast i32* %699 to i8*
%701 = getelementptr inbounds i8, i8* %700, i64 3
%702 = load i8, i8* %701
%703 = zext i8 %702 to i32
%704 = sub nsw i32 %695, %703
%705 = load i32, i32* %23
%706 = and i32 %705, 4095
%707 = mul nsw i32 %704, %706
%708 = add nsw i32 %686, %707
%709 = load i32, i32* %24
%710 = and i32 %709, 4095
%711 = mul nsw i32 %708, %710
%712 = ashr i32 %711, 24
%713 = trunc i32 %712 to i8
%714 = load i32*, i32** %16
%715 = bitcast i32* %714 to i8*
%716 = getelementptr inbounds i8, i8* %715, i64 3
store i8 %713, i8* %716
br label %717
717: ; preds = %569
br label %720
718: ; preds = %564
%719 = load i32*, i32** %16
store i32 0, i32* %719
br label %720
720: ; preds = %718, %717
br label %721
721: ; preds = %720, %563
br label %722
722: ; preds = %721, %443
br label %1129
723: ; preds = %78
%724 = load i32, i32* %23
%725 = load i32, i32* %18
%726 = sub nsw i32 %724, %725
%727 = icmp ult i32 %726, 4096
br i1 %727, label %728, label %919
728: ; preds = %723
%729 = load i32, i32* %24
%730 = load i32, i32* %19
%731 = icmp ult i32 %729, %730
br i1 %731, label %732, label %855
732: ; preds = %728
br label %733
733: ; preds = %732
%734 = load i32*, i32** %30
%735 = bitcast i32* %734 to i8*
%736 = getelementptr inbounds i8, i8* %735, i64 2
%737 = load i8, i8* %736
%738 = zext i8 %737 to i32
%739 = shl i32 %738, 12
%740 = load i32*, i32** %30
%741 = load i32, i32* %17
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds i32, i32* %740, i64 %742
%744 = bitcast i32* %743 to i8*
%745 = getelementptr inbounds i8, i8* %744, i64 2
%746 = load i8, i8* %745
%747 = zext i8 %746 to i32
%748 = load i32*, i32** %30
%749 = bitcast i32* %748 to i8*
%750 = getelementptr inbounds i8, i8* %749, i64 2
%751 = load i8, i8* %750
%752 = zext i8 %751 to i32
%753 = sub nsw i32 %747, %752
%754 = load i32, i32* %24
%755 = and i32 %754, 4095
%756 = mul nsw i32 %753, %755
%757 = add nsw i32 %739, %756
%758 = ashr i32 %757, 12
%759 = trunc i32 %758 to i8
%760 = load i32*, i32** %16
%761 = bitcast i32* %760 to i8*
%762 = getelementptr inbounds i8, i8* %761, i64 2
store i8 %759, i8* %762
%763 = load i32*, i32** %30
%764 = bitcast i32* %763 to i8*
%765 = getelementptr inbounds i8, i8* %764, i64 1
%766 = load i8, i8* %765
%767 = zext i8 %766 to i32
%768 = shl i32 %767, 12
%769 = load i32*, i32** %30
%770 = load i32, i32* %17
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds i32, i32* %769, i64 %771
%773 = bitcast i32* %772 to i8*
%774 = getelementptr inbounds i8, i8* %773, i64 1
%775 = load i8, i8* %774
%776 = zext i8 %775 to i32
%777 = load i32*, i32** %30
%778 = bitcast i32* %777 to i8*
%779 = getelementptr inbounds i8, i8* %778, i64 1
%780 = load i8, i8* %779
%781 = zext i8 %780 to i32
%782 = sub nsw i32 %776, %781
%783 = load i32, i32* %24
%784 = and i32 %783, 4095
%785 = mul nsw i32 %782, %784
%786 = add nsw i32 %768, %785
%787 = ashr i32 %786, 12
%788 = trunc i32 %787 to i8
%789 = load i32*, i32** %16
%790 = bitcast i32* %789 to i8*
%791 = getelementptr inbounds i8, i8* %790, i64 1
store i8 %788, i8* %791
%792 = load i32*, i32** %30
%793 = bitcast i32* %792 to i8*
%794 = getelementptr inbounds i8, i8* %793, i64 0
%795 = load i8, i8* %794
%796 = zext i8 %795 to i32
%797 = shl i32 %796, 12
%798 = load i32*, i32** %30
%799 = load i32, i32* %17
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds i32, i32* %798, i64 %800
%802 = bitcast i32* %801 to i8*
%803 = getelementptr inbounds i8, i8* %802, i64 0
%804 = load i8, i8* %803
%805 = zext i8 %804 to i32
%806 = load i32*, i32** %30
%807 = bitcast i32* %806 to i8*
%808 = getelementptr inbounds i8, i8* %807, i64 0
%809 = load i8, i8* %808
%810 = zext i8 %809 to i32
%811 = sub nsw i32 %805, %810
%812 = load i32, i32* %24
%813 = and i32 %812, 4095
%814 = mul nsw i32 %811, %813
%815 = add nsw i32 %797, %814
%816 = ashr i32 %815, 12
%817 = trunc i32 %816 to i8
%818 = load i32*, i32** %16
%819 = bitcast i32* %818 to i8*
%820 = getelementptr inbounds i8, i8* %819, i64 0
store i8 %817, i8* %820
%821 = load i32*, i32** %30
%822 = bitcast i32* %821 to i8*
%823 = getelementptr inbounds i8, i8* %822, i64 3
%824 = load i8, i8* %823
%825 = zext i8 %824 to i32
%826 = shl i32 %825, 12
%827 = load i32*, i32** %30
%828 = load i32, i32* %17
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds i32, i32* %827, i64 %829
%831 = bitcast i32* %830 to i8*
%832 = getelementptr inbounds i8, i8* %831, i64 3
%833 = load i8, i8* %832
%834 = zext i8 %833 to i32
%835 = load i32*, i32** %30
%836 = bitcast i32* %835 to i8*
%837 = getelementptr inbounds i8, i8* %836, i64 3
%838 = load i8, i8* %837
%839 = zext i8 %838 to i32
%840 = sub nsw i32 %834, %839
%841 = load i32, i32* %24
%842 = and i32 %841, 4095
%843 = mul nsw i32 %840, %842
%844 = add nsw i32 %826, %843
%845 = load i32, i32* %23
%846 = xor i32 %845, -1
%847 = and i32 %846, 4095
%848 = mul nsw i32 %844, %847
%849 = ashr i32 %848, 24
%850 = trunc i32 %849 to i8
%851 = load i32*, i32** %16
%852 = bitcast i32* %851 to i8*
%853 = getelementptr inbounds i8, i8* %852, i64 3
store i8 %850, i8* %853
br label %854
854: ; preds = %733
br label %918
855: ; preds = %728
%856 = load i32, i32* %24
%857 = load i32, i32* %19
%858 = sub nsw i32 %856, %857
%859 = icmp ult i32 %858, 4096
br i1 %859, label %860, label %884
860: ; preds = %855
br label %861
861: ; preds = %860
%862 = load i32*, i32** %30
%863 = load i32, i32* %862
%864 = load i32*, i32** %16
store i32 %863, i32* %864
%865 = load i32*, i32** %16
%866 = bitcast i32* %865 to i8*
%867 = getelementptr inbounds i8, i8* %866, i64 3
%868 = load i8, i8* %867
%869 = zext i8 %868 to i32
%870 = load i32, i32* %23
%871 = xor i32 %870, -1
%872 = and i32 %871, 4095
%873 = mul nsw i32 %869, %872
%874 = load i32, i32* %24
%875 = xor i32 %874, -1
%876 = and i32 %875, 4095
%877 = mul nsw i32 %873, %876
%878 = ashr i32 %877, 24
%879 = trunc i32 %878 to i8
%880 = load i32*, i32** %16
%881 = bitcast i32* %880 to i8*
%882 = getelementptr inbounds i8, i8* %881, i64 3
store i8 %879, i8* %882
br label %883
883: ; preds = %861
br label %917
884: ; preds = %855
%885 = load i32, i32* %24
%886 = xor i32 %885, -1
%887 = icmp ult i32 %886, 4096
br i1 %887, label %888, label %914
888: ; preds = %884
br label %889
889: ; preds = %888
%890 = load i32*, i32** %30
%891 = load i32, i32* %17
%892 = sext i32 %891 to i64
%893 = getelementptr inbounds i32, i32* %890, i64 %892
%894 = load i32, i32* %893
%895 = load i32*, i32** %16
store i32 %894, i32* %895
%896 = load i32*, i32** %16
%897 = bitcast i32* %896 to i8*
%898 = getelementptr inbounds i8, i8* %897, i64 3
%899 = load i8, i8* %898
%900 = zext i8 %899 to i32
%901 = load i32, i32* %23
%902 = xor i32 %901, -1
%903 = and i32 %902, 4095
%904 = mul nsw i32 %900, %903
%905 = load i32, i32* %24
%906 = and i32 %905, 4095
%907 = mul nsw i32 %904, %906
%908 = ashr i32 %907, 24
%909 = trunc i32 %908 to i8
%910 = load i32*, i32** %16
%911 = bitcast i32* %910 to i8*
%912 = getelementptr inbounds i8, i8* %911, i64 3
store i8 %909, i8* %912
br label %913
913: ; preds = %889
br label %916
914: ; preds = %884
%915 = load i32*, i32** %16
store i32 0, i32* %915
br label %916
916: ; preds = %914, %913
br label %917
917: ; preds = %916, %883
br label %918
918: ; preds = %917, %854
br label %1128
919: ; preds = %723
%920 = load i32, i32* %23
%921 = xor i32 %920, -1
%922 = icmp ult i32 %921, 4096
br i1 %922, label %923, label %1125
923: ; preds = %919
%924 = load i32, i32* %24
%925 = load i32, i32* %19
%926 = icmp ult i32 %924, %925
br i1 %926, label %927, label %1061
927: ; preds = %923
br label %928
928: ; preds = %927
%929 = load i32*, i32** %30
%930 = getelementptr inbounds i32, i32* %929, i64 1
%931 = bitcast i32* %930 to i8*
%932 = getelementptr inbounds i8, i8* %931, i64 2
%933 = load i8, i8* %932
%934 = zext i8 %933 to i32
%935 = shl i32 %934, 12
%936 = load i32*, i32** %30
%937 = load i32, i32* %17
%938 = sext i32 %937 to i64
%939 = getelementptr inbounds i32, i32* %936, i64 %938
%940 = getelementptr inbounds i32, i32* %939, i64 1
%941 = bitcast i32* %940 to i8*
%942 = getelementptr inbounds i8, i8* %941, i64 2
%943 = load i8, i8* %942
%944 = zext i8 %943 to i32
%945 = load i32*, i32** %30
%946 = getelementptr inbounds i32, i32* %945, i64 1
%947 = bitcast i32* %946 to i8*
%948 = getelementptr inbounds i8, i8* %947, i64 2
%949 = load i8, i8* %948
%950 = zext i8 %949 to i32
%951 = sub nsw i32 %944, %950
%952 = load i32, i32* %24
%953 = and i32 %952, 4095
%954 = mul nsw i32 %951, %953
%955 = add nsw i32 %935, %954
%956 = ashr i32 %955, 12
%957 = trunc i32 %956 to i8
%958 = load i32*, i32** %16
%959 = bitcast i32* %958 to i8*
%960 = getelementptr inbounds i8, i8* %959, i64 2
store i8 %957, i8* %960
%961 = load i32*, i32** %30
%962 = getelementptr inbounds i32, i32* %961, i64 1
%963 = bitcast i32* %962 to i8*
%964 = getelementptr inbounds i8, i8* %963, i64 1
%965 = load i8, i8* %964
%966 = zext i8 %965 to i32
%967 = shl i32 %966, 12
%968 = load i32*, i32** %30
%969 = load i32, i32* %17
%970 = sext i32 %969 to i64
%971 = getelementptr inbounds i32, i32* %968, i64 %970
%972 = getelementptr inbounds i32, i32* %971, i64 1
%973 = bitcast i32* %972 to i8*
%974 = getelementptr inbounds i8, i8* %973, i64 1
%975 = load i8, i8* %974
%976 = zext i8 %975 to i32
%977 = load i32*, i32** %30
%978 = getelementptr inbounds i32, i32* %977, i64 1
%979 = bitcast i32* %978 to i8*
%980 = getelementptr inbounds i8, i8* %979, i64 1
%981 = load i8, i8* %980
%982 = zext i8 %981 to i32
%983 = sub nsw i32 %976, %982
%984 = load i32, i32* %24
%985 = and i32 %984, 4095
%986 = mul nsw i32 %983, %985
%987 = add nsw i32 %967, %986
%988 = ashr i32 %987, 12
%989 = trunc i32 %988 to i8
%990 = load i32*, i32** %16
%991 = bitcast i32* %990 to i8*
%992 = getelementptr inbounds i8, i8* %991, i64 1
store i8 %989, i8* %992
%993 = load i32*, i32** %30
%994 = getelementptr inbounds i32, i32* %993, i64 1
%995 = bitcast i32* %994 to i8*
%996 = getelementptr inbounds i8, i8* %995, i64 0
%997 = load i8, i8* %996
%998 = zext i8 %997 to i32
%999 = shl i32 %998, 12
%1000 = load i32*, i32** %30
%1001 = load i32, i32* %17
%1002 = sext i32 %1001 to i64
%1003 = getelementptr inbounds i32, i32* %1000, i64 %1002
%1004 = getelementptr inbounds i32, i32* %1003, i64 1
%1005 = bitcast i32* %1004 to i8*
%1006 = getelementptr inbounds i8, i8* %1005, i64 0
%1007 = load i8, i8* %1006
%1008 = zext i8 %1007 to i32
%1009 = load i32*, i32** %30
%1010 = getelementptr inbounds i32, i32* %1009, i64 1
%1011 = bitcast i32* %1010 to i8*
%1012 = getelementptr inbounds i8, i8* %1011, i64 0
%1013 = load i8, i8* %1012
%1014 = zext i8 %1013 to i32
%1015 = sub nsw i32 %1008, %1014
%1016 = load i32, i32* %24
%1017 = and i32 %1016, 4095
%1018 = mul nsw i32 %1015, %1017
%1019 = add nsw i32 %999, %1018
%1020 = ashr i32 %1019, 12
%1021 = trunc i32 %1020 to i8
%1022 = load i32*, i32** %16
%1023 = bitcast i32* %1022 to i8*
%1024 = getelementptr inbounds i8, i8* %1023, i64 0
store i8 %1021, i8* %1024
%1025 = load i32*, i32** %30
%1026 = getelementptr inbounds i32, i32* %1025, i64 1
%1027 = bitcast i32* %1026 to i8*
%1028 = getelementptr inbounds i8, i8* %1027, i64 3
%1029 = load i8, i8* %1028
%1030 = zext i8 %1029 to i32
%1031 = shl i32 %1030, 12
%1032 = load i32*, i32** %30
%1033 = load i32, i32* %17
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds i32, i32* %1032, i64 %1034
%1036 = getelementptr inbounds i32, i32* %1035, i64 1
%1037 = bitcast i32* %1036 to i8*
%1038 = getelementptr inbounds i8, i8* %1037, i64 3
%1039 = load i8, i8* %1038
%1040 = zext i8 %1039 to i32
%1041 = load i32*, i32** %30
%1042 = getelementptr inbounds i32, i32* %1041, i64 1
%1043 = bitcast i32* %1042 to i8*
%1044 = getelementptr inbounds i8, i8* %1043, i64 3
%1045 = load i8, i8* %1044
%1046 = zext i8 %1045 to i32
%1047 = sub nsw i32 %1040, %1046
%1048 = load i32, i32* %24
%1049 = and i32 %1048, 4095
%1050 = mul nsw i32 %1047, %1049
%1051 = add nsw i32 %1031, %1050
%1052 = load i32, i32* %23
%1053 = and i32 %1052, 4095
%1054 = mul nsw i32 %1051, %1053
%1055 = ashr i32 %1054, 24
%1056 = trunc i32 %1055 to i8
%1057 = load i32*, i32** %16
%1058 = bitcast i32* %1057 to i8*
%1059 = getelementptr inbounds i8, i8* %1058, i64 3
store i8 %1056, i8* %1059
br label %1060
1060: ; preds = %928
br label %1124
1061: ; preds = %923
%1062 = load i32, i32* %24
%1063 = load i32, i32* %19
%1064 = sub nsw i32 %1062, %1063
%1065 = icmp ult i32 %1064, 4096
br i1 %1065, label %1066, label %1090
1066: ; preds = %1061
br label %1067
1067: ; preds = %1066
%1068 = load i32*, i32** %30
%1069 = getelementptr inbounds i32, i32* %1068, i64 1
%1070 = load i32, i32* %1069
%1071 = load i32*, i32** %16
store i32 %1070, i32* %1071
%1072 = load i32*, i32** %16
%1073 = bitcast i32* %1072 to i8*
%1074 = getelementptr inbounds i8, i8* %1073, i64 3
%1075 = load i8, i8* %1074
%1076 = zext i8 %1075 to i32
%1077 = load i32, i32* %23
%1078 = and i32 %1077, 4095
%1079 = mul nsw i32 %1076, %1078
%1080 = load i32, i32* %24
%1081 = xor i32 %1080, -1
%1082 = and i32 %1081, 4095
%1083 = mul nsw i32 %1079, %1082
%1084 = ashr i32 %1083, 24
%1085 = trunc i32 %1084 to i8
%1086 = load i32*, i32** %16
%1087 = bitcast i32* %1086 to i8*
%1088 = getelementptr inbounds i8, i8* %1087, i64 3
store i8 %1085, i8* %1088
br label %1089
1089: ; preds = %1067
br label %1123
1090: ; preds = %1061
%1091 = load i32, i32* %24
%1092 = xor i32 %1091, -1
%1093 = icmp ult i32 %1092, 4096
br i1 %1093, label %1094, label %1120
1094: ; preds = %1090
br label %1095
1095: ; preds = %1094
%1096 = load i32*, i32** %30
%1097 = load i32, i32* %17
%1098 = sext i32 %1097 to i64
%1099 = getelementptr inbounds i32, i32* %1096, i64 %1098
%1100 = getelementptr inbounds i32, i32* %1099, i64 1
%1101 = load i32, i32* %1100
%1102 = load i32*, i32** %16
store i32 %1101, i32* %1102
%1103 = load i32*, i32** %16
%1104 = bitcast i32* %1103 to i8*
%1105 = getelementptr inbounds i8, i8* %1104, i64 3
%1106 = load i8, i8* %1105
%1107 = zext i8 %1106 to i32
%1108 = load i32, i32* %23
%1109 = and i32 %1108, 4095
%1110 = mul nsw i32 %1107, %1109
%1111 = load i32, i32* %24
%1112 = and i32 %1111, 4095
%1113 = mul nsw i32 %1110, %1112
%1114 = ashr i32 %1113, 24
%1115 = trunc i32 %1114 to i8
%1116 = load i32*, i32** %16
%1117 = bitcast i32* %1116 to i8*
%1118 = getelementptr inbounds i8, i8* %1117, i64 3
store i8 %1115, i8* %1118
br label %1119
1119: ; preds = %1095
br label %1122
1120: ; preds = %1090
%1121 = load i32*, i32** %16
store i32 0, i32* %1121
br label %1122
1122: ; preds = %1120, %1119
br label %1123
1123: ; preds = %1122, %1089
br label %1124
1124: ; preds = %1123, %1060
br label %1127
1125: ; preds = %919
%1126 = load i32*, i32** %16
store i32 0, i32* %1126
br label %1127
1127: ; preds = %1125, %1124
br label %1128
1128: ; preds = %1127, %918
br label %1129
1129: ; preds = %1128, %722
%1130 = load i32, i32* %25
%1131 = load i32, i32* %23
%1132 = add nsw i32 %1131, %1130
store i32 %1132, i32* %23
%1133 = load i32, i32* %26
%1134 = load i32, i32* %24
%1135 = add nsw i32 %1134, %1133
store i32 %1135, i32* %24
%1136 = load i32*, i32** %16
%1137 = getelementptr inbounds i32, i32* %1136, i32 1
store i32* %1137, i32** %16
br label %1138
1138: ; preds = %1129
%1139 = load i32, i32* %29
%1140 = add nsw i32 %1139, -1
store i32 %1140, i32* %29
%1141 = icmp sge i32 %1140, 0
br i1 %1141, label %78, label %1142
1142: ; preds = %1138
%1143 = load i32, i32* %22
%1144 = add nsw i32 %1143, -1
store i32 %1144, i32* %22
%1145 = icmp sle i32 %1144, 0
br i1 %1145, label %1146, label %1147
1146: ; preds = %1142
br label %1168
1147: ; preds = %1142
%1148 = load i32, i32* %27
%1149 = load i32, i32* %21
%1150 = load i32, i32* %25
%1151 = mul nsw i32 %1149, %1150
%1152 = sub nsw i32 %1148, %1151
%1153 = load i32, i32* %23
%1154 = add nsw i32 %1153, %1152
store i32 %1154, i32* %23
%1155 = load i32, i32* %28
%1156 = load i32, i32* %21
%1157 = load i32, i32* %26
%1158 = mul nsw i32 %1156, %1157
%1159 = sub nsw i32 %1155, %1158
%1160 = load i32, i32* %24
%1161 = add nsw i32 %1160, %1159
store i32 %1161, i32* %24
%1162 = load i32, i32* %20
%1163 = load i32, i32* %21
%1164 = sub nsw i32 %1162, %1163
%1165 = load i32*, i32** %16
%1166 = sext i32 %1164 to i64
%1167 = getelementptr inbounds i32, i32* %1165, i64 %1166
store i32* %1167, i32** %16
br label %75
1168: ; preds = %36, %52, %1146
ret void
}

LLVM IR (-O2):
define void @__imlib_RotateAA(i32* %0, i32* %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13) {
%15 = icmp slt i32 %6, 1
%16 = icmp slt i32 %7, 1
%17 = or i1 %15, %16
br i1 %17, label %485, label %18
18: ; preds = %14
%19 = add nsw i32 %3, -1
%20 = add nsw i32 %4, -1
%21 = tail call i32 (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @__check_inside_coords to i32 (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ...)*)(i32 %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13, i32 %6, i32 %7, i32 %19, i32 %20)
%22 = icmp eq i32 %21, 0
br i1 %22, label %25, label %23
23: ; preds = %18
%24 = tail call i32 (i32*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @__imlib_RotateAAInside to i32 (i32*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, ...)*)(i32* %0, i32* %1, i32 %2, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13)
br label %485
25: ; preds = %18
%26 = shl i32 %3, 12
%27 = add i32 %26, -4096
%28 = shl i32 %4, 12
%29 = add i32 %28, -4096
%30 = sext i32 %2 to i64
%31 = mul nsw i32 %10, %6
%32 = sub i32 %12, %31
%33 = mul nsw i32 %11, %6
%34 = sub i32 %13, %33
%35 = sub nsw i32 %5, %6
%36 = sext i32 %35 to i64
br label %37
37: ; preds = %480, %25
%38 = phi i32 [ %9, %25 ], [ %483, %480 ]
%39 = phi i32 [ %8, %25 ], [ %482, %480 ]
%40 = phi i32 [ %7, %25 ], [ %481, %480 ]
%41 = phi i32* [ %1, %25 ], [ %484, %480 ]
br label %42
42: ; preds = %473, %37
%43 = phi i32 [ %38, %37 ], [ %475, %473 ]
%44 = phi i32 [ %39, %37 ], [ %474, %473 ]
%45 = phi i32 [ %6, %37 ], [ %47, %473 ]
%46 = phi i32* [ %41, %37 ], [ %476, %473 ]
%47 = add nsw i32 %45, -1
%48 = ashr i32 %44, 12
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i32, i32* %0, i64 %49
%51 = ashr i32 %43, 12
%52 = mul nsw i32 %51, %2
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32, i32* %50, i64 %53
%55 = icmp ult i32 %44, %27
br i1 %55, label %56, label %288
56: ; preds = %42
%57 = icmp ult i32 %43, %29
br i1 %57, label %58, label %172
58: ; preds = %56
%59 = bitcast i32* %54 to i8*
%60 = getelementptr inbounds i8, i8* %59, i64 2
%61 = load i8, i8* %60
%62 = zext i8 %61 to i32
%63 = shl nuw nsw i32 %62, 12
%64 = getelementptr inbounds i32, i32* %54, i64 1
%65 = bitcast i32* %64 to i8*
%66 = getelementptr inbounds i8, i8* %65, i64 2
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = sub nsw i32 %68, %62
%70 = and i32 %44, 4095
%71 = mul nsw i32 %69, %70
%72 = add nsw i32 %71, %63
%73 = shl i32 %72, 12
%74 = getelementptr inbounds i32, i32* %54, i64 %30
%75 = bitcast i32* %74 to i8*
%76 = getelementptr inbounds i8, i8* %75, i64 2
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = shl nuw nsw i32 %78, 12
%80 = getelementptr inbounds i32, i32* %74, i64 1
%81 = bitcast i32* %80 to i8*
%82 = getelementptr inbounds i8, i8* %81, i64 2
%83 = load i8, i8* %82
%84 = zext i8 %83 to i32
%85 = sub nsw i32 %84, %78
%86 = mul nsw i32 %85, %70
%87 = sub nsw i32 %79, %72
%88 = add nsw i32 %87, %86
%89 = and i32 %43, 4095
%90 = mul nsw i32 %88, %89
%91 = add nsw i32 %90, %73
%92 = lshr i32 %91, 24
%93 = trunc i32 %92 to i8
%94 = bitcast i32* %46 to i8*
%95 = getelementptr inbounds i8, i8* %94, i64 2
store i8 %93, i8* %95
%96 = getelementptr inbounds i8, i8* %59, i64 1
%97 = load i8, i8* %96
%98 = zext i8 %97 to i32
%99 = shl nuw nsw i32 %98, 12
%100 = getelementptr inbounds i8, i8* %65, i64 1
%101 = load i8, i8* %100
%102 = zext i8 %101 to i32
%103 = sub nsw i32 %102, %98
%104 = mul nsw i32 %103, %70
%105 = add nsw i32 %104, %99
%106 = shl i32 %105, 12
%107 = getelementptr inbounds i8, i8* %75, i64 1
%108 = load i8, i8* %107
%109 = zext i8 %108 to i32
%110 = shl nuw nsw i32 %109, 12
%111 = getelementptr inbounds i8, i8* %81, i64 1
%112 = load i8, i8* %111
%113 = zext i8 %112 to i32
%114 = sub nsw i32 %113, %109
%115 = mul nsw i32 %114, %70
%116 = sub nsw i32 %110, %105
%117 = add nsw i32 %116, %115
%118 = mul nsw i32 %117, %89
%119 = add nsw i32 %118, %106
%120 = lshr i32 %119, 24
%121 = trunc i32 %120 to i8
%122 = getelementptr inbounds i8, i8* %94, i64 1
store i8 %121, i8* %122
%123 = load i8, i8* %59
%124 = zext i8 %123 to i32
%125 = shl nuw nsw i32 %124, 12
%126 = load i8, i8* %65
%127 = zext i8 %126 to i32
%128 = sub nsw i32 %127, %124
%129 = mul nsw i32 %128, %70
%130 = add nsw i32 %129, %125
%131 = shl i32 %130, 12
%132 = load i8, i8* %75
%133 = zext i8 %132 to i32
%134 = shl nuw nsw i32 %133, 12
%135 = load i8, i8* %81
%136 = zext i8 %135 to i32
%137 = sub nsw i32 %136, %133
%138 = mul nsw i32 %137, %70
%139 = sub nsw i32 %134, %130
%140 = add nsw i32 %139, %138
%141 = mul nsw i32 %140, %89
%142 = add nsw i32 %141, %131
%143 = lshr i32 %142, 24
%144 = trunc i32 %143 to i8
store i8 %144, i8* %94
%145 = getelementptr inbounds i8, i8* %59, i64 3
%146 = load i8, i8* %145
%147 = zext i8 %146 to i32
%148 = shl nuw nsw i32 %147, 12
%149 = getelementptr inbounds i8, i8* %65, i64 3
%150 = load i8, i8* %149
%151 = zext i8 %150 to i32
%152 = sub nsw i32 %151, %147
%153 = mul nsw i32 %152, %70
%154 = add nsw i32 %153, %148
%155 = shl i32 %154, 12
%156 = getelementptr inbounds i8, i8* %75, i64 3
%157 = load i8, i8* %156
%158 = zext i8 %157 to i32
%159 = shl nuw nsw i32 %158, 12
%160 = getelementptr inbounds i8, i8* %81, i64 3
%161 = load i8, i8* %160
%162 = zext i8 %161 to i32
%163 = sub nsw i32 %162, %158
%164 = mul nsw i32 %163, %70
%165 = sub nsw i32 %159, %154
%166 = add nsw i32 %165, %164
%167 = mul nsw i32 %166, %89
%168 = add nsw i32 %167, %155
%169 = lshr i32 %168, 24
%170 = trunc i32 %169 to i8
%171 = getelementptr inbounds i8, i8* %94, i64 3
store i8 %170, i8* %171
br label %473
172: ; preds = %56
%173 = sub nsw i32 %43, %29
%174 = icmp ult i32 %173, 4096
br i1 %174, label %175, label %230
175: ; preds = %172
%176 = bitcast i32* %54 to i8*
%177 = getelementptr inbounds i8, i8* %176, i64 2
%178 = load i8, i8* %177
%179 = zext i8 %178 to i32
%180 = getelementptr inbounds i32, i32* %54, i64 1
%181 = bitcast i32* %180 to i8*
%182 = getelementptr inbounds i8, i8* %181, i64 2
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = sub nsw i32 %184, %179
%186 = and i32 %44, 4095
%187 = mul nsw i32 %185, %186
%188 = lshr i32 %187, 12
%189 = trunc i32 %188 to i8
%190 = add i8 %178, %189
%191 = bitcast i32* %46 to i8*
%192 = getelementptr inbounds i8, i8* %191, i64 2
store i8 %190, i8* %192
%193 = getelementptr inbounds i8, i8* %176, i64 1
%194 = load i8, i8* %193
%195 = zext i8 %194 to i32
%196 = getelementptr inbounds i8, i8* %181, i64 1
%197 = load i8, i8* %196
%198 = zext i8 %197 to i32
%199 = sub nsw i32 %198, %195
%200 = mul nsw i32 %199, %186
%201 = lshr i32 %200, 12
%202 = trunc i32 %201 to i8
%203 = add i8 %194, %202
%204 = getelementptr inbounds i8, i8* %191, i64 1
store i8 %203, i8* %204
%205 = load i8, i8* %176
%206 = zext i8 %205 to i32
%207 = load i8, i8* %181
%208 = zext i8 %207 to i32
%209 = sub nsw i32 %208, %206
%210 = mul nsw i32 %209, %186
%211 = lshr i32 %210, 12
%212 = trunc i32 %211 to i8
%213 = add i8 %205, %212
store i8 %213, i8* %191
%214 = getelementptr inbounds i8, i8* %176, i64 3
%215 = load i8, i8* %214
%216 = zext i8 %215 to i32
%217 = shl nuw nsw i32 %216, 12
%218 = getelementptr inbounds i8, i8* %181, i64 3
%219 = load i8, i8* %218
%220 = zext i8 %219 to i32
%221 = sub nsw i32 %220, %216
%222 = mul nsw i32 %221, %186
%223 = add nsw i32 %222, %217
%224 = and i32 %43, 4095
%225 = xor i32 %224, 4095
%226 = mul nsw i32 %223, %225
%227 = lshr i32 %226, 24
%228 = trunc i32 %227 to i8
%229 = getelementptr inbounds i8, i8* %191, i64 3
store i8 %228, i8* %229
br label %473
230: ; preds = %172
%231 = icmp ugt i32 %43, -4097
br i1 %231, label %232, label %287
232: ; preds = %230
%233 = getelementptr inbounds i32, i32* %54, i64 %30
%234 = bitcast i32* %233 to i8*
%235 = getelementptr inbounds i8, i8* %234, i64 2
%236 = load i8, i8* %235
%237 = zext i8 %236 to i32
%238 = getelementptr inbounds i32, i32* %233, i64 1
%239 = bitcast i32* %238 to i8*
%240 = getelementptr inbounds i8, i8* %239, i64 2
%241 = load i8, i8* %240
%242 = zext i8 %241 to i32
%243 = sub nsw i32 %242, %237
%244 = and i32 %44, 4095
%245 = mul nsw i32 %243, %244
%246 = lshr i32 %245, 12
%247 = trunc i32 %246 to i8
%248 = add i8 %236, %247
%249 = bitcast i32* %46 to i8*
%250 = getelementptr inbounds i8, i8* %249, i64 2
store i8 %248, i8* %250
%251 = getelementptr inbounds i8, i8* %234, i64 1
%252 = load i8, i8* %251
%253 = zext i8 %252 to i32
%254 = getelementptr inbounds i8, i8* %239, i64 1
%255 = load i8, i8* %254
%256 = zext i8 %255 to i32
%257 = sub nsw i32 %256, %253
%258 = mul nsw i32 %257, %244
%259 = lshr i32 %258, 12
%260 = trunc i32 %259 to i8
%261 = add i8 %252, %260
%262 = getelementptr inbounds i8, i8* %249, i64 1
store i8 %261, i8* %262
%263 = load i8, i8* %234
%264 = zext i8 %263 to i32
%265 = load i8, i8* %239
%266 = zext i8 %265 to i32
%267 = sub nsw i32 %266, %264
%268 = mul nsw i32 %267, %244
%269 = lshr i32 %268, 12
%270 = trunc i32 %269 to i8
%271 = add i8 %263, %270
store i8 %271, i8* %249
%272 = getelementptr inbounds i8, i8* %234, i64 3
%273 = load i8, i8* %272
%274 = zext i8 %273 to i32
%275 = shl nuw nsw i32 %274, 12
%276 = getelementptr inbounds i8, i8* %239, i64 3
%277 = load i8, i8* %276
%278 = zext i8 %277 to i32
%279 = sub nsw i32 %278, %274
%280 = mul nsw i32 %279, %244
%281 = add nsw i32 %280, %275
%282 = and i32 %43, 4095
%283 = mul nsw i32 %281, %282
%284 = lshr i32 %283, 24
%285 = trunc i32 %284 to i8
%286 = getelementptr inbounds i8, i8* %249, i64 3
store i8 %285, i8* %286
br label %473
287: ; preds = %230
store i32 0, i32* %46
br label %473
288: ; preds = %42
%289 = sub nsw i32 %44, %27
%290 = icmp ult i32 %289, 4096
br i1 %290, label %291, label %380
291: ; preds = %288
%292 = icmp ult i32 %43, %29
br i1 %292, label %293, label %348
293: ; preds = %291
%294 = bitcast i32* %54 to i8*
%295 = getelementptr inbounds i8, i8* %294, i64 2
%296 = load i8, i8* %295
%297 = zext i8 %296 to i32
%298 = getelementptr inbounds i32, i32* %54, i64 %30
%299 = bitcast i32* %298 to i8*
%300 = getelementptr inbounds i8, i8* %299, i64 2
%301 = load i8, i8* %300
%302 = zext i8 %301 to i32
%303 = sub nsw i32 %302, %297
%304 = and i32 %43, 4095
%305 = mul nsw i32 %303, %304
%306 = lshr i32 %305, 12
%307 = trunc i32 %306 to i8
%308 = add i8 %296, %307
%309 = bitcast i32* %46 to i8*
%310 = getelementptr inbounds i8, i8* %309, i64 2
store i8 %308, i8* %310
%311 = getelementptr inbounds i8, i8* %294, i64 1
%312 = load i8, i8* %311
%313 = zext i8 %312 to i32
%314 = getelementptr inbounds i8, i8* %299, i64 1
%315 = load i8, i8* %314
%316 = zext i8 %315 to i32
%317 = sub nsw i32 %316, %313
%318 = mul nsw i32 %317, %304
%319 = lshr i32 %318, 12
%320 = trunc i32 %319 to i8
%321 = add i8 %312, %320
%322 = getelementptr inbounds i8, i8* %309, i64 1
store i8 %321, i8* %322
%323 = load i8, i8* %294
%324 = zext i8 %323 to i32
%325 = load i8, i8* %299
%326 = zext i8 %325 to i32
%327 = sub nsw i32 %326, %324
%328 = mul nsw i32 %327, %304
%329 = lshr i32 %328, 12
%330 = trunc i32 %329 to i8
%331 = add i8 %323, %330
store i8 %331, i8* %309
%332 = getelementptr inbounds i8, i8* %294, i64 3
%333 = load i8, i8* %332
%334 = zext i8 %333 to i32
%335 = shl nuw nsw i32 %334, 12
%336 = getelementptr inbounds i8, i8* %299, i64 3
%337 = load i8, i8* %336
%338 = zext i8 %337 to i32
%339 = sub nsw i32 %338, %334
%340 = mul nsw i32 %339, %304
%341 = add nsw i32 %340, %335
%342 = and i32 %44, 4095
%343 = xor i32 %342, 4095
%344 = mul nsw i32 %341, %343
%345 = lshr i32 %344, 24
%346 = trunc i32 %345 to i8
%347 = getelementptr inbounds i8, i8* %309, i64 3
store i8 %346, i8* %347
br label %473
348: ; preds = %291
%349 = sub nsw i32 %43, %29
%350 = icmp ult i32 %349, 4096
br i1 %350, label %351, label %364
351: ; preds = %348
%352 = load i32, i32* %54
store i32 %352, i32* %46
%353 = bitcast i32* %46 to i8*
%354 = getelementptr inbounds i8, i8* %353, i64 3
%355 = lshr i32 %352, 24
%356 = and i32 %44, 4095
%357 = xor i32 %356, 4095
%358 = and i32 %43, 4095
%359 = xor i32 %358, 4095
%360 = mul nuw nsw i32 %357, %359
%361 = mul nuw i32 %360, %355
%362 = lshr i32 %361, 24
%363 = trunc i32 %362 to i8
store i8 %363, i8* %354
br label %473
364: ; preds = %348
%365 = icmp ugt i32 %43, -4097
br i1 %365, label %366, label %379
366: ; preds = %364
%367 = getelementptr inbounds i32, i32* %54, i64 %30
%368 = load i32, i32* %367
store i32 %368, i32* %46
%369 = bitcast i32* %46 to i8*
%370 = getelementptr inbounds i8, i8* %369, i64 3
%371 = lshr i32 %368, 24
%372 = and i32 %44, 4095
%373 = xor i32 %372, 4095
%374 = and i32 %43, 4095
%375 = mul nuw nsw i32 %373, %374
%376 = mul nuw i32 %375, %371
%377 = lshr i32 %376, 24
%378 = trunc i32 %377 to i8
store i8 %378, i8* %370
br label %473
379: ; preds = %364
store i32 0, i32* %46
br label %473
380: ; preds = %288
%381 = icmp ugt i32 %44, -4097
br i1 %381, label %382, label %472
382: ; preds = %380
%383 = icmp ult i32 %43, %29
br i1 %383, label %384, label %440
384: ; preds = %382
%385 = getelementptr inbounds i32, i32* %54, i64 1
%386 = bitcast i32* %385 to i8*
%387 = getelementptr inbounds i8, i8* %386, i64 2
%388 = load i8, i8* %387
%389 = zext i8 %388 to i32
%390 = getelementptr inbounds i32, i32* %54, i64 %30
%391 = getelementptr inbounds i32, i32* %390, i64 1
%392 = bitcast i32* %391 to i8*
%393 = getelementptr inbounds i8, i8* %392, i64 2
%394 = load i8, i8* %393
%395 = zext i8 %394 to i32
%396 = sub nsw i32 %395, %389
%397 = and i32 %43, 4095
%398 = mul nsw i32 %396, %397
%399 = lshr i32 %398, 12
%400 = trunc i32 %399 to i8
%401 = add i8 %388, %400
%402 = bitcast i32* %46 to i8*
%403 = getelementptr inbounds i8, i8* %402, i64 2
store i8 %401, i8* %403
%404 = getelementptr inbounds i8, i8* %386, i64 1
%405 = load i8, i8* %404
%406 = zext i8 %405 to i32
%407 = getelementptr inbounds i8, i8* %392, i64 1
%408 = load i8, i8* %407
%409 = zext i8 %408 to i32
%410 = sub nsw i32 %409, %406
%411 = mul nsw i32 %410, %397
%412 = lshr i32 %411, 12
%413 = trunc i32 %412 to i8
%414 = add i8 %405, %413
%415 = getelementptr inbounds i8, i8* %402, i64 1
store i8 %414, i8* %415
%416 = load i8, i8* %386
%417 = zext i8 %416 to i32
%418 = load i8, i8* %392
%419 = zext i8 %418 to i32
%420 = sub nsw i32 %419, %417
%421 = mul nsw i32 %420, %397
%422 = lshr i32 %421, 12
%423 = trunc i32 %422 to i8
%424 = add i8 %416, %423
store i8 %424, i8* %402
%425 = getelementptr inbounds i8, i8* %386, i64 3
%426 = load i8, i8* %425
%427 = zext i8 %426 to i32
%428 = shl nuw nsw i32 %427, 12
%429 = getelementptr inbounds i8, i8* %392, i64 3
%430 = load i8, i8* %429
%431 = zext i8 %430 to i32
%432 = sub nsw i32 %431, %427
%433 = mul nsw i32 %432, %397
%434 = add nsw i32 %433, %428
%435 = and i32 %44, 4095
%436 = mul nsw i32 %434, %435
%437 = lshr i32 %436, 24
%438 = trunc i32 %437 to i8
%439 = getelementptr inbounds i8, i8* %402, i64 3
store i8 %438, i8* %439
br label %473
440: ; preds = %382
%441 = sub nsw i32 %43, %29
%442 = icmp ult i32 %441, 4096
br i1 %442, label %443, label %456
443: ; preds = %440
%444 = getelementptr inbounds i32, i32* %54, i64 1
%445 = load i32, i32* %444
store i32 %445, i32* %46
%446 = bitcast i32* %46 to i8*
%447 = getelementptr inbounds i8, i8* %446, i64 3
%448 = lshr i32 %445, 24
%449 = and i32 %44, 4095
%450 = and i32 %43, 4095
%451 = xor i32 %450, 4095
%452 = mul nuw nsw i32 %451, %449
%453 = mul nuw i32 %452, %448
%454 = lshr i32 %453, 24
%455 = trunc i32 %454 to i8
store i8 %455, i8* %447
br label %473
456: ; preds = %440
%457 = icmp ugt i32 %43, -4097
br i1 %457, label %458, label %471
458: ; preds = %456
%459 = getelementptr inbounds i32, i32* %54, i64 %30
%460 = getelementptr inbounds i32, i32* %459, i64 1
%461 = load i32, i32* %460
store i32 %461, i32* %46
%462 = bitcast i32* %46 to i8*
%463 = getelementptr inbounds i8, i8* %462, i64 3
%464 = lshr i32 %461, 24
%465 = and i32 %44, 4095
%466 = and i32 %43, 4095
%467 = mul nuw nsw i32 %465, %466
%468 = mul nuw i32 %467, %464
%469 = lshr i32 %468, 24
%470 = trunc i32 %469 to i8
store i8 %470, i8* %463
br label %473
471: ; preds = %456
store i32 0, i32* %46
br label %473
472: ; preds = %380
store i32 0, i32* %46
br label %473
473: ; preds = %351, %379, %366, %293, %384, %458, %471, %443, %472, %58, %232, %287, %175
%474 = add nsw i32 %44, %10
%475 = add nsw i32 %43, %11
%476 = getelementptr inbounds i32, i32* %46, i64 1
%477 = icmp sgt i32 %45, 1
br i1 %477, label %42, label %478
478: ; preds = %473
%479 = icmp slt i32 %40, 2
br i1 %479, label %485, label %480
480: ; preds = %478
%481 = add nsw i32 %40, -1
%482 = add nsw i32 %32, %474
%483 = add nsw i32 %34, %475
%484 = getelementptr inbounds i32, i32* %476, i64 %36
br label %37
485: ; preds = %478, %14, %23
ret void
}