void movepix(image1, bitpix1, w1, x1, y1, image2, bitpix2, w2, x2,
             y2) char *image1;
int bitpix1;
int w1;
int x1, y1;
char *image2;
int bitpix2;
int w2;
int x2, y2;
{
  short *ims1, *ims2;
  int *imi1, *imi2;
  unsigned short *imu1, *imu2;
  float rpix, *imr1, *imr2;
  double dpix, *imd1, *imd2;
  switch (bitpix1) {
  case 8:
    switch (bitpix2) {
    case 8:
      image2[(y2 * w2) + x2] = image1[(y1 * w1) + x1];
      break;
    case 16:
      ims2 = (short *)image2;
      ims2[(y2 * w2) + x2] = image1[(y1 * w1) + x1];
      break;
    case 32:
      imi2 = (int *)image2;
      imi2[(y2 * w2) + x2] = (int)image1[(y1 * w1) + x1];
      break;
    case -16:
      imu2 = (unsigned short *)image2;
      imu2[(y2 * w2) + x2] = (unsigned short)image1[(y1 * w1) + x1];
      break;
    case -32:
      imr2 = (float *)image2;
      imr2[(y2 * w2) + x2] = (float)image1[(y1 * w1) + x1];
      break;
    case -64:
      imd2 = (double *)image2;
      imd2[(y2 * w2) + x2] = (double)image1[(y1 * w1) + x1];
      break;
    }
    break;
  case 16:
    switch (bitpix2) {
    case 8:
      ims1 = (short *)image1;
      image2[(y2 * w2) + x2] = (char)ims1[(y1 * w1) + x1];
      break;
    case 16:
      ims1 = (short *)image1;
      ims2 = (short *)image2;
      ims2[(y2 * w2) + x2] = ims1[(y1 * w1) + x1];
      break;
    case 32:
      ims1 = (short *)image1;
      imi2 = (int *)image2;
      imi2[(y2 * w2) + x2] = (int)ims1[(y1 * w1) + x1];
      break;
    case -16:
      ims1 = (short *)image1;
      imu2 = (unsigned short *)image2;
      imu2[(y2 * w2) + x2] = (unsigned short)ims1[(y1 * w1) + x1];
      break;
    case -32:
      ims1 = (short *)image1;
      imr2 = (float *)image2;
      imr2[(y2 * w2) + x2] = (float)ims1[(y1 * w1) + x1];
      break;
    case -64:
      ims1 = (short *)image1;
      imd2 = (double *)image2;
      imd2[(y2 * w2) + x2] = (double)ims1[(y1 * w1) + x1];
      break;
    }
    break;
  case 32:
    switch (bitpix2) {
    case 8:
      imi1 = (int *)image1;
      image2[(y2 * w2) + x2] = (char)imi1[(y1 * w1) + x1];
      break;
    case 16:
      imi1 = (int *)image1;
      ims2 = (short *)image2;
      ims2[(y2 * w2) + x2] = (short)imi1[(y1 * w1) + x1];
      break;
    case 32:
      imi1 = (int *)image1;
      imi2 = (int *)image2;
      imi2[(y2 * w2) + x2] = imi1[(y1 * w1) + x1];
      break;
    case -16:
      imi1 = (int *)image1;
      imu2 = (unsigned short *)image2;
      imu2[(y2 * w2) + x2] = (unsigned short)imi1[(y1 * w1) + x1];
      break;
    case -32:
      imi1 = (int *)image1;
      imr2 = (float *)image2;
      imr2[(y2 * w2) + x2] = (float)imi1[(y1 * w1) + x1];
      break;
    case -64:
      imi1 = (int *)image1;
      imd2 = (double *)image2;
      imd2[(y2 * w2) + x2] = (double)imi1[(y1 * w1) + x1];
      break;
    }
    break;
  case -16:
    switch (bitpix2) {
    case 8:
      imu1 = (unsigned short *)image1;
      image2[(y2 * w2) + x2] = (char)imu1[(y1 * w1) + x1];
      break;
    case 16:
      imu1 = (unsigned short *)image1;
      ims2 = (short *)image2;
      ims2[(y2 * w2) + x2] = (short)imu1[(y1 * w1) + x1];
      break;
    case 32:
      imu1 = (unsigned short *)image1;
      imi2 = (int *)image2;
      imi2[(y2 * w2) + x2] = (int)imu1[(y1 * w1) + x1];
      break;
    case -16:
      imu1 = (unsigned short *)image1;
      imu2 = (unsigned short *)image2;
      imu2[(y2 * w2) + x2] = imu1[(y1 * w1) + x1];
      break;
    case -32:
      imu1 = (unsigned short *)image1;
      imr2 = (float *)image2;
      imr2[(y2 * w2) + x2] = (float)imu1[(y1 * w1) + x1];
      break;
    case -64:
      imu1 = (unsigned short *)image1;
      imd2 = (double *)image2;
      imd2[(y2 * w2) + x2] = (double)imu1[(y1 * w1) + x1];
      break;
    }
    break;
  case -32:
    imr1 = (float *)image1;
    rpix = imr1[(y1 * w1) + x1];
    switch (bitpix2) {
    case 8:
      if (rpix < 0.0)
        image2[(y2 * w2) + x2] = (char)(rpix - 0.5);
      else
        image2[(y2 * w2) + x2] = (char)(rpix + 0.5);
      break;
    case 16:
      ims2 = (short *)image2;
      if (rpix < 0.0)
        ims2[(y2 * w2) + x2] = (short)(rpix - 0.5);
      else
        ims2[(y2 * w2) + x2] = (short)(rpix + 0.5);
      break;
    case 32:
      imi2 = (int *)image2;
      if (rpix < 0.0)
        imi2[(y2 * w2) + x2] = (int)(rpix - 0.5);
      else
        imi2[(y2 * w2) + x2] = (int)(rpix + 0.5);
      break;
    case -16:
      imu2 = (unsigned short *)image2;
      if (rpix < 0.0)
        imu2[(y2 * w2) + x2] = (unsigned short)0;
      else
        imu2[(y2 * w2) + x2] = (unsigned short)(rpix + 0.5);
      break;
    case -32:
      imr2 = (float *)image2;
      imr2[(y2 * w2) + x2] = rpix;
      break;
    case -64:
      imd2 = (double *)image2;
      imd2[(y2 * w2) + x2] = (double)rpix;
      break;
    }
    break;
  case -64:
    imd1 = (double *)image1;
    dpix = imd1[(y1 * w1) + x1];
    switch (bitpix2) {
    case 8:
      imd1 = (double *)image1;
      if (dpix < 0.0)
        image2[(y2 * w2) + x2] = (char)(dpix - 0.5);
      else
        image2[(y2 * w2) + x2] = (char)(dpix + 0.5);
      break;
    case 16:
      ims2 = (short *)image2;
      if (dpix < 0.0)
        ims2[(y2 * w2) + x2] = (short)(dpix - 0.5);
      else
        ims2[(y2 * w2) + x2] = (short)(dpix + 0.5);
      break;
    case 32:
      imi2 = (int *)image2;
      if (dpix < 0.0)
        imi2[(y2 * w2) + x2] = (int)(dpix - 0.5);
      else
        imi2[(y2 * w2) + x2] = (int)(dpix + 0.5);
      break;
    case -16:
      imu2 = (unsigned short *)image2;
      if (dpix < 0.0)
        imu2[(y2 * w2) + x2] = (unsigned short)0;
      else
        imu2[(y2 * w2) + x2] = (unsigned short)(dpix + 0.5);
      break;
    case -32:
      imr2 = (float *)image2;
      imr2[(y2 * w2) + x2] = (float)dpix;
      break;
    case -64:
      imd2 = (double *)image2;
      imd2[(y2 * w2) + x2] = dpix;
      break;
    }
    break;
  }
  return;
}


x86 assembly (clang, -O0):
<movepix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x84(%rbp)
sub    $0xffffffc0,%eax
je     1c57 <movepix+0xb57>
jmp    1140 <movepix+0x40>
mov    -0x84(%rbp),%eax
sub    $0xffffffe0,%eax
je     1967 <movepix+0x867>
jmp    1154 <movepix+0x54>
mov    -0x84(%rbp),%eax
sub    $0xfffffff0,%eax
je     1768 <movepix+0x668>
jmp    1168 <movepix+0x68>
mov    -0x84(%rbp),%eax
sub    $0x8,%eax
je     11a4 <movepix+0xa4>
jmp    117c <movepix+0x7c>
mov    -0x84(%rbp),%eax
sub    $0x10,%eax
je     1376 <movepix+0x276>
jmp    1190 <movepix+0x90>
mov    -0x84(%rbp),%eax
sub    $0x20,%eax
je     1575 <movepix+0x475>
jmp    1f0f <movepix+0xe0f>
mov    0x10(%rbp),%eax
mov    %eax,-0x88(%rbp)
sub    $0xffffffc0,%eax
je     1336 <movepix+0x236>
jmp    11bb <movepix+0xbb>
mov    -0x88(%rbp),%eax
sub    $0xffffffe0,%eax
je     12f6 <movepix+0x1f6>
jmp    11cf <movepix+0xcf>
mov    -0x88(%rbp),%eax
sub    $0xfffffff0,%eax
je     12bc <movepix+0x1bc>
jmp    11e3 <movepix+0xe3>
mov    -0x88(%rbp),%eax
sub    $0x8,%eax
je     121f <movepix+0x11f>
jmp    11f7 <movepix+0xf7>
mov    -0x88(%rbp),%eax
sub    $0x10,%eax
je     124c <movepix+0x14c>
jmp    120b <movepix+0x10b>
mov    -0x88(%rbp),%eax
sub    $0x20,%eax
je     1286 <movepix+0x186>
jmp    1371 <movepix+0x271>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1371 <movepix+0x271>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %ax,%dx
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1371 <movepix+0x271>
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1371 <movepix+0x271>
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %ax,%dx
mov    -0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1371 <movepix+0x271>
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
mov    -0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1371 <movepix+0x271>
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cvtsi2sd %eax,%xmm0
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f0f <movepix+0xe0f>
mov    0x10(%rbp),%eax
mov    %eax,-0x8c(%rbp)
sub    $0xffffffc0,%eax
je     152d <movepix+0x42d>
jmp    138d <movepix+0x28d>
mov    -0x8c(%rbp),%eax
sub    $0xffffffe0,%eax
je     14e5 <movepix+0x3e5>
jmp    13a1 <movepix+0x2a1>
mov    -0x8c(%rbp),%eax
sub    $0xfffffff0,%eax
je     14a6 <movepix+0x3a6>
jmp    13b5 <movepix+0x2b5>
mov    -0x8c(%rbp),%eax
sub    $0x8,%eax
je     13f1 <movepix+0x2f1>
jmp    13c9 <movepix+0x2c9>
mov    -0x8c(%rbp),%eax
sub    $0x10,%eax
je     1429 <movepix+0x329>
jmp    13dd <movepix+0x2dd>
mov    -0x8c(%rbp),%eax
sub    $0x20,%eax
je     1468 <movepix+0x368>
jmp    1570 <movepix+0x470>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%ax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1570 <movepix+0x470>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1570 <movepix+0x470>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%edx
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1570 <movepix+0x470>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1570 <movepix+0x470>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm0
mov    -0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1570 <movepix+0x470>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2sd %eax,%xmm0
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f0f <movepix+0xe0f>
mov    0x10(%rbp),%eax
mov    %eax,-0x90(%rbp)
sub    $0xffffffc0,%eax
je     1727 <movepix+0x627>
jmp    158c <movepix+0x48c>
mov    -0x90(%rbp),%eax
sub    $0xffffffe0,%eax
je     16e6 <movepix+0x5e6>
jmp    15a0 <movepix+0x4a0>
mov    -0x90(%rbp),%eax
sub    $0xfffffff0,%eax
je     16a5 <movepix+0x5a5>
jmp    15b4 <movepix+0x4b4>
mov    -0x90(%rbp),%eax
sub    $0x8,%eax
je     15f0 <movepix+0x4f0>
jmp    15c8 <movepix+0x4c8>
mov    -0x90(%rbp),%eax
sub    $0x10,%eax
je     1627 <movepix+0x527>
jmp    15dc <movepix+0x4dc>
mov    -0x90(%rbp),%eax
sub    $0x20,%eax
je     1668 <movepix+0x568>
jmp    1763 <movepix+0x663>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1763 <movepix+0x663>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %ax,%dx
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1763 <movepix+0x663>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1763 <movepix+0x663>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %ax,%dx
mov    -0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1763 <movepix+0x663>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1763 <movepix+0x663>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f0f <movepix+0xe0f>
mov    0x10(%rbp),%eax
mov    %eax,-0x94(%rbp)
sub    $0xffffffc0,%eax
je     191f <movepix+0x81f>
jmp    177f <movepix+0x67f>
mov    -0x94(%rbp),%eax
sub    $0xffffffe0,%eax
je     18d7 <movepix+0x7d7>
jmp    1793 <movepix+0x693>
mov    -0x94(%rbp),%eax
sub    $0xfffffff0,%eax
je     1898 <movepix+0x798>
jmp    17a7 <movepix+0x6a7>
mov    -0x94(%rbp),%eax
sub    $0x8,%eax
je     17e3 <movepix+0x6e3>
jmp    17bb <movepix+0x6bb>
mov    -0x94(%rbp),%eax
sub    $0x10,%eax
je     181b <movepix+0x71b>
jmp    17cf <movepix+0x6cf>
mov    -0x94(%rbp),%eax
sub    $0x20,%eax
je     185a <movepix+0x75a>
jmp    1962 <movepix+0x862>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%ax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1962 <movepix+0x862>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1962 <movepix+0x862>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1962 <movepix+0x862>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1962 <movepix+0x862>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm0
mov    -0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1962 <movepix+0x862>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%eax
cvtsi2sd %eax,%xmm0
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f0f <movepix+0xe0f>
mov    -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x98(%rbp)
sub    $0xffffffc0,%eax
je     1c2b <movepix+0xb2b>
jmp    19a5 <movepix+0x8a5>
mov    -0x98(%rbp),%eax
sub    $0xffffffe0,%eax
je     1c03 <movepix+0xb03>
jmp    19b9 <movepix+0x8b9>
mov    -0x98(%rbp),%eax
sub    $0xfffffff0,%eax
je     1b93 <movepix+0xa93>
jmp    19cd <movepix+0x8cd>
mov    -0x98(%rbp),%eax
sub    $0x8,%eax
je     1a09 <movepix+0x909>
jmp    19e1 <movepix+0x8e1>
mov    -0x98(%rbp),%eax
sub    $0x10,%eax
je     1a87 <movepix+0x987>
jmp    19f5 <movepix+0x8f5>
mov    -0x98(%rbp),%eax
sub    $0x20,%eax
je     1b11 <movepix+0xa11>
jmp    1c52 <movepix+0xb52>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1a53 <movepix+0x953>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5d8(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1a82 <movepix+0x982>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x59c(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1c52 <movepix+0xb52>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1adb <movepix+0x9db>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x552(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1b0c <movepix+0xa0c>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x514(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1c52 <movepix+0xb52>
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1b61 <movepix+0xa61>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4c0(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1b8e <movepix+0xa8e>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x48e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1c52 <movepix+0xb52>
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1bcd <movepix+0xacd>
mov    -0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movw   $0x0,(%rax,%rcx,2)
jmp    1bfe <movepix+0xafe>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x422(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1c52 <movepix+0xb52>
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1c52 <movepix+0xb52>
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f0f <movepix+0xe0f>
mov    -0x8(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x10(%rbp),%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x9c(%rbp)
sub    $0xffffffc0,%eax
je     1ee7 <movepix+0xde7>
jmp    1c95 <movepix+0xb95>
mov    -0x9c(%rbp),%eax
sub    $0xffffffe0,%eax
je     1ebb <movepix+0xdbb>
jmp    1ca9 <movepix+0xba9>
mov    -0x9c(%rbp),%eax
sub    $0xfffffff0,%eax
je     1e57 <movepix+0xd57>
jmp    1cbd <movepix+0xbbd>
mov    -0x9c(%rbp),%eax
sub    $0x8,%eax
je     1cf9 <movepix+0xbf9>
jmp    1cd1 <movepix+0xbd1>
mov    -0x9c(%rbp),%eax
sub    $0x10,%eax
je     1d6f <movepix+0xc6f>
jmp    1ce5 <movepix+0xbe5>
mov    -0x9c(%rbp),%eax
sub    $0x20,%eax
je     1de9 <movepix+0xce9>
jmp    1f0a <movepix+0xe0a>
mov    -0x8(%rbp),%rax
mov    %rax,-0x78(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1d3f <movepix+0xc3f>
movsd  -0x70(%rbp),%xmm0
movsd  0x2ec(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1d6a <movepix+0xc6a>
movsd  -0x70(%rbp),%xmm0
movsd  0x2b4(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1f0a <movepix+0xe0a>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1db7 <movepix+0xcb7>
movsd  -0x70(%rbp),%xmm0
movsd  0x276(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1de4 <movepix+0xce4>
movsd  -0x70(%rbp),%xmm0
movsd  0x23c(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1f0a <movepix+0xe0a>
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1e2d <movepix+0xd2d>
movsd  -0x70(%rbp),%xmm0
movsd  0x1f4(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1e52 <movepix+0xd52>
movsd  0x1cb(%rip),%xmm0
addsd  -0x70(%rbp),%xmm0
cvttsd2si %xmm0,%edx
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1f0a <movepix+0xe0a>
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1e89 <movepix+0xd89>
mov    -0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movw   $0x0,(%rax,%rcx,2)
jmp    1eb6 <movepix+0xdb6>
movsd  -0x70(%rbp),%xmm0
movsd  0x16a(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x50(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1f0a <movepix+0xe0a>
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x68(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1f0a <movepix+0xe0a>
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x80(%rbp),%rax
mov    0x28(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f0f <movepix+0xe0f>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<movepix>:
push   %rbp
push   %rbx
add    $0x40,%esi
rol    $0x1d,%esi
cmp    $0xc,%esi
ja     150d <movepix+0x40d>
mov    0x30(%rsp),%ebp
mov    0x28(%rsp),%r10d
mov    0x20(%rsp),%r11d
mov    0x18(%rsp),%ebx
lea    0xee6(%rip),%rax
movslq (%rax,%rsi,4),%rsi
add    %rax,%rsi
jmp    *%rsi
add    $0x40,%ebx
rol    $0x1d,%ebx
cmp    $0xc,%ebx
ja     150d <movepix+0x40d>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movsd  (%rdi,%rax,8),%xmm0
lea    0xeec(%rip),%rax
movslq (%rax,%rbx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
cvtsd2ss %xmm0,%xmm0
jmp    1477 <movepix+0x377>
add    $0x40,%ebx
rol    $0x1d,%ebx
cmp    $0xc,%ebx
ja     150d <movepix+0x40d>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movss  (%rdi,%rax,4),%xmm0
lea    0xee9(%rip),%rax
movslq (%rax,%rbx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
cvtss2sd %xmm0,%xmm0
jmp    1450 <movepix+0x350>
add    $0x40,%ebx
rol    $0x1d,%ebx
cmp    $0xc,%ebx
ja     150d <movepix+0x40d>
lea    0xef5(%rip),%rax
movslq (%rax,%rbx,4),%rsi
add    %rax,%rsi
jmp    *%rsi
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movzwl (%rdi,%rax,2),%eax
jmp    144c <movepix+0x34c>
add    $0x40,%ebx
rol    $0x1d,%ebx
cmp    $0xc,%ebx
ja     150d <movepix+0x40d>
lea    0xf5f(%rip),%rax
movslq (%rax,%rbx,4),%rsi
add    %rax,%rsi
jmp    *%rsi
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movsbl (%rdi,%rax,1),%eax
jmp    14e2 <movepix+0x3e2>
add    $0x40,%ebx
rol    $0x1d,%ebx
cmp    $0xc,%ebx
ja     150d <movepix+0x40d>
lea    0xef9(%rip),%rax
movslq (%rax,%rbx,4),%rsi
add    %rax,%rsi
jmp    *%rsi
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movzwl (%rdi,%rax,2),%eax
jmp    1261 <movepix+0x161>
add    $0x40,%ebx
rol    $0x1d,%ebx
cmp    $0xc,%ebx
ja     150d <movepix+0x40d>
lea    0xe96(%rip),%rax
movslq (%rax,%rbx,4),%rsi
add    %rax,%rsi
jmp    *%rsi
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movzwl (%rdi,%rax,4),%eax
imul   %r11d,%ebp
add    %r10d,%ebp
movslq %ebp,%rcx
mov    %ax,(%r9,%rcx,2)
jmp    150d <movepix+0x40d>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
mov    (%rdi,%rax,2),%al
jmp    13f9 <movepix+0x2f9>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja     12ff <movepix+0x1ff>
jmp    14ac <movepix+0x3ac>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    148c <movepix+0x38c>
addsd  0xd5c(%rip),%xmm0
cvttsd2si %xmm0,%eax
jmp    14c6 <movepix+0x3c6>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    14ac <movepix+0x3ac>
addsd  0xd3d(%rip),%xmm0
cvttsd2si %xmm0,%eax
jmp    14e2 <movepix+0x3e2>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    149a <movepix+0x39a>
addsd  0xd1e(%rip),%xmm0
cvttsd2si %xmm0,%eax
jmp    14ff <movepix+0x3ff>
xorps  %xmm1,%xmm1
ucomiss %xmm0,%xmm1
jbe    14a8 <movepix+0x3a8>
imul   %r11d,%ebp
add    %r10d,%ebp
movslq %ebp,%rax
movw   $0x0,(%r9,%rax,2)
jmp    150d <movepix+0x40d>
cvtss2sd %xmm0,%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm0,%xmm2
jbe    14ba <movepix+0x3ba>
addsd  0xcdb(%rip),%xmm1
jmp    14c2 <movepix+0x3c2>
cvtss2sd %xmm0,%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm0,%xmm2
jbe    14d6 <movepix+0x3d6>
addsd  0xcbe(%rip),%xmm1
jmp    14de <movepix+0x3de>
cvtss2sd %xmm0,%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm0,%xmm2
jbe    14f3 <movepix+0x3f3>
addsd  0xca1(%rip),%xmm1
jmp    14fb <movepix+0x3fb>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movzwl (%rdi,%rax,2),%eax
jmp    1473 <movepix+0x373>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movzwl (%rdi,%rax,2),%eax
jmp    14ff <movepix+0x3ff>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
mov    (%rdi,%rax,1),%al
jmp    13f9 <movepix+0x2f9>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movsbl (%rdi,%rax,1),%eax
jmp    14ff <movepix+0x3ff>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movswl (%rdi,%rax,2),%eax
jmp    14ff <movepix+0x3ff>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
cvtsi2sdl (%rdi,%rax,4),%xmm0
jmp    1450 <movepix+0x350>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
cvtsi2ssl (%rdi,%rax,4),%xmm0
jmp    1477 <movepix+0x377>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
mov    (%rdi,%rax,4),%al
imul   %r11d,%ebp
add    %r10d,%ebp
movslq %ebp,%rcx
mov    %al,(%r9,%rcx,1)
jmp    150d <movepix+0x40d>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
mov    (%rdi,%rax,4),%eax
jmp    14ff <movepix+0x3ff>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movsbl (%rdi,%rax,1),%eax
jmp    144c <movepix+0x34c>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movsbl (%rdi,%rax,1),%eax
jmp    1473 <movepix+0x373>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movswl (%rdi,%rax,2),%eax
cvtsi2sd %eax,%xmm0
imul   %r11d,%ebp
add    %r10d,%ebp
movslq %ebp,%rax
movsd  %xmm0,(%r9,%rax,8)
jmp    150d <movepix+0x40d>
imul   %edx,%r8d
add    %ecx,%r8d
movslq %r8d,%rax
movswl (%rdi,%rax,2),%eax
cvtsi2ss %eax,%xmm0
imul   %r11d,%ebp
add    %r10d,%ebp
movslq %ebp,%rax
movss  %xmm0,(%r9,%rax,4)
jmp    150d <movepix+0x40d>
addsd  0xb6c(%rip),%xmm0
cvttsd2si %xmm0,%eax
jmp    14c6 <movepix+0x3c6>
addsd  0xb5e(%rip),%xmm0
cvttsd2si %xmm0,%eax
jmp    14ff <movepix+0x3ff>
cvtss2sd %xmm0,%xmm0
addsd  0xb4c(%rip),%xmm0
cvttsd2si %xmm0,%eax
jmp    14e2 <movepix+0x3e2>
addsd  0xb3e(%rip),%xmm1
cvttsd2si %xmm1,%eax
imul   %r11d,%ebp
add    %r10d,%ebp
movslq %ebp,%rcx
mov    %al,(%r9,%rcx,1)
jmp    150d <movepix+0x40d>
addsd  0xb22(%rip),%xmm1
cvttsd2si %xmm1,%eax
imul   %r11d,%ebp
add    %r10d,%ebp
movslq %ebp,%rcx
mov    %ax,(%r9,%rcx,2)
jmp    150d <movepix+0x40d>
addsd  0xb05(%rip),%xmm1
cvttsd2si %xmm1,%eax
imul   %r11d,%ebp
add    %r10d,%ebp
movslq %ebp,%rcx
mov    %eax,(%r9,%rcx,4)
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define void @movepix(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i8* %5, i32 %6, i32 %7, i32 %8, i32 %9) {
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i8*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i16*
%22 = alloca i16*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i16*
%26 = alloca i16*
%27 = alloca float
%28 = alloca float*
%29 = alloca float*
%30 = alloca double
%31 = alloca double*
%32 = alloca double*
store i8* %0, i8** %11
store i32 %1, i32* %12
store i32 %2, i32* %13
store i32 %3, i32* %14
store i32 %4, i32* %15
store i8* %5, i8** %16
store i32 %6, i32* %17
store i32 %7, i32* %18
store i32 %8, i32* %19
store i32 %9, i32* %20
%33 = load i32, i32* %12
switch i32 %33, label %893 [
i32 8, label %34
i32 16, label %160
i32 32, label %297
i32 -16, label %435
i32 -32, label %572
i32 -64, label %737
]
34: ; preds = %10
%35 = load i32, i32* %17
switch i32 %35, label %159 [
i32 8, label %36
i32 16, label %54
i32 32, label %75
i32 -16, label %96
i32 -32, label %117
i32 -64, label %138
]
36: ; preds = %34
%37 = load i8*, i8** %11
%38 = load i32, i32* %15
%39 = load i32, i32* %13
%40 = mul nsw i32 %38, %39
%41 = load i32, i32* %14
%42 = add nsw i32 %40, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %37, i64 %43
%45 = load i8, i8* %44
%46 = load i8*, i8** %16
%47 = load i32, i32* %20
%48 = load i32, i32* %18
%49 = mul nsw i32 %47, %48
%50 = load i32, i32* %19
%51 = add nsw i32 %49, %50
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %46, i64 %52
store i8 %45, i8* %53
br label %159
54: ; preds = %34
%55 = load i8*, i8** %16
%56 = bitcast i8* %55 to i16*
store i16* %56, i16** %22
%57 = load i8*, i8** %11
%58 = load i32, i32* %15
%59 = load i32, i32* %13
%60 = mul nsw i32 %58, %59
%61 = load i32, i32* %14
%62 = add nsw i32 %60, %61
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %57, i64 %63
%65 = load i8, i8* %64
%66 = sext i8 %65 to i16
%67 = load i16*, i16** %22
%68 = load i32, i32* %20
%69 = load i32, i32* %18
%70 = mul nsw i32 %68, %69
%71 = load i32, i32* %19
%72 = add nsw i32 %70, %71
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i16, i16* %67, i64 %73
store i16 %66, i16* %74
br label %159
75: ; preds = %34
%76 = load i8*, i8** %16
%77 = bitcast i8* %76 to i32*
store i32* %77, i32** %24
%78 = load i8*, i8** %11
%79 = load i32, i32* %15
%80 = load i32, i32* %13
%81 = mul nsw i32 %79, %80
%82 = load i32, i32* %14
%83 = add nsw i32 %81, %82
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i8, i8* %78, i64 %84
%86 = load i8, i8* %85
%87 = sext i8 %86 to i32
%88 = load i32*, i32** %24
%89 = load i32, i32* %20
%90 = load i32, i32* %18
%91 = mul nsw i32 %89, %90
%92 = load i32, i32* %19
%93 = add nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %88, i64 %94
store i32 %87, i32* %95
br label %159
96: ; preds = %34
%97 = load i8*, i8** %16
%98 = bitcast i8* %97 to i16*
store i16* %98, i16** %26
%99 = load i8*, i8** %11
%100 = load i32, i32* %15
%101 = load i32, i32* %13
%102 = mul nsw i32 %100, %101
%103 = load i32, i32* %14
%104 = add nsw i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %99, i64 %105
%107 = load i8, i8* %106
%108 = sext i8 %107 to i16
%109 = load i16*, i16** %26
%110 = load i32, i32* %20
%111 = load i32, i32* %18
%112 = mul nsw i32 %110, %111
%113 = load i32, i32* %19
%114 = add nsw i32 %112, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i16, i16* %109, i64 %115
store i16 %108, i16* %116
br label %159
117: ; preds = %34
%118 = load i8*, i8** %16
%119 = bitcast i8* %118 to float*
store float* %119, float** %29
%120 = load i8*, i8** %11
%121 = load i32, i32* %15
%122 = load i32, i32* %13
%123 = mul nsw i32 %121, %122
%124 = load i32, i32* %14
%125 = add nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %120, i64 %126
%128 = load i8, i8* %127
%129 = sitofp i8 %128 to float
%130 = load float*, float** %29
%131 = load i32, i32* %20
%132 = load i32, i32* %18
%133 = mul nsw i32 %131, %132
%134 = load i32, i32* %19
%135 = add nsw i32 %133, %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* %130, i64 %136
store float %129, float* %137
br label %159
138: ; preds = %34
%139 = load i8*, i8** %16
%140 = bitcast i8* %139 to double*
store double* %140, double** %32
%141 = load i8*, i8** %11
%142 = load i32, i32* %15
%143 = load i32, i32* %13
%144 = mul nsw i32 %142, %143
%145 = load i32, i32* %14
%146 = add nsw i32 %144, %145
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i8, i8* %141, i64 %147
%149 = load i8, i8* %148
%150 = sitofp i8 %149 to double
%151 = load double*, double** %32
%152 = load i32, i32* %20
%153 = load i32, i32* %18
%154 = mul nsw i32 %152, %153
%155 = load i32, i32* %19
%156 = add nsw i32 %154, %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %151, i64 %157
store double %150, double* %158
br label %159
159: ; preds = %34, %138, %117, %96, %75, %54, %36
br label %893
160: ; preds = %10
%161 = load i32, i32* %17
switch i32 %161, label %296 [
i32 8, label %162
i32 16, label %183
i32 32, label %205
i32 -16, label %228
i32 -32, label %250
i32 -64, label %273
]
162: ; preds = %160
%163 = load i8*, i8** %11
%164 = bitcast i8* %163 to i16*
store i16* %164, i16** %21
%165 = load i16*, i16** %21
%166 = load i32, i32* %15
%167 = load i32, i32* %13
%168 = mul nsw i32 %166, %167
%169 = load i32, i32* %14
%170 = add nsw i32 %168, %169
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i16, i16* %165, i64 %171
%173 = load i16, i16* %172
%174 = trunc i16 %173 to i8
%175 = load i8*, i8** %16
%176 = load i32, i32* %20
%177 = load i32, i32* %18
%178 = mul nsw i32 %176, %177
%179 = load i32, i32* %19
%180 = add nsw i32 %178, %179
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %175, i64 %181
store i8 %174, i8* %182
br label %296
183: ; preds = %160
%184 = load i8*, i8** %11
%185 = bitcast i8* %184 to i16*
store i16* %185, i16** %21
%186 = load i8*, i8** %16
%187 = bitcast i8* %186 to i16*
store i16* %187, i16** %22
%188 = load i16*, i16** %21
%189 = load i32, i32* %15
%190 = load i32, i32* %13
%191 = mul nsw i32 %189, %190
%192 = load i32, i32* %14
%193 = add nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i16, i16* %188, i64 %194
%196 = load i16, i16* %195
%197 = load i16*, i16** %22
%198 = load i32, i32* %20
%199 = load i32, i32* %18
%200 = mul nsw i32 %198, %199
%201 = load i32, i32* %19
%202 = add nsw i32 %200, %201
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i16, i16* %197, i64 %203
store i16 %196, i16* %204
br label %296
205: ; preds = %160
%206 = load i8*, i8** %11
%207 = bitcast i8* %206 to i16*
store i16* %207, i16** %21
%208 = load i8*, i8** %16
%209 = bitcast i8* %208 to i32*
store i32* %209, i32** %24
%210 = load i16*, i16** %21
%211 = load i32, i32* %15
%212 = load i32, i32* %13
%213 = mul nsw i32 %211, %212
%214 = load i32, i32* %14
%215 = add nsw i32 %213, %214
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i16, i16* %210, i64 %216
%218 = load i16, i16* %217
%219 = sext i16 %218 to i32
%220 = load i32*, i32** %24
%221 = load i32, i32* %20
%222 = load i32, i32* %18
%223 = mul nsw i32 %221, %222
%224 = load i32, i32* %19
%225 = add nsw i32 %223, %224
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i32, i32* %220, i64 %226
store i32 %219, i32* %227
br label %296
228: ; preds = %160
%229 = load i8*, i8** %11
%230 = bitcast i8* %229 to i16*
store i16* %230, i16** %21
%231 = load i8*, i8** %16
%232 = bitcast i8* %231 to i16*
store i16* %232, i16** %26
%233 = load i16*, i16** %21
%234 = load i32, i32* %15
%235 = load i32, i32* %13
%236 = mul nsw i32 %234, %235
%237 = load i32, i32* %14
%238 = add nsw i32 %236, %237
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i16, i16* %233, i64 %239
%241 = load i16, i16* %240
%242 = load i16*, i16** %26
%243 = load i32, i32* %20
%244 = load i32, i32* %18
%245 = mul nsw i32 %243, %244
%246 = load i32, i32* %19
%247 = add nsw i32 %245, %246
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i16, i16* %242, i64 %248
store i16 %241, i16* %249
br label %296
250: ; preds = %160
%251 = load i8*, i8** %11
%252 = bitcast i8* %251 to i16*
store i16* %252, i16** %21
%253 = load i8*, i8** %16
%254 = bitcast i8* %253 to float*
store float* %254, float** %29
%255 = load i16*, i16** %21
%256 = load i32, i32* %15
%257 = load i32, i32* %13
%258 = mul nsw i32 %256, %257
%259 = load i32, i32* %14
%260 = add nsw i32 %258, %259
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i16, i16* %255, i64 %261
%263 = load i16, i16* %262
%264 = sitofp i16 %263 to float
%265 = load float*, float** %29
%266 = load i32, i32* %20
%267 = load i32, i32* %18
%268 = mul nsw i32 %266, %267
%269 = load i32, i32* %19
%270 = add nsw i32 %268, %269
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* %265, i64 %271
store float %264, float* %272
br label %296
273: ; preds = %160
%274 = load i8*, i8** %11
%275 = bitcast i8* %274 to i16*
store i16* %275, i16** %21
%276 = load i8*, i8** %16
%277 = bitcast i8* %276 to double*
store double* %277, double** %32
%278 = load i16*, i16** %21
%279 = load i32, i32* %15
%280 = load i32, i32* %13
%281 = mul nsw i32 %279, %280
%282 = load i32, i32* %14
%283 = add nsw i32 %281, %282
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i16, i16* %278, i64 %284
%286 = load i16, i16* %285
%287 = sitofp i16 %286 to double
%288 = load double*, double** %32
%289 = load i32, i32* %20
%290 = load i32, i32* %18
%291 = mul nsw i32 %289, %290
%292 = load i32, i32* %19
%293 = add nsw i32 %291, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %288, i64 %294
store double %287, double* %295
br label %296
296: ; preds = %160, %273, %250, %228, %205, %183, %162
br label %893
297: ; preds = %10
%298 = load i32, i32* %17
switch i32 %298, label %434 [
i32 8, label %299
i32 16, label %320
i32 32, label %343
i32 -16, label %365
i32 -32, label %388
i32 -64, label %411
]
299: ; preds = %297
%300 = load i8*, i8** %11
%301 = bitcast i8* %300 to i32*
store i32* %301, i32** %23
%302 = load i32*, i32** %23
%303 = load i32, i32* %15
%304 = load i32, i32* %13
%305 = mul nsw i32 %303, %304
%306 = load i32, i32* %14
%307 = add nsw i32 %305, %306
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds i32, i32* %302, i64 %308
%310 = load i32, i32* %309
%311 = trunc i32 %310 to i8
%312 = load i8*, i8** %16
%313 = load i32, i32* %20
%314 = load i32, i32* %18
%315 = mul nsw i32 %313, %314
%316 = load i32, i32* %19
%317 = add nsw i32 %315, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds i8, i8* %312, i64 %318
store i8 %311, i8* %319
br label %434
320: ; preds = %297
%321 = load i8*, i8** %11
%322 = bitcast i8* %321 to i32*
store i32* %322, i32** %23
%323 = load i8*, i8** %16
%324 = bitcast i8* %323 to i16*
store i16* %324, i16** %22
%325 = load i32*, i32** %23
%326 = load i32, i32* %15
%327 = load i32, i32* %13
%328 = mul nsw i32 %326, %327
%329 = load i32, i32* %14
%330 = add nsw i32 %328, %329
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds i32, i32* %325, i64 %331
%333 = load i32, i32* %332
%334 = trunc i32 %333 to i16
%335 = load i16*, i16** %22
%336 = load i32, i32* %20
%337 = load i32, i32* %18
%338 = mul nsw i32 %336, %337
%339 = load i32, i32* %19
%340 = add nsw i32 %338, %339
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i16, i16* %335, i64 %341
store i16 %334, i16* %342
br label %434
343: ; preds = %297
%344 = load i8*, i8** %11
%345 = bitcast i8* %344 to i32*
store i32* %345, i32** %23
%346 = load i8*, i8** %16
%347 = bitcast i8* %346 to i32*
store i32* %347, i32** %24
%348 = load i32*, i32** %23
%349 = load i32, i32* %15
%350 = load i32, i32* %13
%351 = mul nsw i32 %349, %350
%352 = load i32, i32* %14
%353 = add nsw i32 %351, %352
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i32, i32* %348, i64 %354
%356 = load i32, i32* %355
%357 = load i32*, i32** %24
%358 = load i32, i32* %20
%359 = load i32, i32* %18
%360 = mul nsw i32 %358, %359
%361 = load i32, i32* %19
%362 = add nsw i32 %360, %361
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds i32, i32* %357, i64 %363
store i32 %356, i32* %364
br label %434
365: ; preds = %297
%366 = load i8*, i8** %11
%367 = bitcast i8* %366 to i32*
store i32* %367, i32** %23
%368 = load i8*, i8** %16
%369 = bitcast i8* %368 to i16*
store i16* %369, i16** %26
%370 = load i32*, i32** %23
%371 = load i32, i32* %15
%372 = load i32, i32* %13
%373 = mul nsw i32 %371, %372
%374 = load i32, i32* %14
%375 = add nsw i32 %373, %374
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i32, i32* %370, i64 %376
%378 = load i32, i32* %377
%379 = trunc i32 %378 to i16
%380 = load i16*, i16** %26
%381 = load i32, i32* %20
%382 = load i32, i32* %18
%383 = mul nsw i32 %381, %382
%384 = load i32, i32* %19
%385 = add nsw i32 %383, %384
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i16, i16* %380, i64 %386
store i16 %379, i16* %387
br label %434
388: ; preds = %297
%389 = load i8*, i8** %11
%390 = bitcast i8* %389 to i32*
store i32* %390, i32** %23
%391 = load i8*, i8** %16
%392 = bitcast i8* %391 to float*
store float* %392, float** %29
%393 = load i32*, i32** %23
%394 = load i32, i32* %15
%395 = load i32, i32* %13
%396 = mul nsw i32 %394, %395
%397 = load i32, i32* %14
%398 = add nsw i32 %396, %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds i32, i32* %393, i64 %399
%401 = load i32, i32* %400
%402 = sitofp i32 %401 to float
%403 = load float*, float** %29
%404 = load i32, i32* %20
%405 = load i32, i32* %18
%406 = mul nsw i32 %404, %405
%407 = load i32, i32* %19
%408 = add nsw i32 %406, %407
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds float, float* %403, i64 %409
store float %402, float* %410
br label %434
411: ; preds = %297
%412 = load i8*, i8** %11
%413 = bitcast i8* %412 to i32*
store i32* %413, i32** %23
%414 = load i8*, i8** %16
%415 = bitcast i8* %414 to double*
store double* %415, double** %32
%416 = load i32*, i32** %23
%417 = load i32, i32* %15
%418 = load i32, i32* %13
%419 = mul nsw i32 %417, %418
%420 = load i32, i32* %14
%421 = add nsw i32 %419, %420
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds i32, i32* %416, i64 %422
%424 = load i32, i32* %423
%425 = sitofp i32 %424 to double
%426 = load double*, double** %32
%427 = load i32, i32* %20
%428 = load i32, i32* %18
%429 = mul nsw i32 %427, %428
%430 = load i32, i32* %19
%431 = add nsw i32 %429, %430
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds double, double* %426, i64 %432
store double %425, double* %433
br label %434
434: ; preds = %297, %411, %388, %365, %343, %320, %299
br label %893
435: ; preds = %10
%436 = load i32, i32* %17
switch i32 %436, label %571 [
i32 8, label %437
i32 16, label %458
i32 32, label %480
i32 -16, label %503
i32 -32, label %525
i32 -64, label %548
]
437: ; preds = %435
%438 = load i8*, i8** %11
%439 = bitcast i8* %438 to i16*
store i16* %439, i16** %25
%440 = load i16*, i16** %25
%441 = load i32, i32* %15
%442 = load i32, i32* %13
%443 = mul nsw i32 %441, %442
%444 = load i32, i32* %14
%445 = add nsw i32 %443, %444
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i16, i16* %440, i64 %446
%448 = load i16, i16* %447
%449 = trunc i16 %448 to i8
%450 = load i8*, i8** %16
%451 = load i32, i32* %20
%452 = load i32, i32* %18
%453 = mul nsw i32 %451, %452
%454 = load i32, i32* %19
%455 = add nsw i32 %453, %454
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds i8, i8* %450, i64 %456
store i8 %449, i8* %457
br label %571
458: ; preds = %435
%459 = load i8*, i8** %11
%460 = bitcast i8* %459 to i16*
store i16* %460, i16** %25
%461 = load i8*, i8** %16
%462 = bitcast i8* %461 to i16*
store i16* %462, i16** %22
%463 = load i16*, i16** %25
%464 = load i32, i32* %15
%465 = load i32, i32* %13
%466 = mul nsw i32 %464, %465
%467 = load i32, i32* %14
%468 = add nsw i32 %466, %467
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds i16, i16* %463, i64 %469
%471 = load i16, i16* %470
%472 = load i16*, i16** %22
%473 = load i32, i32* %20
%474 = load i32, i32* %18
%475 = mul nsw i32 %473, %474
%476 = load i32, i32* %19
%477 = add nsw i32 %475, %476
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds i16, i16* %472, i64 %478
store i16 %471, i16* %479
br label %571
480: ; preds = %435
%481 = load i8*, i8** %11
%482 = bitcast i8* %481 to i16*
store i16* %482, i16** %25
%483 = load i8*, i8** %16
%484 = bitcast i8* %483 to i32*
store i32* %484, i32** %24
%485 = load i16*, i16** %25
%486 = load i32, i32* %15
%487 = load i32, i32* %13
%488 = mul nsw i32 %486, %487
%489 = load i32, i32* %14
%490 = add nsw i32 %488, %489
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds i16, i16* %485, i64 %491
%493 = load i16, i16* %492
%494 = zext i16 %493 to i32
%495 = load i32*, i32** %24
%496 = load i32, i32* %20
%497 = load i32, i32* %18
%498 = mul nsw i32 %496, %497
%499 = load i32, i32* %19
%500 = add nsw i32 %498, %499
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds i32, i32* %495, i64 %501
store i32 %494, i32* %502
br label %571
503: ; preds = %435
%504 = load i8*, i8** %11
%505 = bitcast i8* %504 to i16*
store i16* %505, i16** %25
%506 = load i8*, i8** %16
%507 = bitcast i8* %506 to i16*
store i16* %507, i16** %26
%508 = load i16*, i16** %25
%509 = load i32, i32* %15
%510 = load i32, i32* %13
%511 = mul nsw i32 %509, %510
%512 = load i32, i32* %14
%513 = add nsw i32 %511, %512
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds i16, i16* %508, i64 %514
%516 = load i16, i16* %515
%517 = load i16*, i16** %26
%518 = load i32, i32* %20
%519 = load i32, i32* %18
%520 = mul nsw i32 %518, %519
%521 = load i32, i32* %19
%522 = add nsw i32 %520, %521
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds i16, i16* %517, i64 %523
store i16 %516, i16* %524
br label %571
525: ; preds = %435
%526 = load i8*, i8** %11
%527 = bitcast i8* %526 to i16*
store i16* %527, i16** %25
%528 = load i8*, i8** %16
%529 = bitcast i8* %528 to float*
store float* %529, float** %29
%530 = load i16*, i16** %25
%531 = load i32, i32* %15
%532 = load i32, i32* %13
%533 = mul nsw i32 %531, %532
%534 = load i32, i32* %14
%535 = add nsw i32 %533, %534
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds i16, i16* %530, i64 %536
%538 = load i16, i16* %537
%539 = uitofp i16 %538 to float
%540 = load float*, float** %29
%541 = load i32, i32* %20
%542 = load i32, i32* %18
%543 = mul nsw i32 %541, %542
%544 = load i32, i32* %19
%545 = add nsw i32 %543, %544
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds float, float* %540, i64 %546
store float %539, float* %547
br label %571
548: ; preds = %435
%549 = load i8*, i8** %11
%550 = bitcast i8* %549 to i16*
store i16* %550, i16** %25
%551 = load i8*, i8** %16
%552 = bitcast i8* %551 to double*
store double* %552, double** %32
%553 = load i16*, i16** %25
%554 = load i32, i32* %15
%555 = load i32, i32* %13
%556 = mul nsw i32 %554, %555
%557 = load i32, i32* %14
%558 = add nsw i32 %556, %557
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds i16, i16* %553, i64 %559
%561 = load i16, i16* %560
%562 = uitofp i16 %561 to double
%563 = load double*, double** %32
%564 = load i32, i32* %20
%565 = load i32, i32* %18
%566 = mul nsw i32 %564, %565
%567 = load i32, i32* %19
%568 = add nsw i32 %566, %567
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds double, double* %563, i64 %569
store double %562, double* %570
br label %571
571: ; preds = %435, %548, %525, %503, %480, %458, %437
br label %893
572: ; preds = %10
%573 = load i8*, i8** %11
%574 = bitcast i8* %573 to float*
store float* %574, float** %28
%575 = load float*, float** %28
%576 = load i32, i32* %15
%577 = load i32, i32* %13
%578 = mul nsw i32 %576, %577
%579 = load i32, i32* %14
%580 = add nsw i32 %578, %579
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds float, float* %575, i64 %581
%583 = load float, float* %582
store float %583, float* %27
%584 = load i32, i32* %17
switch i32 %584, label %736 [
i32 8, label %585
i32 16, label %616
i32 32, label %649
i32 -16, label %682
i32 -32, label %711
i32 -64, label %723
]
585: ; preds = %572
%586 = load float, float* %27
%587 = fpext float %586 to double
%588 = fcmp olt double %587, 0.000000e+00
br i1 %588, label %589, label %602
589: ; preds = %585
%590 = load float, float* %27
%591 = fpext float %590 to double
%592 = fsub double %591, 5.000000e-01
%593 = fptosi double %592 to i8
%594 = load i8*, i8** %16
%595 = load i32, i32* %20
%596 = load i32, i32* %18
%597 = mul nsw i32 %595, %596
%598 = load i32, i32* %19
%599 = add nsw i32 %597, %598
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds i8, i8* %594, i64 %600
store i8 %593, i8* %601
br label %615
602: ; preds = %585
%603 = load float, float* %27
%604 = fpext float %603 to double
%605 = fadd double %604, 5.000000e-01
%606 = fptosi double %605 to i8
%607 = load i8*, i8** %16
%608 = load i32, i32* %20
%609 = load i32, i32* %18
%610 = mul nsw i32 %608, %609
%611 = load i32, i32* %19
%612 = add nsw i32 %610, %611
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds i8, i8* %607, i64 %613
store i8 %606, i8* %614
br label %615
615: ; preds = %602, %589
br label %736
616: ; preds = %572
%617 = load i8*, i8** %16
%618 = bitcast i8* %617 to i16*
store i16* %618, i16** %22
%619 = load float, float* %27
%620 = fpext float %619 to double
%621 = fcmp olt double %620, 0.000000e+00
br i1 %621, label %622, label %635
622: ; preds = %616
%623 = load float, float* %27
%624 = fpext float %623 to double
%625 = fsub double %624, 5.000000e-01
%626 = fptosi double %625 to i16
%627 = load i16*, i16** %22
%628 = load i32, i32* %20
%629 = load i32, i32* %18
%630 = mul nsw i32 %628, %629
%631 = load i32, i32* %19
%632 = add nsw i32 %630, %631
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds i16, i16* %627, i64 %633
store i16 %626, i16* %634
br label %648
635: ; preds = %616
%636 = load float, float* %27
%637 = fpext float %636 to double
%638 = fadd double %637, 5.000000e-01
%639 = fptosi double %638 to i16
%640 = load i16*, i16** %22
%641 = load i32, i32* %20
%642 = load i32, i32* %18
%643 = mul nsw i32 %641, %642
%644 = load i32, i32* %19
%645 = add nsw i32 %643, %644
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds i16, i16* %640, i64 %646
store i16 %639, i16* %647
br label %648
648: ; preds = %635, %622
br label %736
649: ; preds = %572
%650 = load i8*, i8** %16
%651 = bitcast i8* %650 to i32*
store i32* %651, i32** %24
%652 = load float, float* %27
%653 = fpext float %652 to double
%654 = fcmp olt double %653, 0.000000e+00
br i1 %654, label %655, label %668
655: ; preds = %649
%656 = load float, float* %27
%657 = fpext float %656 to double
%658 = fsub double %657, 5.000000e-01
%659 = fptosi double %658 to i32
%660 = load i32*, i32** %24
%661 = load i32, i32* %20
%662 = load i32, i32* %18
%663 = mul nsw i32 %661, %662
%664 = load i32, i32* %19
%665 = add nsw i32 %663, %664
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds i32, i32* %660, i64 %666
store i32 %659, i32* %667
br label %681
668: ; preds = %649
%669 = load float, float* %27
%670 = fpext float %669 to double
%671 = fadd double %670, 5.000000e-01
%672 = fptosi double %671 to i32
%673 = load i32*, i32** %24
%674 = load i32, i32* %20
%675 = load i32, i32* %18
%676 = mul nsw i32 %674, %675
%677 = load i32, i32* %19
%678 = add nsw i32 %676, %677
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds i32, i32* %673, i64 %679
store i32 %672, i32* %680
br label %681
681: ; preds = %668, %655
br label %736
682: ; preds = %572
%683 = load i8*, i8** %16
%684 = bitcast i8* %683 to i16*
store i16* %684, i16** %26
%685 = load float, float* %27
%686 = fpext float %685 to double
%687 = fcmp olt double %686, 0.000000e+00
br i1 %687, label %688, label %697
688: ; preds = %682
%689 = load i16*, i16** %26
%690 = load i32, i32* %20
%691 = load i32, i32* %18
%692 = mul nsw i32 %690, %691
%693 = load i32, i32* %19
%694 = add nsw i32 %692, %693
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds i16, i16* %689, i64 %695
store i16 0, i16* %696
br label %710
697: ; preds = %682
%698 = load float, float* %27
%699 = fpext float %698 to double
%700 = fadd double %699, 5.000000e-01
%701 = fptoui double %700 to i16
%702 = load i16*, i16** %26
%703 = load i32, i32* %20
%704 = load i32, i32* %18
%705 = mul nsw i32 %703, %704
%706 = load i32, i32* %19
%707 = add nsw i32 %705, %706
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds i16, i16* %702, i64 %708
store i16 %701, i16* %709
br label %710
710: ; preds = %697, %688
br label %736
711: ; preds = %572
%712 = load i8*, i8** %16
%713 = bitcast i8* %712 to float*
store float* %713, float** %29
%714 = load float, float* %27
%715 = load float*, float** %29
%716 = load i32, i32* %20
%717 = load i32, i32* %18
%718 = mul nsw i32 %716, %717
%719 = load i32, i32* %19
%720 = add nsw i32 %718, %719
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds float, float* %715, i64 %721
store float %714, float* %722
br label %736
723: ; preds = %572
%724 = load i8*, i8** %16
%725 = bitcast i8* %724 to double*
store double* %725, double** %32
%726 = load float, float* %27
%727 = fpext float %726 to double
%728 = load double*, double** %32
%729 = load i32, i32* %20
%730 = load i32, i32* %18
%731 = mul nsw i32 %729, %730
%732 = load i32, i32* %19
%733 = add nsw i32 %731, %732
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds double, double* %728, i64 %734
store double %727, double* %735
br label %736
736: ; preds = %572, %723, %711, %710, %681, %648, %615
br label %893
737: ; preds = %10
%738 = load i8*, i8** %11
%739 = bitcast i8* %738 to double*
store double* %739, double** %31
%740 = load double*, double** %31
%741 = load i32, i32* %15
%742 = load i32, i32* %13
%743 = mul nsw i32 %741, %742
%744 = load i32, i32* %14
%745 = add nsw i32 %743, %744
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double, double* %740, i64 %746
%748 = load double, double* %747
store double %748, double* %30
%749 = load i32, i32* %17
switch i32 %749, label %892 [
i32 8, label %750
i32 16, label %780
i32 32, label %810
i32 -16, label %840
i32 -32, label %867
i32 -64, label %880
]
750: ; preds = %737
%751 = load i8*, i8** %11
%752 = bitcast i8* %751 to double*
store double* %752, double** %31
%753 = load double, double* %30
%754 = fcmp olt double %753, 0.000000e+00
br i1 %754, label %755, label %767
755: ; preds = %750
%756 = load double, double* %30
%757 = fsub double %756, 5.000000e-01
%758 = fptosi double %757 to i8
%759 = load i8*, i8** %16
%760 = load i32, i32* %20
%761 = load i32, i32* %18
%762 = mul nsw i32 %760, %761
%763 = load i32, i32* %19
%764 = add nsw i32 %762, %763
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds i8, i8* %759, i64 %765
store i8 %758, i8* %766
br label %779
767: ; preds = %750
%768 = load double, double* %30
%769 = fadd double %768, 5.000000e-01
%770 = fptosi double %769 to i8
%771 = load i8*, i8** %16
%772 = load i32, i32* %20
%773 = load i32, i32* %18
%774 = mul nsw i32 %772, %773
%775 = load i32, i32* %19
%776 = add nsw i32 %774, %775
%777 = sext i32 %776 to i64
%778 = getelementptr inbounds i8, i8* %771, i64 %777
store i8 %770, i8* %778
br label %779
779: ; preds = %767, %755
br label %892
780: ; preds = %737
%781 = load i8*, i8** %16
%782 = bitcast i8* %781 to i16*
store i16* %782, i16** %22
%783 = load double, double* %30
%784 = fcmp olt double %783, 0.000000e+00
br i1 %784, label %785, label %797
785: ; preds = %780
%786 = load double, double* %30
%787 = fsub double %786, 5.000000e-01
%788 = fptosi double %787 to i16
%789 = load i16*, i16** %22
%790 = load i32, i32* %20
%791 = load i32, i32* %18
%792 = mul nsw i32 %790, %791
%793 = load i32, i32* %19
%794 = add nsw i32 %792, %793
%795 = sext i32 %794 to i64
%796 = getelementptr inbounds i16, i16* %789, i64 %795
store i16 %788, i16* %796
br label %809
797: ; preds = %780
%798 = load double, double* %30
%799 = fadd double %798, 5.000000e-01
%800 = fptosi double %799 to i16
%801 = load i16*, i16** %22
%802 = load i32, i32* %20
%803 = load i32, i32* %18
%804 = mul nsw i32 %802, %803
%805 = load i32, i32* %19
%806 = add nsw i32 %804, %805
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds i16, i16* %801, i64 %807
store i16 %800, i16* %808
br label %809
809: ; preds = %797, %785
br label %892
810: ; preds = %737
%811 = load i8*, i8** %16
%812 = bitcast i8* %811 to i32*
store i32* %812, i32** %24
%813 = load double, double* %30
%814 = fcmp olt double %813, 0.000000e+00
br i1 %814, label %815, label %827
815: ; preds = %810
%816 = load double, double* %30
%817 = fsub double %816, 5.000000e-01
%818 = fptosi double %817 to i32
%819 = load i32*, i32** %24
%820 = load i32, i32* %20
%821 = load i32, i32* %18
%822 = mul nsw i32 %820, %821
%823 = load i32, i32* %19
%824 = add nsw i32 %822, %823
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds i32, i32* %819, i64 %825
store i32 %818, i32* %826
br label %839
827: ; preds = %810
%828 = load double, double* %30
%829 = fadd double %828, 5.000000e-01
%830 = fptosi double %829 to i32
%831 = load i32*, i32** %24
%832 = load i32, i32* %20
%833 = load i32, i32* %18
%834 = mul nsw i32 %832, %833
%835 = load i32, i32* %19
%836 = add nsw i32 %834, %835
%837 = sext i32 %836 to i64
%838 = getelementptr inbounds i32, i32* %831, i64 %837
store i32 %830, i32* %838
br label %839
839: ; preds = %827, %815
br label %892
840: ; preds = %737
%841 = load i8*, i8** %16
%842 = bitcast i8* %841 to i16*
store i16* %842, i16** %26
%843 = load double, double* %30
%844 = fcmp olt double %843, 0.000000e+00
br i1 %844, label %845, label %854
845: ; preds = %840
%846 = load i16*, i16** %26
%847 = load i32, i32* %20
%848 = load i32, i32* %18
%849 = mul nsw i32 %847, %848
%850 = load i32, i32* %19
%851 = add nsw i32 %849, %850
%852 = sext i32 %851 to i64
%853 = getelementptr inbounds i16, i16* %846, i64 %852
store i16 0, i16* %853
br label %866
854: ; preds = %840
%855 = load double, double* %30
%856 = fadd double %855, 5.000000e-01
%857 = fptoui double %856 to i16
%858 = load i16*, i16** %26
%859 = load i32, i32* %20
%860 = load i32, i32* %18
%861 = mul nsw i32 %859, %860
%862 = load i32, i32* %19
%863 = add nsw i32 %861, %862
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds i16, i16* %858, i64 %864
store i16 %857, i16* %865
br label %866
866: ; preds = %854, %845
br label %892
867: ; preds = %737
%868 = load i8*, i8** %16
%869 = bitcast i8* %868 to float*
store float* %869, float** %29
%870 = load double, double* %30
%871 = fptrunc double %870 to float
%872 = load float*, float** %29
%873 = load i32, i32* %20
%874 = load i32, i32* %18
%875 = mul nsw i32 %873, %874
%876 = load i32, i32* %19
%877 = add nsw i32 %875, %876
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds float, float* %872, i64 %878
store float %871, float* %879
br label %892
880: ; preds = %737
%881 = load i8*, i8** %16
%882 = bitcast i8* %881 to double*
store double* %882, double** %32
%883 = load double, double* %30
%884 = load double*, double** %32
%885 = load i32, i32* %20
%886 = load i32, i32* %18
%887 = mul nsw i32 %885, %886
%888 = load i32, i32* %19
%889 = add nsw i32 %887, %888
%890 = sext i32 %889 to i64
%891 = getelementptr inbounds double, double* %884, i64 %890
store double %883, double* %891
br label %892
892: ; preds = %737, %880, %867, %866, %839, %809, %779
br label %893
893: ; preds = %10, %892, %736, %571, %434, %296, %159
ret void
}

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