void c_plot(char *framebuffer, short x, short y, short x_clip, short y_clip,
            short xx_clip, short yy_clip, unsigned int color,
            unsigned int bcolor, unsigned char alpha, unsigned char draw_mode,
            unsigned char bytes_per_pixel, unsigned char bits_per_pixel,
            unsigned int bytes_per_line, short xoffset, short yoffset) {
  if (x >= x_clip && x <= xx_clip && y >= y_clip && y <= yy_clip) {
    x += xoffset;
    y += yoffset;
    unsigned int index = (x * bytes_per_pixel) + (y * bytes_per_line);
    switch (draw_mode) {
    case 0:
      switch (bits_per_pixel) {
      case 32: {
        *((unsigned int *)(framebuffer + index)) = color;
      } break;
      case 24: {
        *(framebuffer + index) = color & 255;
        *(framebuffer + index + 1) = (color >> 8) & 255;
        *(framebuffer + index + 2) = (color >> 16) & 255;
      } break;
      case 16: {
        *((unsigned short *)(framebuffer + index)) = (short)color;
      } break;
      }
      break;
    case 1:
      switch (bits_per_pixel) {
      case 32: {
        *((unsigned int *)(framebuffer + index)) ^= color;
      } break;
      case 24: {
        *(framebuffer + index) ^= color & 255;
        *(framebuffer + index + 1) ^= (color >> 8) & 255;
        *(framebuffer + index + 2) ^= (color >> 16) & 255;
      } break;
      case 16: {
        *((unsigned short *)(framebuffer + index)) ^= (short)color;
      } break;
      }
      break;
    case 2:
      switch (bits_per_pixel) {
      case 32: {
        *((unsigned int *)(framebuffer + index)) |= color;
      } break;
      case 24: {
        *(framebuffer + index) |= color & 255;
        *(framebuffer + index + 1) |= (color >> 8) & 255;
        *(framebuffer + index + 2) |= (color >> 16) & 255;
      } break;
      case 16: {
        *((unsigned short *)(framebuffer + index)) |= (short)color;
      } break;
      }
      break;
    case 3:
      switch (bits_per_pixel) {
      case 32: {
        *((unsigned int *)(framebuffer + index)) &= color;
      } break;
      case 24: {
        *(framebuffer + index) &= color & 255;
        *(framebuffer + index + 1) &= (color >> 8) & 255;
        *(framebuffer + index + 2) &= (color >> 16) & 255;
      } break;
      case 16: {
        *((unsigned short *)(framebuffer + index)) &= (short)color;
      } break;
      }
      break;
    case 4:
      switch (bits_per_pixel) {
      case 32: {
        if ((*((unsigned int *)(framebuffer + index)) & 0xFFFFFF00) !=
            (bcolor & 0xFFFFFF00)) {
          *((unsigned int *)(framebuffer + index)) = color;
        }
      } break;
      case 24: {
        if ((*((unsigned int *)(framebuffer + index)) & 0xFFFFFF00) !=
            (bcolor & 0xFFFFFF00)) {
          *(framebuffer + index) = color & 255;
          *(framebuffer + index + 1) = (color >> 8) & 255;
          *(framebuffer + index + 2) = (color >> 16) & 255;
        }
      } break;
      case 16: {
        if (*((unsigned short *)(framebuffer + index)) != (bcolor & 0xFFFF)) {
          *((unsigned short *)(framebuffer + index)) = color;
        }
      } break;
      }
      break;
    case 5:
      switch (bits_per_pixel) {
      case 32: {
        if ((*((unsigned int *)(framebuffer + index)) & 0xFFFFFF00) ==
            (bcolor & 0xFFFFFF00)) {
          *((unsigned int *)(framebuffer + index)) = color;
        }
      } break;
      case 24: {
        if ((*((unsigned int *)(framebuffer + index)) & 0xFFFFFF00) ==
            (bcolor & 0xFFFFFF00)) {
          *(framebuffer + index) = color & 255;
          *(framebuffer + index + 1) = (color >> 8) & 255;
          *(framebuffer + index + 2) = (color >> 16) & 255;
        }
      } break;
      case 16: {
        if (*((unsigned short *)(framebuffer + index)) == (bcolor & 0xFFFF)) {
          *((unsigned short *)(framebuffer + index)) = color;
        }
      } break;
      }
      break;
    case 6:
      switch (bits_per_pixel) {
      case 32: {
        unsigned int fb_rgb = *((unsigned int *)(framebuffer + index));
        unsigned char fb_r = fb_rgb & 255;
        unsigned char fb_g = (fb_rgb >> 8) & 255;
        unsigned char fb_b = (fb_rgb >> 16) & 255;
        unsigned char R = color & 255;
        unsigned char G = (color >> 8) & 255;
        unsigned char B = (color >> 16) & 255;
        unsigned char A = (color >> 24) & 255;
        unsigned char invA = (255 - A);
        fb_r = ((R * A) + (fb_r * invA)) >> 8;
        fb_g = ((G * A) + (fb_g * invA)) >> 8;
        fb_b = ((B * A) + (fb_b * invA)) >> 8;
        *((unsigned int *)(framebuffer + index)) =
            fb_r | (fb_g << 8) | (fb_b << 16) | (A << 24);
      } break;
      case 24: {
        unsigned char fb_r = *(framebuffer + index);
        unsigned char fb_g = *(framebuffer + index + 1);
        unsigned char fb_b = *(framebuffer + index + 2);
        unsigned char invA = (255 - alpha);
        unsigned char R = color & 255;
        unsigned char G = (color >> 8) & 255;
        unsigned char B = (color >> 16) & 255;
        fb_r = ((R * alpha) + (fb_r * invA)) >> 8;
        fb_g = ((G * alpha) + (fb_g * invA)) >> 8;
        fb_b = ((B * alpha) + (fb_b * invA)) >> 8;
        *(framebuffer + index) = fb_r;
        *(framebuffer + index + 1) = fb_g;
        *(framebuffer + index + 2) = fb_b;
      } break;
      case 16: {
        unsigned short rgb565 = *((unsigned short *)(framebuffer + index));
        unsigned short fb_r = rgb565 & 31;
        unsigned short fb_g = (rgb565 >> 5) & 63;
        unsigned short fb_b = (rgb565 >> 11) & 31;
        unsigned short R = color & 31;
        unsigned short G = (color >> 5) & 63;
        unsigned short B = (color >> 11) & 31;
        unsigned char invA = (255 - alpha);
        fb_r = ((R * alpha) + (fb_r * invA)) >> 8;
        fb_g = ((G * alpha) + (fb_g * invA)) >> 8;
        fb_b = ((B * alpha) + (fb_b * invA)) >> 8;
        rgb565 = (fb_b << 11) | (fb_g << 5) | fb_r;
        *((unsigned short *)(framebuffer + index)) = rgb565;
      } break;
      }
      break;
    case 7:
      switch (bits_per_pixel) {
      case 32: {
        *((unsigned int *)(framebuffer + index)) += color;
      } break;
      case 24: {
        *(framebuffer + index) += color & 255;
        *(framebuffer + index + 1) += (color >> 8) & 255;
        *(framebuffer + index + 2) += (color >> 16) & 255;
      } break;
      case 16: {
        *((unsigned short *)(framebuffer + index)) += (short)color;
      } break;
      }
      break;
    case 8:
      switch (bits_per_pixel) {
      case 32: {
        *((unsigned int *)(framebuffer + index)) -= color;
      } break;
      case 24: {
        *(framebuffer + index) -= color & 255;
        *(framebuffer + index + 1) -= (color >> 8) & 255;
        *(framebuffer + index + 2) -= (color >> 16) & 255;
      } break;
      case 16: {
        *((unsigned short *)(framebuffer + index)) -= (short)color;
      } break;
      }
      break;
    case 9:
      switch (bits_per_pixel) {
      case 32: {
        *((unsigned int *)(framebuffer + index)) *= color;
      } break;
      case 24: {
        *(framebuffer + index) *= color & 255;
        *(framebuffer + index + 1) *= (color >> 8) & 255;
        *(framebuffer + index + 2) *= (color >> 16) & 255;
      } break;
      case 16: {
        *((unsigned short *)(framebuffer + index)) *= (short)color;
      } break;
      }
      break;
    case 10:
      switch (bits_per_pixel) {
      case 32: {
        *((unsigned int *)(framebuffer + index)) /= color;
      } break;
      case 24: {
        *(framebuffer + index) /= color & 255;
        *(framebuffer + index + 1) /= (color >> 8) & 255;
        *(framebuffer + index + 2) /= (color >> 16) & 255;
      } break;
      case 16: {
        *((unsigned short *)(framebuffer + index)) /= (short)color;
      } break;
      }
      break;
    }
  }
}


x86 assembly (clang, -O0):
<c_plot>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %r8d,-0x4c(%rbp)
mov    %ecx,%eax
mov    -0x4c(%rbp),%ecx
mov    %eax,-0x48(%rbp)
mov    %edx,%eax
mov    -0x48(%rbp),%edx
mov    %eax,-0x44(%rbp)
mov    %esi,%eax
mov    -0x44(%rbp),%esi
mov    %eax,-0x40(%rbp)
mov    %rdi,%r8
mov    -0x40(%rbp),%edi
mov    %r9w,%ax
mov    0x58(%rbp),%r9w
mov    0x50(%rbp),%r9w
mov    0x48(%rbp),%r9d
mov    0x40(%rbp),%r9b
mov    0x38(%rbp),%r9b
mov    0x30(%rbp),%r9b
mov    0x28(%rbp),%r9b
mov    0x20(%rbp),%r9d
mov    0x18(%rbp),%r9d
mov    0x10(%rbp),%r9w
mov    %r8,-0x8(%rbp)
mov    %di,-0xa(%rbp)
mov    %si,-0xc(%rbp)
mov    %dx,-0xe(%rbp)
mov    %cx,-0x10(%rbp)
mov    %ax,-0x12(%rbp)
movswl -0xa(%rbp),%eax
movswl -0xe(%rbp),%ecx
cmp    %ecx,%eax
jl     1d94 <c_plot+0xc94>
movswl -0xa(%rbp),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jg     1d94 <c_plot+0xc94>
movswl -0xc(%rbp),%eax
movswl -0x10(%rbp),%ecx
cmp    %ecx,%eax
jl     1d94 <c_plot+0xc94>
movswl -0xc(%rbp),%eax
movswl 0x10(%rbp),%ecx
cmp    %ecx,%eax
jg     1d94 <c_plot+0xc94>
movzwl 0x50(%rbp),%ecx
movzwl -0xa(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0xa(%rbp)
movzwl 0x58(%rbp),%ecx
movzwl -0xc(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0xc(%rbp)
movswl -0xa(%rbp),%eax
movzbl 0x38(%rbp),%ecx
imul   %ecx,%eax
movswl -0xc(%rbp),%ecx
mov    0x48(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x18(%rbp)
movzbl 0x30(%rbp),%eax
mov    %rax,-0x58(%rbp)
sub    $0xa,%rax
ja     1d8f <c_plot+0xc8f>
mov    -0x58(%rbp),%rax
lea    0xdfc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl 0x40(%rbp),%eax
mov    %eax,-0x5c(%rbp)
sub    $0x10,%eax
je     129f <c_plot+0x19f>
jmp    1222 <c_plot+0x122>
mov    -0x5c(%rbp),%eax
sub    $0x18,%eax
je     1256 <c_plot+0x156>
jmp    1233 <c_plot+0x133>
mov    -0x5c(%rbp),%eax
sub    $0x20,%eax
jne    12b0 <c_plot+0x1b0>
jmp    1244 <c_plot+0x144>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %edx,(%rax,%rcx,1)
jmp    12b0 <c_plot+0x1b0>
mov    0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,0x2(%rax,%rcx,1)
jmp    12b0 <c_plot+0x1b0>
mov    0x18(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x60(%rbp)
sub    $0x10,%eax
je     135b <c_plot+0x25b>
jmp    12ca <c_plot+0x1ca>
mov    -0x60(%rbp),%eax
sub    $0x18,%eax
je     1301 <c_plot+0x201>
jmp    12db <c_plot+0x1db>
mov    -0x60(%rbp),%eax
sub    $0x20,%eax
jne    1372 <c_plot+0x272>
jmp    12ec <c_plot+0x1ec>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
xor    (%rax,%rcx,1),%edx
mov    %edx,(%rax,%rcx,1)
jmp    1372 <c_plot+0x272>
mov    0x18(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x1(%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x2(%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,0x2(%rax,%rcx,1)
jmp    1372 <c_plot+0x272>
mov    0x18(%rbp),%eax
movswl %ax,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x64(%rbp)
sub    $0x10,%eax
je     141d <c_plot+0x31d>
jmp    138c <c_plot+0x28c>
mov    -0x64(%rbp),%eax
sub    $0x18,%eax
je     13c3 <c_plot+0x2c3>
jmp    139d <c_plot+0x29d>
mov    -0x64(%rbp),%eax
sub    $0x20,%eax
jne    1434 <c_plot+0x334>
jmp    13ae <c_plot+0x2ae>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
or     (%rax,%rcx,1),%edx
mov    %edx,(%rax,%rcx,1)
jmp    1434 <c_plot+0x334>
mov    0x18(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x1(%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x2(%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,0x2(%rax,%rcx,1)
jmp    1434 <c_plot+0x334>
mov    0x18(%rbp),%eax
movswl %ax,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x68(%rbp)
sub    $0x10,%eax
je     14df <c_plot+0x3df>
jmp    144e <c_plot+0x34e>
mov    -0x68(%rbp),%eax
sub    $0x18,%eax
je     1485 <c_plot+0x385>
jmp    145f <c_plot+0x35f>
mov    -0x68(%rbp),%eax
sub    $0x20,%eax
jne    14f6 <c_plot+0x3f6>
jmp    1470 <c_plot+0x370>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
and    (%rax,%rcx,1),%edx
mov    %edx,(%rax,%rcx,1)
jmp    14f6 <c_plot+0x3f6>
mov    0x18(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%edx
and    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x1(%rax,%rcx,1),%edx
and    %esi,%edx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x2(%rax,%rcx,1),%edx
and    %esi,%edx
mov    %dl,0x2(%rax,%rcx,1)
jmp    14f6 <c_plot+0x3f6>
mov    0x18(%rbp),%eax
movswl %ax,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%edx
and    %esi,%edx
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x6c(%rbp)
sub    $0x10,%eax
je     15cd <c_plot+0x4cd>
jmp    1510 <c_plot+0x410>
mov    -0x6c(%rbp),%eax
sub    $0x18,%eax
je     1564 <c_plot+0x464>
jmp    1521 <c_plot+0x421>
mov    -0x6c(%rbp),%eax
sub    $0x20,%eax
jne    15ff <c_plot+0x4ff>
jmp    1532 <c_plot+0x432>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%eax
and    $0xffffff00,%eax
mov    0x20(%rbp),%ecx
and    $0xffffff00,%ecx
cmp    %ecx,%eax
je     155f <c_plot+0x45f>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %edx,(%rax,%rcx,1)
jmp    15ff <c_plot+0x4ff>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%eax
and    $0xffffff00,%eax
mov    0x20(%rbp),%ecx
and    $0xffffff00,%ecx
cmp    %ecx,%eax
je     15c8 <c_plot+0x4c8>
mov    0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,0x2(%rax,%rcx,1)
jmp    15ff <c_plot+0x4ff>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%eax
mov    0x20(%rbp),%ecx
and    $0xffff,%ecx
cmp    %ecx,%eax
je     15fa <c_plot+0x4fa>
mov    0x18(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dx,(%rax,%rcx,1)
jmp    15ff <c_plot+0x4ff>
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x70(%rbp)
sub    $0x10,%eax
je     16d6 <c_plot+0x5d6>
jmp    1619 <c_plot+0x519>
mov    -0x70(%rbp),%eax
sub    $0x18,%eax
je     166d <c_plot+0x56d>
jmp    162a <c_plot+0x52a>
mov    -0x70(%rbp),%eax
sub    $0x20,%eax
jne    1708 <c_plot+0x608>
jmp    163b <c_plot+0x53b>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%eax
and    $0xffffff00,%eax
mov    0x20(%rbp),%ecx
and    $0xffffff00,%ecx
cmp    %ecx,%eax
jne    1668 <c_plot+0x568>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %edx,(%rax,%rcx,1)
jmp    1708 <c_plot+0x608>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%eax
and    $0xffffff00,%eax
mov    0x20(%rbp),%ecx
and    $0xffffff00,%ecx
cmp    %ecx,%eax
jne    16d1 <c_plot+0x5d1>
mov    0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,0x2(%rax,%rcx,1)
jmp    1708 <c_plot+0x608>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%eax
mov    0x20(%rbp),%ecx
and    $0xffff,%ecx
cmp    %ecx,%eax
jne    1703 <c_plot+0x603>
mov    0x18(%rbp),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dx,(%rax,%rcx,1)
jmp    1708 <c_plot+0x608>
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x74(%rbp)
sub    $0x10,%eax
je     1929 <c_plot+0x829>
jmp    1722 <c_plot+0x622>
mov    -0x74(%rbp),%eax
sub    $0x18,%eax
je     1843 <c_plot+0x743>
jmp    1733 <c_plot+0x633>
mov    -0x74(%rbp),%eax
sub    $0x20,%eax
jne    1a17 <c_plot+0x917>
jmp    1744 <c_plot+0x644>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x1d(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,-0x1e(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,-0x1f(%rbp)
mov    0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x20(%rbp)
mov    0x18(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,-0x21(%rbp)
mov    0x18(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,-0x22(%rbp)
mov    0x18(%rbp),%eax
shr    $0x18,%eax
and    $0xff,%eax
mov    %al,-0x23(%rbp)
movzbl -0x23(%rbp),%ecx
mov    $0xff,%eax
sub    %ecx,%eax
mov    %al,-0x24(%rbp)
movzbl -0x20(%rbp),%eax
movzbl -0x23(%rbp),%ecx
imul   %ecx,%eax
movzbl -0x1d(%rbp),%ecx
movzbl -0x24(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %al,-0x1d(%rbp)
movzbl -0x21(%rbp),%eax
movzbl -0x23(%rbp),%ecx
imul   %ecx,%eax
movzbl -0x1e(%rbp),%ecx
movzbl -0x24(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %al,-0x1e(%rbp)
movzbl -0x22(%rbp),%eax
movzbl -0x23(%rbp),%ecx
imul   %ecx,%eax
movzbl -0x1f(%rbp),%ecx
movzbl -0x24(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %al,-0x1f(%rbp)
movzbl -0x1d(%rbp),%edx
movzbl -0x1e(%rbp),%eax
shl    $0x8,%eax
or     %eax,%edx
movzbl -0x1f(%rbp),%eax
shl    $0x10,%eax
or     %eax,%edx
movzbl -0x23(%rbp),%eax
shl    $0x18,%eax
or     %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %edx,(%rax,%rcx,1)
jmp    1a17 <c_plot+0x917>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x25(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    0x1(%rax,%rcx,1),%al
mov    %al,-0x26(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    0x2(%rax,%rcx,1),%al
mov    %al,-0x27(%rbp)
movzbl 0x28(%rbp),%ecx
mov    $0xff,%eax
sub    %ecx,%eax
mov    %al,-0x28(%rbp)
mov    0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x29(%rbp)
mov    0x18(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,-0x2a(%rbp)
mov    0x18(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,-0x2b(%rbp)
movzbl -0x29(%rbp),%eax
movzbl 0x28(%rbp),%ecx
imul   %ecx,%eax
movzbl -0x25(%rbp),%ecx
movzbl -0x28(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %al,-0x25(%rbp)
movzbl -0x2a(%rbp),%eax
movzbl 0x28(%rbp),%ecx
imul   %ecx,%eax
movzbl -0x26(%rbp),%ecx
movzbl -0x28(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %al,-0x26(%rbp)
movzbl -0x2b(%rbp),%eax
movzbl 0x28(%rbp),%ecx
imul   %ecx,%eax
movzbl -0x27(%rbp),%ecx
movzbl -0x28(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %al,-0x27(%rbp)
mov    -0x25(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x26(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,0x1(%rax,%rcx,1)
mov    -0x27(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dl,0x2(%rax,%rcx,1)
jmp    1a17 <c_plot+0x917>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%ax
mov    %ax,-0x2e(%rbp)
movzwl -0x2e(%rbp),%eax
and    $0x1f,%eax
mov    %ax,-0x30(%rbp)
movzwl -0x2e(%rbp),%eax
sar    $0x5,%eax
and    $0x3f,%eax
mov    %ax,-0x32(%rbp)
movzwl -0x2e(%rbp),%eax
sar    $0xb,%eax
and    $0x1f,%eax
mov    %ax,-0x34(%rbp)
mov    0x18(%rbp),%eax
and    $0x1f,%eax
mov    %ax,-0x36(%rbp)
mov    0x18(%rbp),%eax
shr    $0x5,%eax
and    $0x3f,%eax
mov    %ax,-0x38(%rbp)
mov    0x18(%rbp),%eax
shr    $0xb,%eax
and    $0x1f,%eax
mov    %ax,-0x3a(%rbp)
movzbl 0x28(%rbp),%ecx
mov    $0xff,%eax
sub    %ecx,%eax
mov    %al,-0x3b(%rbp)
movzwl -0x36(%rbp),%eax
movzbl 0x28(%rbp),%ecx
imul   %ecx,%eax
movzwl -0x30(%rbp),%ecx
movzbl -0x3b(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %ax,-0x30(%rbp)
movzwl -0x38(%rbp),%eax
movzbl 0x28(%rbp),%ecx
imul   %ecx,%eax
movzwl -0x32(%rbp),%ecx
movzbl -0x3b(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %ax,-0x32(%rbp)
movzwl -0x3a(%rbp),%eax
movzbl 0x28(%rbp),%ecx
imul   %ecx,%eax
movzwl -0x34(%rbp),%ecx
movzbl -0x3b(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
sar    $0x8,%eax
mov    %ax,-0x34(%rbp)
movzwl -0x34(%rbp),%eax
shl    $0xb,%eax
movzwl -0x32(%rbp),%ecx
shl    $0x5,%ecx
or     %ecx,%eax
movzwl -0x30(%rbp),%ecx
or     %ecx,%eax
mov    %ax,-0x2e(%rbp)
mov    -0x2e(%rbp),%dx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x78(%rbp)
sub    $0x10,%eax
je     1ac2 <c_plot+0x9c2>
jmp    1a31 <c_plot+0x931>
mov    -0x78(%rbp),%eax
sub    $0x18,%eax
je     1a68 <c_plot+0x968>
jmp    1a42 <c_plot+0x942>
mov    -0x78(%rbp),%eax
sub    $0x20,%eax
jne    1ad9 <c_plot+0x9d9>
jmp    1a53 <c_plot+0x953>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    (%rax,%rcx,1),%edx
mov    %edx,(%rax,%rcx,1)
jmp    1ad9 <c_plot+0x9d9>
mov    0x18(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x1(%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x2(%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,0x2(%rax,%rcx,1)
jmp    1ad9 <c_plot+0x9d9>
mov    0x18(%rbp),%eax
movswl %ax,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x7c(%rbp)
sub    $0x10,%eax
je     1b86 <c_plot+0xa86>
jmp    1af3 <c_plot+0x9f3>
mov    -0x7c(%rbp),%eax
sub    $0x18,%eax
je     1b2c <c_plot+0xa2c>
jmp    1b04 <c_plot+0xa04>
mov    -0x7c(%rbp),%eax
sub    $0x20,%eax
jne    1b9d <c_plot+0xa9d>
jmp    1b15 <c_plot+0xa15>
mov    0x18(%rbp),%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,1)
jmp    1b9d <c_plot+0xa9d>
mov    0x18(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x1(%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x2(%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,0x2(%rax,%rcx,1)
jmp    1b9d <c_plot+0xa9d>
mov    0x18(%rbp),%eax
movswl %ax,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x80(%rbp)
sub    $0x10,%eax
je     1c4c <c_plot+0xb4c>
jmp    1bb7 <c_plot+0xab7>
mov    -0x80(%rbp),%eax
sub    $0x18,%eax
je     1bef <c_plot+0xaef>
jmp    1bc8 <c_plot+0xac8>
mov    -0x80(%rbp),%eax
sub    $0x20,%eax
jne    1c64 <c_plot+0xb64>
jmp    1bd9 <c_plot+0xad9>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   (%rax,%rcx,1),%edx
mov    %edx,(%rax,%rcx,1)
jmp    1c64 <c_plot+0xb64>
mov    0x18(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%edx
imul   %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x1(%rax,%rcx,1),%edx
imul   %esi,%edx
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movsbl 0x2(%rax,%rcx,1),%edx
imul   %esi,%edx
mov    %dl,0x2(%rax,%rcx,1)
jmp    1c64 <c_plot+0xb64>
mov    0x18(%rbp),%eax
movswl %ax,%esi
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%edx
imul   %esi,%edx
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
movzbl 0x40(%rbp),%eax
mov    %eax,-0x84(%rbp)
sub    $0x10,%eax
je     1d62 <c_plot+0xc62>
jmp    1c81 <c_plot+0xb81>
mov    -0x84(%rbp),%eax
sub    $0x18,%eax
je     1cd2 <c_plot+0xbd2>
jmp    1c95 <c_plot+0xb95>
mov    -0x84(%rbp),%eax
sub    $0x20,%eax
jne    1d8a <c_plot+0xc8a>
jmp    1ca9 <c_plot+0xba9>
mov    0x18(%rbp),%esi
mov    -0x8(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,1),%eax
xor    %edx,%edx
div    %esi
mov    %eax,%edx
mov    -0x90(%rbp),%rax
mov    %edx,(%rax,%rcx,1)
jmp    1d8a <c_plot+0xc8a>
mov    0x18(%rbp),%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
xor    %edx,%edx
div    %esi
mov    %eax,%edx
mov    -0xa8(%rbp),%rax
mov    %dl,(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x8,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x18(%rbp),%ecx
movsbl 0x1(%rax,%rcx,1),%eax
xor    %edx,%edx
div    %esi
mov    %eax,%edx
mov    -0xa0(%rbp),%rax
mov    %dl,0x1(%rax,%rcx,1)
mov    0x18(%rbp),%esi
shr    $0x10,%esi
and    $0xff,%esi
mov    -0x8(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x18(%rbp),%ecx
movsbl 0x2(%rax,%rcx,1),%eax
xor    %edx,%edx
div    %esi
mov    %eax,%edx
mov    -0x98(%rbp),%rax
mov    %dl,0x2(%rax,%rcx,1)
jmp    1d8a <c_plot+0xc8a>
mov    0x18(%rbp),%eax
movswl %ax,%esi
mov    -0x8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x18(%rbp),%ecx
movzwl (%rax,%rcx,1),%eax
cltd
idiv   %esi
mov    %eax,%edx
mov    -0xb0(%rbp),%rax
mov    %dx,(%rax,%rcx,1)
jmp    1d8f <c_plot+0xc8f>
jmp    1d94 <c_plot+0xc94>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_plot>:
push   %rbp
push   %rbx
cmp    0x18(%rsp),%dx
jg     1667 <c_plot+0x567>
cmp    %r8w,%dx
jl     1667 <c_plot+0x567>
cmp    %cx,%si
jl     1667 <c_plot+0x567>
cmp    %r9w,%si
jg     1667 <c_plot+0x567>
mov    0x38(%rsp),%cl
cmp    $0xa,%cl
ja     1667 <c_plot+0x567>
movzwl 0x60(%rsp),%eax
movzwl 0x58(%rsp),%ebp
mov    0x48(%rsp),%r8b
mov    0x28(%rsp),%ebx
mov    0x20(%rsp),%r9d
add    %esi,%ebp
add    %edx,%eax
movswl %bp,%edx
movzbl 0x40(%rsp),%esi
imul   %edx,%esi
cwtl
imul   0x50(%rsp),%eax
add    %esi,%eax
movzbl %cl,%ecx
lea    0xe90(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
cmp    $0x10,%r8b
je     13d0 <c_plot+0x2d0>
cmp    $0x18,%r8b
je     13dc <c_plot+0x2dc>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
mov    %r9d,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
cmp    $0x10,%r8b
je     13e3 <c_plot+0x2e3>
cmp    $0x18,%r8b
je     13ef <c_plot+0x2ef>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
xor    %r9d,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
cmp    $0x10,%r8b
je     140d <c_plot+0x30d>
cmp    $0x18,%r8b
je     1419 <c_plot+0x319>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
or     %r9d,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
cmp    $0x10,%r8b
je     1437 <c_plot+0x337>
cmp    $0x18,%r8b
je     1443 <c_plot+0x343>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
and    %r9d,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
cmp    $0x10,%r8b
je     1461 <c_plot+0x361>
cmp    $0x18,%r8b
je     146f <c_plot+0x36f>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
xor    (%rdi,%rax,1),%ebx
cmp    $0x100,%ebx
jb     1667 <c_plot+0x567>
jmp    127d <c_plot+0x17d>
cmp    $0x10,%r8b
je     1481 <c_plot+0x381>
cmp    $0x18,%r8b
je     1497 <c_plot+0x397>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
xor    (%rdi,%rax,1),%ebx
cmp    $0xff,%ebx
ja     1667 <c_plot+0x567>
mov    %r9d,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    0x30(%rsp),%bl
cmp    $0x10,%r8b
je     14be <c_plot+0x3be>
cmp    $0x18,%r8b
je     1532 <c_plot+0x432>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%r8d
mov    (%rdi,%r8,1),%ebx
movzbl %bl,%r10d
movzbl %bh,%edx
shr    $0x10,%ebx
mov    %r9d,%eax
mov    %r9d,%esi
shr    $0x10,%esi
mov    %r9d,%ecx
shr    $0x18,%ecx
movzbl %al,%r11d
imul   %ecx,%r11d
movzbl %ah,%ebp
imul   %ecx,%ebp
movzbl %sil,%esi
imul   %ecx,%esi
xor    $0xff,%ecx
imul   %ecx,%r10d
imul   %ecx,%edx
movzbl %bl,%ebx
imul   %ecx,%ebx
mov    %r10d,%ecx
add    %r11d,%ecx
movzbl %ch,%ecx
add    %ebp,%edx
add    %esi,%ebx
and    $0xff00,%edx
shl    $0x8,%ebx
and    $0xff0000,%ebx
and    $0xff000000,%eax
or     %edx,%eax
or     %ecx,%eax
or     %ebx,%eax
mov    %eax,(%rdi,%r8,1)
jmp    1667 <c_plot+0x567>
cmp    $0x10,%r8b
je     158c <c_plot+0x48c>
cmp    $0x18,%r8b
je     1598 <c_plot+0x498>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
add    %r9d,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
cmp    $0x10,%r8b
je     15b6 <c_plot+0x4b6>
cmp    $0x18,%r8b
je     15c8 <c_plot+0x4c8>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
imul   (%rdi,%rax,1),%r9d
mov    %r9d,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
cmp    $0x10,%r8b
je     164c <c_plot+0x54c>
cmp    $0x18,%r8b
je     15f9 <c_plot+0x4f9>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%eax
sub    %r9d,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
cmp    $0x10,%r8b
je     1655 <c_plot+0x555>
cmp    $0x18,%r8b
je     1614 <c_plot+0x514>
cmp    $0x20,%r8b
jne    1667 <c_plot+0x567>
mov    %eax,%ecx
mov    (%rdi,%rcx,1),%eax
xor    %edx,%edx
div    %r9d
mov    %eax,(%rdi,%rcx,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
mov    %r9w,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
jmp    14a8 <c_plot+0x3a8>
mov    %eax,%eax
xor    %r9w,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
mov    %r9d,%edx
xor    %dl,(%rdi,%rax,1)
mov    %r9d,%ecx
shr    $0x8,%ecx
xor    %cl,0x1(%rdi,%rax,1)
shr    $0x10,%edx
xor    %dl,0x2(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
or     %r9w,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
mov    %r9d,%edx
or     %dl,(%rdi,%rax,1)
mov    %r9d,%ecx
shr    $0x8,%ecx
or     %cl,0x1(%rdi,%rax,1)
shr    $0x10,%edx
or     %dl,0x2(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
and    %r9w,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
mov    %r9d,%edx
and    %dl,(%rdi,%rax,1)
mov    %r9d,%ecx
shr    $0x8,%ecx
and    %cl,0x1(%rdi,%rax,1)
shr    $0x10,%edx
and    %dl,0x2(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
cmp    %bx,(%rdi,%rax,1)
je     1667 <c_plot+0x567>
jmp    148d <c_plot+0x38d>
mov    %eax,%eax
xor    (%rdi,%rax,1),%ebx
cmp    $0x100,%ebx
jae    14a8 <c_plot+0x3a8>
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
cmp    %bx,(%rdi,%rax,1)
jne    1667 <c_plot+0x567>
mov    %r9w,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
xor    (%rdi,%rax,1),%ebx
cmp    $0xff,%ebx
ja     1667 <c_plot+0x567>
mov    %r9d,%ecx
mov    %cl,(%rdi,%rax,1)
mov    %ch,0x1(%rdi,%rax,1)
shr    $0x10,%ecx
mov    %cl,0x2(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%r8d
movzwl (%rdi,%r8,1),%ecx
mov    %ecx,%r10d
and    $0x1f,%r10d
mov    %ecx,%edx
shr    $0x5,%edx
and    $0x3f,%edx
shr    $0xb,%ecx
mov    %r9d,%eax
and    $0x1f,%r9d
mov    %eax,%esi
shr    $0x5,%esi
and    $0x3f,%esi
shr    $0xb,%eax
movzbl %bl,%ebp
imul   %ebp,%r9d
imul   %ebp,%esi
and    $0x1f,%eax
imul   %ebp,%eax
mov    %ebp,%ebx
not    %bl
movzbl %bl,%ebp
imul   %ebp,%r10d
add    %r9d,%r10d
shr    $0x8,%r10d
imul   %ebp,%edx
add    %esi,%edx
imul   %ebp,%ecx
add    %eax,%ecx
and    $0x1f00,%ecx
shr    $0x3,%edx
and    $0xffffffe0,%edx
lea    (%r10,%rcx,8),%eax
or     %edx,%eax
mov    %ax,(%rdi,%r8,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%ebp
movzbl (%rdi,%rbp,1),%edx
movzbl 0x1(%rdi,%rbp,1),%ecx
mov    %r9d,%eax
mov    %r9d,%r8d
movzbl %al,%r9d
movzbl %ah,%esi
movzbl 0x2(%rdi,%rbp,1),%eax
movzbl %bl,%r10d
not    %bl
imul   %r10d,%r9d
movzbl %bl,%ebx
imul   %ebx,%edx
add    %r9d,%edx
mov    %dh,(%rdi,%rbp,1)
imul   %r10d,%esi
imul   %ebx,%ecx
add    %esi,%ecx
mov    %ch,0x1(%rdi,%rbp,1)
shr    $0x10,%r8d
movzbl %r8b,%ecx
imul   %r10d,%ecx
imul   %ebx,%eax
add    %ecx,%eax
mov    %ah,0x2(%rdi,%rbp,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
add    %r9w,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
mov    %r9d,%edx
add    %dl,(%rdi,%rax,1)
mov    %r9d,%ecx
shr    $0x8,%ecx
add    %cl,0x1(%rdi,%rax,1)
shr    $0x10,%edx
add    %dl,0x2(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
imul   (%rdi,%rax,1),%r9w
mov    %r9w,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%edx
mov    (%rdi,%rdx,1),%al
mov    0x1(%rdi,%rdx,1),%cl
mov    %r9d,%esi
mul    %sil
mov    %al,(%rdi,%rdx,1)
mov    %r9d,%ebp
shr    $0x8,%ebp
mov    %ecx,%eax
mul    %bpl
mov    %al,0x1(%rdi,%rdx,1)
shr    $0x10,%esi
mov    0x2(%rdi,%rdx,1),%al
mul    %sil
mov    %al,0x2(%rdi,%rdx,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
mov    %r9d,%edx
sub    %dl,(%rdi,%rax,1)
mov    %r9d,%ecx
shr    $0x8,%ecx
sub    %cl,0x1(%rdi,%rax,1)
shr    $0x10,%edx
sub    %dl,0x2(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
mov    %r9d,%ebx
movzbl %bl,%ecx
mov    %eax,%esi
movsbl (%rdi,%rsi,1),%eax
xor    %edx,%edx
div    %ecx
mov    %al,(%rdi,%rsi,1)
movzbl %bh,%ecx
movsbl 0x1(%rdi,%rsi,1),%eax
xor    %edx,%edx
div    %ecx
mov    %al,0x1(%rdi,%rsi,1)
shr    $0x10,%ebx
movzbl %bl,%ecx
movsbl 0x2(%rdi,%rsi,1),%eax
xor    %edx,%edx
div    %ecx
mov    %al,0x2(%rdi,%rsi,1)
jmp    1667 <c_plot+0x567>
mov    %eax,%eax
sub    %r9w,(%rdi,%rax,1)
jmp    1667 <c_plot+0x567>
movswl %r9w,%ecx
mov    %eax,%esi
movzwl (%rdi,%rsi,1),%eax
xor    %edx,%edx
idiv   %ecx
mov    %ax,(%rdi,%rsi,1)
pop    %rbx
pop    %rbp
ret

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

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