int ConvertType(unsigned char *data_in, char in_type, void *data_out,
                char out_type, int n) {
  int i;
  if (out_type == 'n') {
    return (0);
  }
  switch (in_type) {
  case 'c':
    switch (out_type) {
    case 'c':
      for (i = 0; i < n; i++)
        ((unsigned char *)data_out)[i] = data_in[i];
      break;
    case 's':
      for (i = 0; i < n; i++)
        ((short *)data_out)[i] = data_in[i];
      break;
    case 'u':
      for (i = 0; i < n; i++)
        ((unsigned short *)data_out)[i] = data_in[i];
      break;
    case 'i':
    case 'S':
      for (i = 0; i < n; i++)
        ((int *)data_out)[i] = data_in[i];
      break;
    case 'U':
      for (i = 0; i < n; i++)
        ((unsigned int *)data_out)[i] = data_in[i];
      break;
    case 'f':
      for (i = 0; i < n; i++)
        ((float *)data_out)[i] = data_in[i];
      break;
    case 'd':
      for (i = 0; i < n; i++)
        ((double *)data_out)[i] = data_in[i];
      break;
    default:
      return (6);
    }
    break;
  case 's':
    switch (out_type) {
    case 'c':
      for (i = 0; i < n; i++)
        ((unsigned char *)data_out)[i] = ((short *)data_in)[i];
      break;
    case 's':
      for (i = 0; i < n; i++)
        ((short *)data_out)[i] = ((short *)data_in)[i];
      break;
    case 'u':
      for (i = 0; i < n; i++)
        ((unsigned short *)data_out)[i] = ((short *)data_in)[i];
      break;
    case 'S':
    case 'i':
      for (i = 0; i < n; i++)
        ((int *)data_out)[i] = ((short *)data_in)[i];
      break;
    case 'U':
      for (i = 0; i < n; i++)
        ((unsigned int *)data_out)[i] = ((short *)data_in)[i];
      break;
    case 'f':
      for (i = 0; i < n; i++)
        ((float *)data_out)[i] = ((short *)data_in)[i];
      break;
    case 'd':
      for (i = 0; i < n; i++)
        ((double *)data_out)[i] = ((short *)data_in)[i];
      break;
    default:
      return (6);
    }
    break;
  case 'u':
    switch (out_type) {
    case 'c':
      for (i = 0; i < n; i++)
        ((unsigned char *)data_out)[i] = ((unsigned short *)data_in)[i];
      break;
    case 's':
      for (i = 0; i < n; i++)
        ((short *)data_out)[i] = ((unsigned short *)data_in)[i];
      break;
    case 'u':
      for (i = 0; i < n; i++)
        ((unsigned short *)data_out)[i] = ((unsigned short *)data_in)[i];
      break;
    case 'i':
    case 'S':
      for (i = 0; i < n; i++)
        ((int *)data_out)[i] = ((unsigned short *)data_in)[i];
      break;
    case 'U':
      for (i = 0; i < n; i++)
        ((unsigned int *)data_out)[i] = ((unsigned short *)data_in)[i];
      break;
    case 'f':
      for (i = 0; i < n; i++)
        ((float *)data_out)[i] = ((unsigned short *)data_in)[i];
      break;
    case 'd':
      for (i = 0; i < n; i++)
        ((double *)data_out)[i] = ((unsigned short *)data_in)[i];
      break;
    default:
      return (6);
    }
    break;
  case 'i':
  case 'S':
    switch (out_type) {
    case 'c':
      for (i = 0; i < n; i++)
        ((unsigned char *)data_out)[i] = ((int *)data_in)[i];
      break;
    case 's':
      for (i = 0; i < n; i++)
        ((short *)data_out)[i] = ((int *)data_in)[i];
      break;
    case 'u':
      for (i = 0; i < n; i++)
        ((unsigned short *)data_out)[i] = ((int *)data_in)[i];
      break;
    case 'i':
    case 'S':
      for (i = 0; i < n; i++)
        ((int *)data_out)[i] = ((int *)data_in)[i];
      break;
    case 'U':
      for (i = 0; i < n; i++)
        ((unsigned int *)data_out)[i] = ((int *)data_in)[i];
      break;
    case 'f':
      for (i = 0; i < n; i++)
        ((float *)data_out)[i] = ((int *)data_in)[i];
      break;
    case 'd':
      for (i = 0; i < n; i++)
        ((double *)data_out)[i] = ((int *)data_in)[i];
      break;
    default:
      return (6);
    }
    break;
  case 'U':
    switch (out_type) {
    case 'c':
      for (i = 0; i < n; i++)
        ((unsigned char *)data_out)[i] = ((unsigned *)data_in)[i];
      break;
    case 's':
      for (i = 0; i < n; i++)
        ((short *)data_out)[i] = ((unsigned *)data_in)[i];
      break;
    case 'u':
      for (i = 0; i < n; i++)
        ((unsigned short *)data_out)[i] = ((unsigned *)data_in)[i];
      break;
    case 'i':
    case 'S':
      for (i = 0; i < n; i++)
        ((int *)data_out)[i] = ((unsigned *)data_in)[i];
      break;
    case 'U':
      for (i = 0; i < n; i++)
        ((unsigned int *)data_out)[i] = ((unsigned *)data_in)[i];
      break;
    case 'f':
      for (i = 0; i < n; i++)
        ((float *)data_out)[i] = ((unsigned *)data_in)[i];
      break;
    case 'd':
      for (i = 0; i < n; i++)
        ((double *)data_out)[i] = ((unsigned *)data_in)[i];
      break;
    default:
      return (6);
    }
    break;
  case 'f':
    switch (out_type) {
    case 'c':
      for (i = 0; i < n; i++)
        ((unsigned char *)data_out)[i] = ((float *)data_in)[i];
      break;
    case 's':
      for (i = 0; i < n; i++)
        ((short *)data_out)[i] = ((float *)data_in)[i];
      break;
    case 'u':
      for (i = 0; i < n; i++)
        ((unsigned short *)data_out)[i] = ((float *)data_in)[i];
      break;
    case 'i':
    case 'S':
      for (i = 0; i < n; i++)
        ((int *)data_out)[i] = ((float *)data_in)[i];
      break;
    case 'U':
      for (i = 0; i < n; i++)
        ((unsigned int *)data_out)[i] = ((float *)data_in)[i];
      break;
    case 'f':
      for (i = 0; i < n; i++)
        ((float *)data_out)[i] = ((float *)data_in)[i];
      break;
    case 'd':
      for (i = 0; i < n; i++)
        ((double *)data_out)[i] = ((float *)data_in)[i];
      break;
    default:
      return (6);
    }
    break;
  case 'd':
    switch (out_type) {
    case 'c':
      for (i = 0; i < n; i++)
        ((unsigned char *)data_out)[i] = ((double *)data_in)[i];
      break;
    case 's':
      for (i = 0; i < n; i++)
        ((short *)data_out)[i] = ((double *)data_in)[i];
      break;
    case 'u':
      for (i = 0; i < n; i++)
        ((unsigned short *)data_out)[i] = ((double *)data_in)[i];
      break;
    case 'i':
    case 'S':
      for (i = 0; i < n; i++)
        ((int *)data_out)[i] = ((double *)data_in)[i];
      break;
    case 'U':
      for (i = 0; i < n; i++)
        ((unsigned int *)data_out)[i] = ((double *)data_in)[i];
      break;
    case 'f':
      for (i = 0; i < n; i++)
        ((float *)data_out)[i] = ((double *)data_in)[i];
      break;
    case 'd':
      for (i = 0; i < n; i++)
        ((double *)data_out)[i] = ((double *)data_in)[i];
      break;
    default:
      return (6);
      break;
    }
    break;
  default:
    printf("internal getdata bug: unknown type shouldn't make it here!\n");
    return (6);
  }
  return (0);
}


x86 assembly (clang, -O0):
<ConvertType>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %cl,%al
mov    %sil,%cl
mov    %rdi,-0x10(%rbp)
mov    %cl,-0x11(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %al,-0x21(%rbp)
mov    %r8d,-0x28(%rbp)
movsbl -0x21(%rbp),%eax
cmp    $0x6e,%eax
jne    1148 <ConvertType+0x38>
movl   $0x0,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
movsbl -0x11(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x38(%rbp)
sub    $0x22,%eax
ja     1f4b <ConvertType+0xe3b>
mov    -0x38(%rbp),%rax
lea    0xe97(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movsbl -0x21(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x22,%eax
ja     135a <ConvertType+0x24a>
mov    -0x40(%rbp),%rax
lea    0x1241(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11d3 <ConvertType+0xc3>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a3 <ConvertType+0x93>
jmp    1366 <ConvertType+0x256>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1214 <ConvertType+0x104>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11df <ConvertType+0xcf>
jmp    1366 <ConvertType+0x256>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1255 <ConvertType+0x145>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1220 <ConvertType+0x110>
jmp    1366 <ConvertType+0x256>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1292 <ConvertType+0x182>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1261 <ConvertType+0x151>
jmp    1366 <ConvertType+0x256>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12cf <ConvertType+0x1bf>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    129e <ConvertType+0x18e>
jmp    1366 <ConvertType+0x256>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1312 <ConvertType+0x202>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12db <ConvertType+0x1cb>
jmp    1366 <ConvertType+0x256>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1355 <ConvertType+0x245>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    131e <ConvertType+0x20e>
jmp    1366 <ConvertType+0x256>
movl   $0x6,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
jmp    1f65 <ConvertType+0xe55>
movsbl -0x21(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x22,%eax
ja     1550 <ConvertType+0x440>
mov    -0x48(%rbp),%rax
lea    0xfbc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13cf <ConvertType+0x2bf>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    139c <ConvertType+0x28c>
jmp    155c <ConvertType+0x44c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    140d <ConvertType+0x2fd>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13db <ConvertType+0x2cb>
jmp    155c <ConvertType+0x44c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    144b <ConvertType+0x33b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1419 <ConvertType+0x309>
jmp    155c <ConvertType+0x44c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1488 <ConvertType+0x378>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1457 <ConvertType+0x347>
jmp    155c <ConvertType+0x44c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14c5 <ConvertType+0x3b5>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1494 <ConvertType+0x384>
jmp    155c <ConvertType+0x44c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1508 <ConvertType+0x3f8>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14d1 <ConvertType+0x3c1>
jmp    155c <ConvertType+0x44c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    154b <ConvertType+0x43b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1514 <ConvertType+0x404>
jmp    155c <ConvertType+0x44c>
movl   $0x6,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
jmp    1f65 <ConvertType+0xe55>
movsbl -0x21(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
sub    $0x22,%eax
ja     1746 <ConvertType+0x636>
mov    -0x50(%rbp),%rax
lea    0xd3a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15c5 <ConvertType+0x4b5>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1592 <ConvertType+0x482>
jmp    1752 <ConvertType+0x642>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1603 <ConvertType+0x4f3>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15d1 <ConvertType+0x4c1>
jmp    1752 <ConvertType+0x642>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1641 <ConvertType+0x531>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    160f <ConvertType+0x4ff>
jmp    1752 <ConvertType+0x642>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    167e <ConvertType+0x56e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzwl (%rax,%rcx,2),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    164d <ConvertType+0x53d>
jmp    1752 <ConvertType+0x642>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    16bb <ConvertType+0x5ab>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzwl (%rax,%rcx,2),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    168a <ConvertType+0x57a>
jmp    1752 <ConvertType+0x642>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    16fe <ConvertType+0x5ee>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzwl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16c7 <ConvertType+0x5b7>
jmp    1752 <ConvertType+0x642>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1741 <ConvertType+0x631>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzwl (%rax,%rcx,2),%eax
cvtsi2sd %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    170a <ConvertType+0x5fa>
jmp    1752 <ConvertType+0x642>
movl   $0x6,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
jmp    1f65 <ConvertType+0xe55>
movsbl -0x21(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x58(%rbp)
sub    $0x22,%eax
ja     1937 <ConvertType+0x827>
mov    -0x58(%rbp),%rax
lea    0xab8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    17ba <ConvertType+0x6aa>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1788 <ConvertType+0x678>
jmp    1943 <ConvertType+0x833>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    17fa <ConvertType+0x6ea>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17c6 <ConvertType+0x6b6>
jmp    1943 <ConvertType+0x833>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    183a <ConvertType+0x72a>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1806 <ConvertType+0x6f6>
jmp    1943 <ConvertType+0x833>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1876 <ConvertType+0x766>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1846 <ConvertType+0x736>
jmp    1943 <ConvertType+0x833>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    18b2 <ConvertType+0x7a2>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1882 <ConvertType+0x772>
jmp    1943 <ConvertType+0x833>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    18f2 <ConvertType+0x7e2>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18be <ConvertType+0x7ae>
jmp    1943 <ConvertType+0x833>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1932 <ConvertType+0x822>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18fe <ConvertType+0x7ee>
jmp    1943 <ConvertType+0x833>
movl   $0x6,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
jmp    1f65 <ConvertType+0xe55>
movsbl -0x21(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x60(%rbp)
sub    $0x22,%eax
ja     1b2e <ConvertType+0xa1e>
mov    -0x60(%rbp),%rax
lea    0x83b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    19ab <ConvertType+0x89b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1979 <ConvertType+0x869>
jmp    1b3a <ConvertType+0xa2a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    19eb <ConvertType+0x8db>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19b7 <ConvertType+0x8a7>
jmp    1b3a <ConvertType+0xa2a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a2b <ConvertType+0x91b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19f7 <ConvertType+0x8e7>
jmp    1b3a <ConvertType+0xa2a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a67 <ConvertType+0x957>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a37 <ConvertType+0x927>
jmp    1b3a <ConvertType+0xa2a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1aa3 <ConvertType+0x993>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a73 <ConvertType+0x963>
jmp    1b3a <ConvertType+0xa2a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ae6 <ConvertType+0x9d6>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cvtsi2ss %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1aaf <ConvertType+0x99f>
jmp    1b3a <ConvertType+0xa2a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b29 <ConvertType+0xa19>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cvtsi2sd %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1af2 <ConvertType+0x9e2>
jmp    1b3a <ConvertType+0xa2a>
movl   $0x6,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
jmp    1f65 <ConvertType+0xe55>
movsbl -0x21(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x68(%rbp)
sub    $0x22,%eax
ja     1d34 <ConvertType+0xc24>
mov    -0x68(%rbp),%rax
lea    0x5b8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ba4 <ConvertType+0xa94>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b70 <ConvertType+0xa60>
jmp    1d40 <ConvertType+0xc30>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1bea <ConvertType+0xada>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1bb0 <ConvertType+0xaa0>
jmp    1d40 <ConvertType+0xc30>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1c2c <ConvertType+0xb1c>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1bf6 <ConvertType+0xae6>
jmp    1d40 <ConvertType+0xc30>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1c6a <ConvertType+0xb5a>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1c38 <ConvertType+0xb28>
jmp    1d40 <ConvertType+0xc30>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1cab <ConvertType+0xb9b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvttss2si (%rax,%rcx,4),%rax
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1c76 <ConvertType+0xb66>
jmp    1d40 <ConvertType+0xc30>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ceb <ConvertType+0xbdb>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1cb7 <ConvertType+0xba7>
jmp    1d40 <ConvertType+0xc30>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1d2f <ConvertType+0xc1f>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1cf7 <ConvertType+0xbe7>
jmp    1d40 <ConvertType+0xc30>
movl   $0x6,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
jmp    1f65 <ConvertType+0xe55>
movsbl -0x21(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x70(%rbp)
sub    $0x22,%eax
ja     1f3a <ConvertType+0xe2a>
mov    -0x70(%rbp),%rax
lea    0x326(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1daa <ConvertType+0xc9a>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1d76 <ConvertType+0xc66>
jmp    1f46 <ConvertType+0xe36>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1df0 <ConvertType+0xce0>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1db6 <ConvertType+0xca6>
jmp    1f46 <ConvertType+0xe36>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e32 <ConvertType+0xd22>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%eax
mov    %ax,%dx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1dfc <ConvertType+0xcec>
jmp    1f46 <ConvertType+0xe36>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e70 <ConvertType+0xd60>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e3e <ConvertType+0xd2e>
jmp    1f46 <ConvertType+0xe36>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1eb1 <ConvertType+0xda1>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvttsd2si (%rax,%rcx,8),%rax
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e7c <ConvertType+0xd6c>
jmp    1f46 <ConvertType+0xe36>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ef5 <ConvertType+0xde5>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ebd <ConvertType+0xdad>
jmp    1f46 <ConvertType+0xe36>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1f35 <ConvertType+0xe25>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1f01 <ConvertType+0xdf1>
jmp    1f46 <ConvertType+0xe36>
movl   $0x6,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
jmp    1f65 <ConvertType+0xe55>
lea    0x50e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x6,-0x4(%rbp)
jmp    1f6c <ConvertType+0xe5c>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ConvertType>:
push   %rax
xor    %eax,%eax
cmp    $0x6e,%cl
jne    111a <ConvertType+0xa>
pop    %rcx
ret
movsbl %sil,%eax
add    $0xffffffad,%eax
cmp    $0x22,%eax
ja     11ec <ConvertType+0xdc>
lea    0x3f5f(%rip),%rsi
movslq (%rsi,%rax,4),%rax
add    %rsi,%rax
jmp    *%rax
mov    $0x6,%eax
add    $0xffffffad,%ecx
cmp    $0x22,%ecx
ja     1118 <ConvertType+0x8>
lea    0x4172(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1184 <ConvertType+0x74>
lea    (%rdi,%r9,4),%rax
cmp    %rdx,%rax
jbe    2345 <ConvertType+0x1235>
lea    (%rdx,%r9,4),%rax
cmp    %rdi,%rax
jbe    2345 <ConvertType+0x1235>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     11b0 <ConvertType+0xa0>
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rsi,4),%ecx
mov    %ecx,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    11a0 <ConvertType+0x90>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
nopl   0x0(%rax)
mov    (%rdi,%rsi,4),%ecx
mov    %ecx,(%rdx,%rsi,4)
mov    0x4(%rdi,%rsi,4),%ecx
mov    %ecx,0x4(%rdx,%rsi,4)
mov    0x8(%rdi,%rsi,4),%ecx
mov    %ecx,0x8(%rdx,%rsi,4)
mov    0xc(%rdi,%rsi,4),%ecx
mov    %ecx,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    11c0 <ConvertType+0xb0>
jmp    1118 <ConvertType+0x8>
lea    0x42fd(%rip),%rdi
call   1030 <puts@plt>
mov    $0x6,%eax
pop    %rcx
ret
mov    $0x6,%eax
add    $0xffffffad,%ecx
cmp    $0x22,%ecx
ja     1118 <ConvertType+0x8>
lea    0x401d(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1251 <ConvertType+0x141>
lea    (%rdi,%r9,4),%rax
cmp    %rdx,%rax
jbe    2752 <ConvertType+0x1642>
lea    (%rdx,%r9,4),%rax
cmp    %rdi,%rax
jbe    2752 <ConvertType+0x1642>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1275 <ConvertType+0x165>
mov    (%rdi,%rsi,4),%ecx
mov    %ecx,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1265 <ConvertType+0x155>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
mov    (%rdi,%rsi,4),%ecx
mov    %ecx,(%rdx,%rsi,4)
mov    0x4(%rdi,%rsi,4),%ecx
mov    %ecx,0x4(%rdx,%rsi,4)
mov    0x8(%rdi,%rsi,4),%ecx
mov    %ecx,0x8(%rdx,%rsi,4)
mov    0xc(%rdi,%rsi,4),%ecx
mov    %ecx,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1281 <ConvertType+0x171>
jmp    1118 <ConvertType+0x8>
mov    $0x6,%eax
add    $0xffffffad,%ecx
cmp    $0x22,%ecx
ja     1118 <ConvertType+0x8>
lea    0x419f(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     12ff <ConvertType+0x1ef>
lea    (%rdi,%r9,1),%rax
cmp    %rdx,%rax
jbe    277f <ConvertType+0x166f>
lea    (%rdx,%r9,4),%rax
cmp    %rdi,%rax
jbe    277f <ConvertType+0x166f>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rcx
and    $0x3,%rcx
je     1324 <ConvertType+0x214>
movzbl (%rdi,%rsi,1),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1313 <ConvertType+0x203>
cmp    $0x3,%r8
jb     1b75 <ConvertType+0xa65>
movzbl (%rdi,%rsi,1),%eax
mov    %eax,(%rdx,%rsi,4)
movzbl 0x1(%rdi,%rsi,1),%eax
mov    %eax,0x4(%rdx,%rsi,4)
movzbl 0x2(%rdi,%rsi,1),%eax
mov    %eax,0x8(%rdx,%rsi,4)
movzbl 0x3(%rdi,%rsi,1),%eax
mov    %eax,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    132e <ConvertType+0x21e>
jmp    1b75 <ConvertType+0xa65>
mov    $0x6,%eax
add    $0xffffffad,%ecx
cmp    $0x22,%ecx
ja     1118 <ConvertType+0x8>
lea    0x3da6(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    2372 <ConvertType+0x1262>
xor    %esi,%esi
jmp    345f <ConvertType+0x234f>
mov    $0x6,%eax
add    $0xffffffad,%ecx
cmp    $0x22,%ecx
ja     1118 <ConvertType+0x8>
lea    0x3def(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    23e2 <ConvertType+0x12d2>
xor    %esi,%esi
jmp    34a9 <ConvertType+0x2399>
mov    $0x6,%eax
add    $0xffffffad,%ecx
cmp    $0x22,%ecx
ja     1118 <ConvertType+0x8>
lea    0x3fdc(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    2450 <ConvertType+0x1340>
xor    %esi,%esi
jmp    34ff <ConvertType+0x23ef>
mov    $0x6,%eax
add    $0xffffffad,%ecx
cmp    $0x22,%ecx
ja     1118 <ConvertType+0x8>
lea    0x3f0d(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    24d8 <ConvertType+0x13c8>
xor    %esi,%esi
jmp    354e <ConvertType+0x243e>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     149b <ConvertType+0x38b>
lea    (%rdi,%r9,4),%rax
cmp    %rdx,%rax
jbe    2807 <ConvertType+0x16f7>
lea    (%rdx,%r9,4),%rax
cmp    %rdi,%rax
jbe    2807 <ConvertType+0x16f7>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     14bf <ConvertType+0x3af>
mov    (%rdi,%rsi,4),%ecx
mov    %ecx,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    14af <ConvertType+0x39f>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
mov    (%rdi,%rsi,4),%ecx
mov    %ecx,(%rdx,%rsi,4)
mov    0x4(%rdi,%rsi,4),%ecx
mov    %ecx,0x4(%rdx,%rsi,4)
mov    0x8(%rdi,%rsi,4),%ecx
mov    %ecx,0x8(%rdx,%rsi,4)
mov    0xc(%rdi,%rsi,4),%ecx
mov    %ecx,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    14cb <ConvertType+0x3bb>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1528 <ConvertType+0x418>
lea    (%rdi,%r9,4),%rax
cmp    %rdx,%rax
jbe    2834 <ConvertType+0x1724>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    2834 <ConvertType+0x1724>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     154d <ConvertType+0x43d>
movzbl (%rdi,%rsi,4),%ecx
mov    %cl,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    153c <ConvertType+0x42c>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzbl (%rdi,%rsi,4),%ecx
mov    %cl,(%rdx,%rsi,1)
movzbl 0x4(%rdi,%rsi,4),%ecx
mov    %cl,0x1(%rdx,%rsi,1)
movzbl 0x8(%rdi,%rsi,4),%ecx
mov    %cl,0x2(%rdx,%rsi,1)
movzbl 0xc(%rdi,%rsi,4),%ecx
mov    %cl,0x3(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1559 <ConvertType+0x449>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    2550 <ConvertType+0x1440>
xor    %esi,%esi
jmp    3591 <ConvertType+0x2481>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    25b2 <ConvertType+0x14a2>
xor    %esi,%esi
jmp    35dc <ConvertType+0x24cc>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    261a <ConvertType+0x150a>
xor    %esi,%esi
jmp    3641 <ConvertType+0x2531>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    26b6 <ConvertType+0x15a6>
xor    %esi,%esi
jmp    36a1 <ConvertType+0x2591>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1642 <ConvertType+0x532>
lea    (%rdi,%r9,4),%rax
cmp    %rdx,%rax
jbe    36b9 <ConvertType+0x25a9>
lea    (%rdx,%r9,4),%rax
cmp    %rdi,%rax
jbe    36b9 <ConvertType+0x25a9>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1666 <ConvertType+0x556>
mov    (%rdi,%rsi,4),%ecx
mov    %ecx,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1656 <ConvertType+0x546>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
mov    (%rdi,%rsi,4),%ecx
mov    %ecx,(%rdx,%rsi,4)
mov    0x4(%rdi,%rsi,4),%ecx
mov    %ecx,0x4(%rdx,%rsi,4)
mov    0x8(%rdi,%rsi,4),%ecx
mov    %ecx,0x8(%rdx,%rsi,4)
mov    0xc(%rdi,%rsi,4),%ecx
mov    %ecx,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1672 <ConvertType+0x562>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     16cf <ConvertType+0x5bf>
lea    (%rdi,%r9,4),%rax
cmp    %rdx,%rax
jbe    36e6 <ConvertType+0x25d6>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    36e6 <ConvertType+0x25d6>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     16f4 <ConvertType+0x5e4>
movzbl (%rdi,%rsi,4),%ecx
mov    %cl,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    16e3 <ConvertType+0x5d3>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzbl (%rdi,%rsi,4),%ecx
mov    %cl,(%rdx,%rsi,1)
movzbl 0x4(%rdi,%rsi,4),%ecx
mov    %cl,0x1(%rdx,%rsi,1)
movzbl 0x8(%rdi,%rsi,4),%ecx
mov    %cl,0x2(%rdx,%rsi,1)
movzbl 0xc(%rdi,%rsi,4),%ecx
mov    %cl,0x3(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1700 <ConvertType+0x5f0>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    32b1 <ConvertType+0x21a1>
xor    %esi,%esi
jmp    45ee <ConvertType+0x34de>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    28d0 <ConvertType+0x17c0>
xor    %esi,%esi
jmp    4020 <ConvertType+0x2f10>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    29bf <ConvertType+0x18af>
xor    %esi,%esi
jmp    4088 <ConvertType+0x2f78>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    2a5b <ConvertType+0x194b>
xor    %esi,%esi
jmp    40e8 <ConvertType+0x2fd8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     17e9 <ConvertType+0x6d9>
lea    (%rdi,%r9,1),%rax
cmp    %rdx,%rax
jbe    3782 <ConvertType+0x2672>
lea    (%rdx,%r9,4),%rax
cmp    %rdi,%rax
jbe    3782 <ConvertType+0x2672>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rcx
and    $0x3,%rcx
je     180e <ConvertType+0x6fe>
movzbl (%rdi,%rsi,1),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    17fd <ConvertType+0x6ed>
cmp    $0x3,%r8
jb     1b75 <ConvertType+0xa65>
movzbl (%rdi,%rsi,1),%eax
mov    %eax,(%rdx,%rsi,4)
movzbl 0x1(%rdi,%rsi,1),%eax
mov    %eax,0x4(%rdx,%rsi,4)
movzbl 0x2(%rdi,%rsi,1),%eax
mov    %eax,0x8(%rdx,%rsi,4)
movzbl 0x3(%rdi,%rsi,1),%eax
mov    %eax,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1818 <ConvertType+0x708>
jmp    1b75 <ConvertType+0xa65>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1879 <ConvertType+0x769>
lea    (%rdi,%r9,1),%rax
cmp    %rdx,%rax
jbe    3d8f <ConvertType+0x2c7f>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    3d8f <ConvertType+0x2c7f>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rcx
and    $0x3,%rcx
je     189e <ConvertType+0x78e>
movzbl (%rdi,%rsi,1),%eax
mov    %al,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    188d <ConvertType+0x77d>
cmp    $0x3,%r8
jb     1b75 <ConvertType+0xa65>
movzbl (%rdi,%rsi,1),%eax
mov    %al,(%rdx,%rsi,1)
movzbl 0x1(%rdi,%rsi,1),%eax
mov    %al,0x1(%rdx,%rsi,1)
movzbl 0x2(%rdi,%rsi,1),%eax
mov    %al,0x2(%rdx,%rsi,1)
movzbl 0x3(%rdi,%rsi,1),%eax
mov    %al,0x3(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    18a8 <ConvertType+0x798>
jmp    1b75 <ConvertType+0xa65>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jb     1909 <ConvertType+0x7f9>
lea    (%rdi,%r9,1),%rax
cmp    %rdx,%rax
jbe    3da0 <ConvertType+0x2c90>
lea    (%rdx,%r9,8),%rax
cmp    %rdi,%rax
jbe    3da0 <ConvertType+0x2c90>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1937 <ConvertType+0x827>
movzbl (%rdi,%rsi,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    191d <ConvertType+0x80d>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzbl (%rdi,%rsi,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
movzbl 0x1(%rdi,%rsi,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x8(%rdx,%rsi,8)
movzbl 0x2(%rdi,%rsi,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x10(%rdx,%rsi,8)
movzbl 0x3(%rdi,%rsi,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x18(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1943 <ConvertType+0x833>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     19c8 <ConvertType+0x8b8>
lea    (%rdi,%r9,1),%rax
cmp    %rdx,%rax
jbe    380a <ConvertType+0x26fa>
lea    (%rdx,%r9,4),%rax
cmp    %rdi,%rax
jbe    380a <ConvertType+0x26fa>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rcx
and    $0x3,%rcx
je     19f6 <ConvertType+0x8e6>
movzbl (%rdi,%rsi,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    19dc <ConvertType+0x8cc>
cmp    $0x3,%r8
jb     1b75 <ConvertType+0xa65>
movzbl (%rdi,%rsi,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movzbl 0x1(%rdi,%rsi,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
movzbl 0x2(%rdi,%rsi,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x8(%rdx,%rsi,4)
movzbl 0x3(%rdi,%rsi,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1a00 <ConvertType+0x8f0>
jmp    1b75 <ConvertType+0xa65>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x10,%r8d
jb     1a85 <ConvertType+0x975>
lea    (%rdi,%r9,1),%rax
cmp    %rdx,%rax
jbe    389a <ConvertType+0x278a>
lea    (%rdx,%r9,2),%rax
cmp    %rdi,%rax
jbe    389a <ConvertType+0x278a>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rcx
and    $0x3,%rcx
je     1aab <ConvertType+0x99b>
movzbl (%rdi,%rsi,1),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1a99 <ConvertType+0x989>
cmp    $0x3,%r8
jb     1b75 <ConvertType+0xa65>
movzbl (%rdi,%rsi,1),%eax
mov    %ax,(%rdx,%rsi,2)
movzbl 0x1(%rdi,%rsi,1),%eax
mov    %ax,0x2(%rdx,%rsi,2)
movzbl 0x2(%rdi,%rsi,1),%eax
mov    %ax,0x4(%rdx,%rsi,2)
movzbl 0x3(%rdi,%rsi,1),%eax
mov    %ax,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1ab5 <ConvertType+0x9a5>
jmp    1b75 <ConvertType+0xa65>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x10,%r8d
jb     1b1a <ConvertType+0xa0a>
lea    (%rdi,%r9,1),%rax
cmp    %rdx,%rax
jbe    391c <ConvertType+0x280c>
lea    (%rdx,%r9,2),%rax
cmp    %rdi,%rax
jbe    391c <ConvertType+0x280c>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rcx
and    $0x3,%rcx
je     1b40 <ConvertType+0xa30>
movzbl (%rdi,%rsi,1),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1b2e <ConvertType+0xa1e>
cmp    $0x3,%r8
jb     1b75 <ConvertType+0xa65>
movzbl (%rdi,%rsi,1),%eax
mov    %ax,(%rdx,%rsi,2)
movzbl 0x1(%rdi,%rsi,1),%eax
mov    %ax,0x2(%rdx,%rsi,2)
movzbl 0x2(%rdi,%rsi,1),%eax
mov    %ax,0x4(%rdx,%rsi,2)
movzbl 0x3(%rdi,%rsi,1),%eax
mov    %ax,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1b46 <ConvertType+0xa36>
xor    %eax,%eax
pop    %rcx
ret
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    334d <ConvertType+0x223d>
xor    %esi,%esi
jmp    467a <ConvertType+0x356a>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jb     1bcc <ConvertType+0xabc>
lea    (%rdi,%r9,8),%rax
cmp    %rdx,%rax
jbe    3e42 <ConvertType+0x2d32>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    3e42 <ConvertType+0x2d32>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1bf2 <ConvertType+0xae2>
cvttsd2si (%rdi,%rsi,8),%ecx
mov    %cl,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1be0 <ConvertType+0xad0>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
cvttsd2si (%rdi,%rsi,8),%ecx
mov    %cl,(%rdx,%rsi,1)
cvttsd2si 0x8(%rdi,%rsi,8),%ecx
mov    %cl,0x1(%rdx,%rsi,1)
cvttsd2si 0x10(%rdi,%rsi,8),%ecx
mov    %cl,0x2(%rdx,%rsi,1)
cvttsd2si 0x18(%rdi,%rsi,8),%ecx
mov    %cl,0x3(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1bfe <ConvertType+0xaee>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jb     1c63 <ConvertType+0xb53>
lea    (%rdi,%r9,8),%rax
cmp    %rdx,%rax
jbe    3ee2 <ConvertType+0x2dd2>
lea    (%rdx,%r9,8),%rax
cmp    %rdi,%rax
jbe    3ee2 <ConvertType+0x2dd2>
xor    %esi,%esi
mov    %rsi,%rcx
not    %rcx
add    %r9,%rcx
mov    %r9,%rax
and    $0x3,%rax
je     1c8b <ConvertType+0xb7b>
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1c77 <ConvertType+0xb67>
xor    %eax,%eax
cmp    $0x3,%rcx
jb     1118 <ConvertType+0x8>
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
movsd  0x8(%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rsi,8)
movsd  0x10(%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rsi,8)
movsd  0x18(%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1c97 <ConvertType+0xb87>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    2af7 <ConvertType+0x19e7>
xor    %esi,%esi
jmp    4132 <ConvertType+0x3022>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    2b67 <ConvertType+0x1a57>
xor    %esi,%esi
jmp    418e <ConvertType+0x307e>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    2bef <ConvertType+0x1adf>
xor    %esi,%esi
jmp    41e5 <ConvertType+0x30d5>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    2c77 <ConvertType+0x1b67>
xor    %esi,%esi
jmp    4267 <ConvertType+0x3157>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1d8c <ConvertType+0xc7c>
lea    (%rdi,%r9,4),%rax
cmp    %rdx,%rax
jbe    399e <ConvertType+0x288e>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    399e <ConvertType+0x288e>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1db2 <ConvertType+0xca2>
cvttss2si (%rdi,%rsi,4),%ecx
mov    %cl,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1da0 <ConvertType+0xc90>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
cvttss2si (%rdi,%rsi,4),%ecx
mov    %cl,(%rdx,%rsi,1)
cvttss2si 0x4(%rdi,%rsi,4),%ecx
mov    %cl,0x1(%rdx,%rsi,1)
cvttss2si 0x8(%rdi,%rsi,4),%ecx
mov    %cl,0x2(%rdx,%rsi,1)
cvttss2si 0xc(%rdi,%rsi,4),%ecx
mov    %cl,0x3(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1dbe <ConvertType+0xcae>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    2d52 <ConvertType+0x1c42>
xor    %esi,%esi
jmp    42a9 <ConvertType+0x3199>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1e45 <ConvertType+0xd35>
lea    (%rdi,%r9,4),%rax
cmp    %rdx,%rax
jbe    3a2e <ConvertType+0x291e>
lea    (%rdx,%r9,4),%rax
cmp    %rdi,%rax
jbe    3a2e <ConvertType+0x291e>
xor    %esi,%esi
mov    %rsi,%rcx
not    %rcx
add    %r9,%rcx
mov    %r9,%rax
and    $0x3,%rax
je     1e6d <ConvertType+0xd5d>
movss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1e59 <ConvertType+0xd49>
xor    %eax,%eax
cmp    $0x3,%rcx
jb     1118 <ConvertType+0x8>
movss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  0x4(%rdi,%rsi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
movss  0x8(%rdi,%rsi,4),%xmm0
movss  %xmm0,0x8(%rdx,%rsi,4)
movss  0xc(%rdi,%rsi,4),%xmm0
movss  %xmm0,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1e79 <ConvertType+0xd69>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    2daf <ConvertType+0x1c9f>
xor    %esi,%esi
jmp    42f7 <ConvertType+0x31e7>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    2e1b <ConvertType+0x1d0b>
xor    %esi,%esi
jmp    435e <ConvertType+0x324e>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    2ec3 <ConvertType+0x1db3>
xor    %esi,%esi
jmp    43b5 <ConvertType+0x32a5>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x10,%r8d
jb     1f4c <ConvertType+0xe3c>
lea    (%rdi,%r9,2),%rax
cmp    %rdx,%rax
jbe    3a5b <ConvertType+0x294b>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    3a5b <ConvertType+0x294b>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1f71 <ConvertType+0xe61>
movzbl (%rdi,%rsi,2),%ecx
mov    %cl,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1f60 <ConvertType+0xe50>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzbl (%rdi,%rsi,2),%ecx
mov    %cl,(%rdx,%rsi,1)
movzbl 0x2(%rdi,%rsi,2),%ecx
mov    %cl,0x1(%rdx,%rsi,1)
movzbl 0x4(%rdi,%rsi,2),%ecx
mov    %cl,0x2(%rdx,%rsi,1)
movzbl 0x6(%rdi,%rsi,2),%ecx
mov    %cl,0x3(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1f7d <ConvertType+0xe6d>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    2f4b <ConvertType+0x1e3b>
xor    %esi,%esi
jmp    4414 <ConvertType+0x3304>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    2fe5 <ConvertType+0x1ed5>
xor    %esi,%esi
jmp    4476 <ConvertType+0x3366>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x10,%r8d
jb     2022 <ConvertType+0xf12>
lea    (%rdi,%r9,2),%rax
cmp    %rdx,%rax
jbe    3add <ConvertType+0x29cd>
lea    (%rdx,%r9,2),%rax
cmp    %rdi,%rax
jbe    3add <ConvertType+0x29cd>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     2048 <ConvertType+0xf38>
movzwl (%rdi,%rsi,2),%ecx
mov    %cx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    2036 <ConvertType+0xf26>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,2),%ecx
mov    %cx,(%rdx,%rsi,2)
movzwl 0x2(%rdi,%rsi,2),%ecx
mov    %cx,0x2(%rdx,%rsi,2)
movzwl 0x4(%rdi,%rsi,2),%ecx
mov    %cx,0x4(%rdx,%rsi,2)
movzwl 0x6(%rdi,%rsi,2),%ecx
mov    %cx,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    2054 <ConvertType+0xf44>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x10,%r8d
jb     20b9 <ConvertType+0xfa9>
lea    (%rdi,%r9,2),%rax
cmp    %rdx,%rax
jbe    3b0a <ConvertType+0x29fa>
lea    (%rdx,%r9,2),%rax
cmp    %rdi,%rax
jbe    3b0a <ConvertType+0x29fa>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     20df <ConvertType+0xfcf>
movzwl (%rdi,%rsi,2),%ecx
mov    %cx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    20cd <ConvertType+0xfbd>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,2),%ecx
mov    %cx,(%rdx,%rsi,2)
movzwl 0x2(%rdi,%rsi,2),%ecx
mov    %cx,0x2(%rdx,%rsi,2)
movzwl 0x4(%rdi,%rsi,2),%ecx
mov    %cx,0x4(%rdx,%rsi,2)
movzwl 0x6(%rdi,%rsi,2),%ecx
mov    %cx,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    20eb <ConvertType+0xfdb>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    3075 <ConvertType+0x1f65>
xor    %esi,%esi
jmp    44ce <ConvertType+0x33be>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x10,%r8d
jb     2172 <ConvertType+0x1062>
lea    (%rdi,%r9,2),%rax
cmp    %rdx,%rax
jbe    3b37 <ConvertType+0x2a27>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    3b37 <ConvertType+0x2a27>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     2197 <ConvertType+0x1087>
movzbl (%rdi,%rsi,2),%ecx
mov    %cl,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    2186 <ConvertType+0x1076>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzbl (%rdi,%rsi,2),%ecx
mov    %cl,(%rdx,%rsi,1)
movzbl 0x2(%rdi,%rsi,2),%ecx
mov    %cl,0x1(%rdx,%rsi,1)
movzbl 0x4(%rdi,%rsi,2),%ecx
mov    %cl,0x2(%rdx,%rsi,1)
movzbl 0x6(%rdi,%rsi,2),%ecx
mov    %cl,0x3(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    21a3 <ConvertType+0x1093>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x4,%r8d
jae    30ed <ConvertType+0x1fdd>
xor    %esi,%esi
jmp    4525 <ConvertType+0x3415>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jae    3173 <ConvertType+0x2063>
xor    %esi,%esi
jmp    4580 <ConvertType+0x3470>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x10,%r8d
jb     2248 <ConvertType+0x1138>
lea    (%rdi,%r9,2),%rax
cmp    %rdx,%rax
jbe    3bb9 <ConvertType+0x2aa9>
lea    (%rdx,%r9,2),%rax
cmp    %rdi,%rax
jbe    3bb9 <ConvertType+0x2aa9>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     226e <ConvertType+0x115e>
movzwl (%rdi,%rsi,2),%ecx
mov    %cx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    225c <ConvertType+0x114c>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,2),%ecx
mov    %cx,(%rdx,%rsi,2)
movzwl 0x2(%rdi,%rsi,2),%ecx
mov    %cx,0x2(%rdx,%rsi,2)
movzwl 0x4(%rdi,%rsi,2),%ecx
mov    %cx,0x4(%rdx,%rsi,2)
movzwl 0x6(%rdi,%rsi,2),%ecx
mov    %cx,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    227a <ConvertType+0x116a>
jmp    1118 <ConvertType+0x8>
mov    $0x0,%eax
test   %r8d,%r8d
jle    1118 <ConvertType+0x8>
mov    %r8d,%r9d
cmp    $0x10,%r8d
jb     22df <ConvertType+0x11cf>
lea    (%rdi,%r9,2),%rax
cmp    %rdx,%rax
jbe    3be6 <ConvertType+0x2ad6>
lea    (%rdx,%r9,2),%rax
cmp    %rdi,%rax
jbe    3be6 <ConvertType+0x2ad6>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     2305 <ConvertType+0x11f5>
movzwl (%rdi,%rsi,2),%ecx
mov    %cx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    22f3 <ConvertType+0x11e3>
xor    %eax,%eax
cmp    $0x3,%r8
jb     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,2),%ecx
mov    %cx,(%rdx,%rsi,2)
movzwl 0x2(%rdi,%rsi,2),%ecx
mov    %cx,0x2(%rdx,%rsi,2)
movzwl 0x4(%rdi,%rsi,2),%ecx
mov    %cx,0x4(%rdx,%rsi,2)
movzwl 0x6(%rdi,%rsi,2),%ecx
mov    %cx,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    2311 <ConvertType+0x1201>
jmp    1118 <ConvertType+0x8>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x18,%rcx
jae    31f3 <ConvertType+0x20e3>
xor    %ecx,%ecx
jmp    3262 <ConvertType+0x2152>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     342d <ConvertType+0x231d>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rdx,%rax,4)
movupd 0x20(%rdi,%rax,8),%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x10(%rdx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2399 <ConvertType+0x1289>
jmp    342f <ConvertType+0x231f>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     3477 <ConvertType+0x2367>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
movupd %xmm0,0x20(%rdx,%rax,4)
movupd %xmm1,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2409 <ConvertType+0x12f9>
jmp    3479 <ConvertType+0x2369>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     34c1 <ConvertType+0x23b1>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movq   (%rdi,%rax,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
psrad  $0x10,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
movq   0x10(%rdi,%rax,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x18(%rdi,%rax,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
psrad  $0x10,%xmm1
movdqu %xmm0,0x20(%rdx,%rax,4)
movdqu %xmm1,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2477 <ConvertType+0x1367>
jmp    34c3 <ConvertType+0x23b3>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     3516 <ConvertType+0x2406>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movq   (%rdi,%rax,2),%xmm1
movq   0x8(%rdi,%rax,2),%xmm2
punpcklwd %xmm0,%xmm1
punpcklwd %xmm0,%xmm2
movdqu %xmm1,(%rdx,%rax,4)
movdqu %xmm2,0x10(%rdx,%rax,4)
movq   0x10(%rdi,%rax,2),%xmm1
movq   0x18(%rdi,%rax,2),%xmm2
punpcklwd %xmm0,%xmm1
punpcklwd %xmm0,%xmm2
movdqu %xmm1,0x20(%rdx,%rax,4)
movdqu %xmm2,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2503 <ConvertType+0x13f3>
jmp    3518 <ConvertType+0x2408>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     3565 <ConvertType+0x2455>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
cvtdq2pd (%rdi,%rax,4),%xmm0
cvtdq2pd 0x8(%rdi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,8)
movups %xmm1,0x10(%rdx,%rax,8)
cvtdq2pd 0x10(%rdi,%rax,4),%xmm0
cvtdq2pd 0x18(%rdi,%rax,4),%xmm1
movupd %xmm0,0x20(%rdx,%rax,8)
movupd %xmm1,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2577 <ConvertType+0x1467>
jmp    3567 <ConvertType+0x2457>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     35ae <ConvertType+0x249e>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvtdq2ps %xmm0,%xmm0
cvtdq2ps %xmm1,%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
cvtdq2ps %xmm0,%xmm0
cvtdq2ps %xmm1,%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    25d9 <ConvertType+0x14c9>
jmp    35b0 <ConvertType+0x24a0>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     35f9 <ConvertType+0x24e9>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
movdqu 0x20(%rdi,%rax,4),%xmm0
movdqu 0x30(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,0x10(%rdx,%rax,2)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2641 <ConvertType+0x1531>
jmp    35fb <ConvertType+0x24eb>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     3659 <ConvertType+0x2549>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
movdqu 0x20(%rdi,%rax,4),%xmm0
movdqu 0x30(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,0x10(%rdx,%rax,2)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    26dd <ConvertType+0x15cd>
jmp    365b <ConvertType+0x254b>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x18,%rcx
jae    3c13 <ConvertType+0x2b03>
xor    %ecx,%ecx
jmp    3c82 <ConvertType+0x2b72>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     3f0f <ConvertType+0x2dff>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movd   (%rdi,%rax,1),%xmm1
movd   0x4(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movdqu %xmm1,(%rdx,%rax,4)
movdqu %xmm2,0x10(%rdx,%rax,4)
movd   0x8(%rdi,%rax,1),%xmm1
movd   0xc(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movdqu %xmm1,0x20(%rdx,%rax,4)
movdqu %xmm2,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    27aa <ConvertType+0x169a>
jmp    3f11 <ConvertType+0x2e01>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x18,%rcx
jae    3cd1 <ConvertType+0x2bc1>
xor    %ecx,%ecx
jmp    3d40 <ConvertType+0x2c30>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     3f54 <ConvertType+0x2e44>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movdqa 0x280d(%rip),%xmm0
movdqu (%rdi,%rax,4),%xmm1
movdqu 0x10(%rdi,%rax,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,(%rdx,%rax,1)
movd   %xmm2,0x4(%rdx,%rax,1)
movdqu 0x20(%rdi,%rax,4),%xmm1
movdqu 0x30(%rdi,%rax,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%rdx,%rax,1)
movd   %xmm2,0xc(%rdx,%rax,1)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2863 <ConvertType+0x1753>
jmp    3f56 <ConvertType+0x2e46>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     3fa5 <ConvertType+0x2e95>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movdqa 0x2731(%rip),%xmm0
movdqa 0x2739(%rip),%xmm1
movdqa 0x2741(%rip),%xmm2
movaps 0x274a(%rip),%xmm3
movdqu (%rdi,%rax,4),%xmm4
movdqu 0x10(%rdi,%rax,4),%xmm5
movdqa %xmm4,%xmm6
pand   %xmm0,%xmm6
por    %xmm1,%xmm6
psrld  $0x10,%xmm4
por    %xmm2,%xmm4
subps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movdqa %xmm5,%xmm6
pand   %xmm0,%xmm6
por    %xmm1,%xmm6
psrld  $0x10,%xmm5
por    %xmm2,%xmm5
subps  %xmm3,%xmm5
addps  %xmm6,%xmm5
movups %xmm4,(%rdx,%rax,4)
movups %xmm5,0x10(%rdx,%rax,4)
movdqu 0x20(%rdi,%rax,4),%xmm4
movdqu 0x30(%rdi,%rax,4),%xmm5
movdqa %xmm4,%xmm6
pand   %xmm0,%xmm6
por    %xmm1,%xmm6
psrld  $0x10,%xmm4
por    %xmm2,%xmm4
subps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movdqa %xmm5,%xmm6
pand   %xmm0,%xmm6
por    %xmm1,%xmm6
psrld  $0x10,%xmm5
por    %xmm2,%xmm5
subps  %xmm3,%xmm5
addps  %xmm6,%xmm5
movups %xmm4,0x20(%rdx,%rax,4)
movups %xmm5,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2916 <ConvertType+0x1806>
jmp    3fa7 <ConvertType+0x2e97>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4040 <ConvertType+0x2f30>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
movdqu 0x20(%rdi,%rax,4),%xmm0
movdqu 0x30(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,0x10(%rdx,%rax,2)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    29e6 <ConvertType+0x18d6>
jmp    4042 <ConvertType+0x2f32>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     40a0 <ConvertType+0x2f90>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
movdqu 0x20(%rdi,%rax,4),%xmm0
movdqu 0x30(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,0x10(%rdx,%rax,2)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2a82 <ConvertType+0x1972>
jmp    40a2 <ConvertType+0x2f92>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     4100 <ConvertType+0x2ff0>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rdx,%rax,4)
movupd 0x20(%rdi,%rax,8),%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x10(%rdx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2b1e <ConvertType+0x1a0e>
jmp    4102 <ConvertType+0x2ff2>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     4150 <ConvertType+0x3040>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
movd   %xmm0,(%rdx,%rax,2)
movd   %xmm1,0x4(%rdx,%rax,2)
movupd 0x20(%rdi,%rax,8),%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
pshuflw $0xe8,%xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm1,%xmm1
movd   %xmm0,0x8(%rdx,%rax,2)
movd   %xmm1,0xc(%rdx,%rax,2)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2b8e <ConvertType+0x1a7e>
jmp    4152 <ConvertType+0x3042>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     41a7 <ConvertType+0x3097>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
movd   %xmm0,(%rdx,%rax,2)
movd   %xmm1,0x4(%rdx,%rax,2)
movupd 0x20(%rdi,%rax,8),%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
pshuflw $0xe8,%xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm1,%xmm1
movd   %xmm0,0x8(%rdx,%rax,2)
movd   %xmm1,0xc(%rdx,%rax,2)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2c16 <ConvertType+0x1b06>
jmp    41a9 <ConvertType+0x3099>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     41fe <ConvertType+0x30ee>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movaps 0x236b(%rip),%xmm0
movups (%rdi,%rax,4),%xmm1
movups 0x10(%rdi,%rax,4),%xmm2
cvttps2dq %xmm1,%xmm3
movdqa %xmm3,%xmm4
psrad  $0x1f,%xmm4
subps  %xmm0,%xmm1
cvttps2dq %xmm1,%xmm1
pand   %xmm4,%xmm1
por    %xmm3,%xmm1
cvttps2dq %xmm2,%xmm3
movdqa %xmm3,%xmm4
psrad  $0x1f,%xmm4
subps  %xmm0,%xmm2
cvttps2dq %xmm2,%xmm2
pand   %xmm4,%xmm2
por    %xmm3,%xmm2
movdqu %xmm1,(%rdx,%rax,4)
movdqu %xmm2,0x10(%rdx,%rax,4)
movups 0x20(%rdi,%rax,4),%xmm1
movups 0x30(%rdi,%rax,4),%xmm2
cvttps2dq %xmm1,%xmm3
movdqa %xmm3,%xmm4
psrad  $0x1f,%xmm4
subps  %xmm0,%xmm1
cvttps2dq %xmm1,%xmm1
pand   %xmm4,%xmm1
por    %xmm3,%xmm1
cvttps2dq %xmm2,%xmm3
movdqa %xmm3,%xmm4
psrad  $0x1f,%xmm4
subps  %xmm0,%xmm2
cvttps2dq %xmm2,%xmm2
pand   %xmm4,%xmm2
por    %xmm3,%xmm2
movdqu %xmm1,0x20(%rdx,%rax,4)
movdqu %xmm2,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2ca5 <ConvertType+0x1b95>
jmp    4200 <ConvertType+0x30f0>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     4280 <ConvertType+0x3170>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
cvtps2pd (%rdi,%rax,4),%xmm0
cvtps2pd 0x8(%rdi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,8)
movups %xmm1,0x10(%rdx,%rax,8)
cvtps2pd 0x10(%rdi,%rax,4),%xmm0
cvtps2pd 0x18(%rdi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,8)
movupd %xmm1,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2d79 <ConvertType+0x1c69>
jmp    4282 <ConvertType+0x3172>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     42c7 <ConvertType+0x31b7>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
packssdw %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
packssdw %xmm1,%xmm0
movdqu %xmm0,0x10(%rdx,%rax,2)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2dd6 <ConvertType+0x1cc6>
jmp    42c9 <ConvertType+0x31b9>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4310 <ConvertType+0x3200>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,0x10(%rdx,%rax,2)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2e42 <ConvertType+0x1d32>
jmp    4312 <ConvertType+0x3202>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4377 <ConvertType+0x3267>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movq   (%rdi,%rax,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
psrad  $0x10,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
movq   0x10(%rdi,%rax,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x18(%rdi,%rax,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
psrad  $0x10,%xmm1
movdqu %xmm0,0x20(%rdx,%rax,4)
movdqu %xmm1,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    2eea <ConvertType+0x1dda>
jmp    4379 <ConvertType+0x3269>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     43cc <ConvertType+0x32bc>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movd   (%rdi,%rax,2),%xmm0
movd   0x4(%rdi,%rax,2),%xmm1
pshuflw $0x60,%xmm0,%xmm0
psrad  $0x10,%xmm0
cvtdq2pd %xmm0,%xmm0
pshuflw $0x60,%xmm1,%xmm1
psrad  $0x10,%xmm1
cvtdq2pd %xmm1,%xmm1
movups %xmm0,(%rdx,%rax,8)
movups %xmm1,0x10(%rdx,%rax,8)
movd   0x8(%rdi,%rax,2),%xmm0
movd   0xc(%rdi,%rax,2),%xmm1
pshuflw $0x60,%xmm0,%xmm0
psrad  $0x10,%xmm0
cvtdq2pd %xmm0,%xmm0
pshuflw $0x60,%xmm1,%xmm1
psrad  $0x10,%xmm1
cvtdq2pd %xmm1,%xmm1
movupd %xmm0,0x20(%rdx,%rax,8)
movupd %xmm1,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2f72 <ConvertType+0x1e62>
jmp    43ce <ConvertType+0x32be>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4434 <ConvertType+0x3324>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movq   (%rdi,%rax,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
cvtdq2ps %xmm0,%xmm0
psrad  $0x10,%xmm1
cvtdq2ps %xmm1,%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movq   0x10(%rdi,%rax,2),%xmm0
punpcklwd %xmm0,%xmm0
movq   0x18(%rdi,%rax,2),%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm0
cvtdq2ps %xmm0,%xmm0
psrad  $0x10,%xmm1
cvtdq2ps %xmm1,%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    300c <ConvertType+0x1efc>
jmp    4436 <ConvertType+0x3326>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4496 <ConvertType+0x3386>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movq   (%rdi,%rax,2),%xmm1
movq   0x8(%rdi,%rax,2),%xmm2
punpcklwd %xmm0,%xmm1
punpcklwd %xmm0,%xmm2
movdqu %xmm1,(%rdx,%rax,4)
movdqu %xmm2,0x10(%rdx,%rax,4)
movq   0x10(%rdi,%rax,2),%xmm1
movq   0x18(%rdi,%rax,2),%xmm2
punpcklwd %xmm0,%xmm1
punpcklwd %xmm0,%xmm2
movdqu %xmm1,0x20(%rdx,%rax,4)
movdqu %xmm2,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    30a0 <ConvertType+0x1f90>
jmp    4498 <ConvertType+0x3388>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     44e5 <ConvertType+0x33d5>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movd   (%rdi,%rax,2),%xmm1
movd   0x4(%rdi,%rax,2),%xmm2
punpcklwd %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm1
punpcklwd %xmm0,%xmm2
cvtdq2pd %xmm2,%xmm2
movups %xmm1,(%rdx,%rax,8)
movups %xmm2,0x10(%rdx,%rax,8)
movd   0x8(%rdi,%rax,2),%xmm1
punpcklwd %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm1
movd   0xc(%rdi,%rax,2),%xmm2
punpcklwd %xmm0,%xmm2
cvtdq2pd %xmm2,%xmm2
movupd %xmm1,0x20(%rdx,%rax,8)
movdqu %xmm2,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    3118 <ConvertType+0x2008>
jmp    44e7 <ConvertType+0x33d7>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4545 <ConvertType+0x3435>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movq   (%rdi,%rax,2),%xmm1
movq   0x8(%rdi,%rax,2),%xmm2
punpcklwd %xmm0,%xmm1
cvtdq2ps %xmm1,%xmm1
punpcklwd %xmm0,%xmm2
cvtdq2ps %xmm2,%xmm2
movups %xmm1,(%rdx,%rax,4)
movups %xmm2,0x10(%rdx,%rax,4)
movq   0x10(%rdi,%rax,2),%xmm1
movq   0x18(%rdi,%rax,2),%xmm2
punpcklwd %xmm0,%xmm1
cvtdq2ps %xmm1,%xmm1
punpcklwd %xmm0,%xmm2
cvtdq2ps %xmm2,%xmm2
movups %xmm1,0x20(%rdx,%rax,4)
movups %xmm2,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    319e <ConvertType+0x208e>
jmp    4547 <ConvertType+0x3437>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,4),%xmm0
movups 0x10(%rdi,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x20(%rdi,%rcx,4),%xmm0
movups 0x30(%rdi,%rcx,4),%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
movups 0x40(%rdi,%rcx,4),%xmm0
movups 0x50(%rdi,%rcx,4),%xmm1
movups %xmm0,0x40(%rdx,%rcx,4)
movups %xmm1,0x50(%rdx,%rcx,4)
movupd 0x60(%rdi,%rcx,4),%xmm0
movupd 0x70(%rdi,%rcx,4),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,4)
movupd %xmm1,0x70(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rax
jne    3206 <ConvertType+0x20f6>
test   %r8,%r8
je     329e <ConvertType+0x218e>
lea    (%rdx,%rcx,4),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    327d <ConvertType+0x216d>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1186 <ConvertType+0x76>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     45a0 <ConvertType+0x3490>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
xorpd  %xmm0,%xmm0
movapd 0x1d3c(%rip),%xmm1
movsd  (%rdi,%rax,4),%xmm2
movsd  0x8(%rdi,%rax,4),%xmm3
unpcklps %xmm0,%xmm2
orpd   %xmm1,%xmm2
subpd  %xmm1,%xmm2
unpcklps %xmm0,%xmm3
orpd   %xmm1,%xmm3
subpd  %xmm1,%xmm3
movupd %xmm2,(%rdx,%rax,8)
movupd %xmm3,0x10(%rdx,%rax,8)
movsd  0x10(%rdi,%rax,4),%xmm2
movsd  0x18(%rdi,%rax,4),%xmm3
unpcklps %xmm0,%xmm2
orpd   %xmm1,%xmm2
subpd  %xmm1,%xmm2
unpcklps %xmm0,%xmm3
orpd   %xmm1,%xmm3
subpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rdx,%rax,8)
movupd %xmm3,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    32e4 <ConvertType+0x21d4>
jmp    45a2 <ConvertType+0x3492>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     460e <ConvertType+0x34fe>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movapd 0x1c84(%rip),%xmm0
movupd (%rdi,%rax,8),%xmm1
movupd 0x10(%rdi,%rax,8),%xmm2
cvttpd2dq %xmm1,%xmm3
movapd %xmm3,%xmm4
psrad  $0x1f,%xmm4
subpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm1
andpd  %xmm4,%xmm1
orpd   %xmm3,%xmm1
cvttpd2dq %xmm2,%xmm3
movapd %xmm3,%xmm4
psrad  $0x1f,%xmm4
subpd  %xmm0,%xmm2
cvttpd2dq %xmm2,%xmm2
andpd  %xmm4,%xmm2
orpd   %xmm3,%xmm2
unpcklpd %xmm2,%xmm1
movupd %xmm1,(%rdx,%rax,4)
movupd 0x20(%rdi,%rax,8),%xmm1
movupd 0x30(%rdi,%rax,8),%xmm2
cvttpd2dq %xmm1,%xmm3
movapd %xmm3,%xmm4
psrad  $0x1f,%xmm4
subpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm1
andpd  %xmm4,%xmm1
orpd   %xmm3,%xmm1
cvttpd2dq %xmm2,%xmm3
movapd %xmm3,%xmm4
psrad  $0x1f,%xmm4
subpd  %xmm0,%xmm2
cvttpd2dq %xmm2,%xmm2
andpd  %xmm4,%xmm2
orpd   %xmm3,%xmm2
unpcklpd %xmm2,%xmm1
movupd %xmm1,0x10(%rdx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    337c <ConvertType+0x226c>
jmp    4610 <ConvertType+0x3500>
xor    %eax,%eax
test   $0x1,%r8b
je     3451 <ConvertType+0x2341>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
cvttsd2si (%rdi,%rsi,8),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    345f <ConvertType+0x234f>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     349b <ConvertType+0x238b>
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
movupd %xmm0,(%rdx,%rax,4)
movupd %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
cvttss2si (%rdi,%rsi,4),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    34a9 <ConvertType+0x2399>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     34f1 <ConvertType+0x23e1>
movq   (%rdi,%rax,2),%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
punpcklwd %xmm0,%xmm0
psrad  $0x10,%xmm0
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movswl (%rdi,%rsi,2),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    34ff <ConvertType+0x23ef>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     3540 <ConvertType+0x2430>
movq   (%rdi,%rax,2),%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
pxor   %xmm2,%xmm2
punpcklwd %xmm2,%xmm0
punpcklwd %xmm2,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,2),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    354e <ConvertType+0x243e>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     3583 <ConvertType+0x2473>
cvtdq2pd (%rdi,%rax,4),%xmm0
cvtdq2pd 0x8(%rdi,%rax,4),%xmm1
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
xor    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rdi,%rsi,4),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r9
jne    3593 <ConvertType+0x2483>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     35ce <ConvertType+0x24be>
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvtdq2ps %xmm0,%xmm0
cvtdq2ps %xmm1,%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
xor    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2ssl (%rdi,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r9
jne    35de <ConvertType+0x24ce>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     3633 <ConvertType+0x2523>
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,4),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    3641 <ConvertType+0x2531>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     3693 <ConvertType+0x2583>
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,4),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    36a1 <ConvertType+0x2591>
jmp    1118 <ConvertType+0x8>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x18,%rcx
jae    4693 <ConvertType+0x3583>
xor    %ecx,%ecx
jmp    4702 <ConvertType+0x35f2>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4bbe <ConvertType+0x3aae>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movdqa 0x195b(%rip),%xmm0
movdqu (%rdi,%rax,4),%xmm1
movdqu 0x10(%rdi,%rax,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,(%rdx,%rax,1)
movd   %xmm2,0x4(%rdx,%rax,1)
movdqu 0x20(%rdi,%rax,4),%xmm1
movdqu 0x30(%rdi,%rax,4),%xmm2
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%rdx,%rax,1)
movd   %xmm2,0xc(%rdx,%rax,1)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    3715 <ConvertType+0x2605>
jmp    4bc0 <ConvertType+0x3ab0>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4c0f <ConvertType+0x3aff>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movd   (%rdi,%rax,1),%xmm1
movd   0x4(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movdqu %xmm1,(%rdx,%rax,4)
movdqu %xmm2,0x10(%rdx,%rax,4)
movd   0x8(%rdi,%rax,1),%xmm1
movd   0xc(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movdqu %xmm1,0x20(%rdx,%rax,4)
movdqu %xmm2,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    37ad <ConvertType+0x269d>
jmp    4c11 <ConvertType+0x3b01>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4c54 <ConvertType+0x3b44>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movd   (%rdi,%rax,1),%xmm1
movd   0x4(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
cvtdq2ps %xmm1,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
cvtdq2ps %xmm2,%xmm2
movups %xmm1,(%rdx,%rax,4)
movups %xmm2,0x10(%rdx,%rax,4)
movd   0x8(%rdi,%rax,1),%xmm1
movd   0xc(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
cvtdq2ps %xmm1,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
cvtdq2ps %xmm2,%xmm2
movups %xmm1,0x20(%rdx,%rax,4)
movups %xmm2,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    3835 <ConvertType+0x2725>
jmp    4c56 <ConvertType+0x3b46>
mov    %r9d,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rax
mov    %rax,%r8
shr    $0x4,%r8
add    $0x1,%r8
test   %rax,%rax
je     4c9c <ConvertType+0x3b8c>
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
or     $0x2,%rcx
and    %r8,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movq   (%rdi,%rax,1),%xmm1
movq   0x8(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,(%rdx,%rax,2)
movdqu %xmm2,0x10(%rdx,%rax,2)
movq   0x10(%rdi,%rax,1),%xmm1
movq   0x18(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,0x20(%rdx,%rax,2)
movdqu %xmm2,0x30(%rdx,%rax,2)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rcx
jne    38cf <ConvertType+0x27bf>
jmp    4c9e <ConvertType+0x3b8e>
mov    %r9d,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rax
mov    %rax,%r8
shr    $0x4,%r8
add    $0x1,%r8
test   %rax,%rax
je     4cd9 <ConvertType+0x3bc9>
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
or     $0x2,%rcx
and    %r8,%rcx
xor    %eax,%eax
pxor   %xmm0,%xmm0
movq   (%rdi,%rax,1),%xmm1
movq   0x8(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,(%rdx,%rax,2)
movdqu %xmm2,0x10(%rdx,%rax,2)
movq   0x10(%rdi,%rax,1),%xmm1
movq   0x18(%rdi,%rax,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
movdqu %xmm1,0x20(%rdx,%rax,2)
movdqu %xmm2,0x30(%rdx,%rax,2)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rcx
jne    3951 <ConvertType+0x2841>
jmp    4cdb <ConvertType+0x3bcb>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     4d16 <ConvertType+0x3c06>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rdx,%rax,1)
movd   %xmm1,0x4(%rdx,%rax,1)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,0x8(%rdx,%rax,1)
movd   %xmm1,0xc(%rdx,%rax,1)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    39c5 <ConvertType+0x28b5>
jmp    4d18 <ConvertType+0x3c08>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x18,%rcx
jae    4751 <ConvertType+0x3641>
xor    %ecx,%ecx
jmp    47c0 <ConvertType+0x36b0>
mov    %r9d,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rax
mov    %rax,%r8
shr    $0x4,%r8
add    $0x1,%r8
test   %rax,%rax
je     4d5d <ConvertType+0x3c4d>
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
or     $0x2,%rcx
and    %r8,%rcx
xor    %eax,%eax
movdqa 0x15ec(%rip),%xmm0
movdqu (%rdi,%rax,2),%xmm1
movdqu 0x10(%rdi,%rax,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,(%rdx,%rax,1)
movdqu 0x20(%rdi,%rax,2),%xmm1
movdqu 0x30(%rdi,%rax,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,0x10(%rdx,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rcx
jne    3a94 <ConvertType+0x2984>
jmp    4d5f <ConvertType+0x3c4f>
mov    %r9d,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rcx
mov    %rcx,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x30,%rcx
jae    480f <ConvertType+0x36ff>
xor    %ecx,%ecx
jmp    4871 <ConvertType+0x3761>
mov    %r9d,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rcx
mov    %rcx,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x30,%rcx
jae    48c0 <ConvertType+0x37b0>
xor    %ecx,%ecx
jmp    4922 <ConvertType+0x3812>
mov    %r9d,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rax
mov    %rax,%r8
shr    $0x4,%r8
add    $0x1,%r8
test   %rax,%rax
je     4d9c <ConvertType+0x3c8c>
movabs $0x1ffffffffffffffc,%rcx
ff ff 1f
or     $0x2,%rcx
and    %r8,%rcx
xor    %eax,%eax
movdqa 0x1510(%rip),%xmm0
movdqu (%rdi,%rax,2),%xmm1
movdqu 0x10(%rdi,%rax,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,(%rdx,%rax,1)
movdqu 0x20(%rdi,%rax,2),%xmm1
movdqu 0x30(%rdi,%rax,2),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm1
movdqu %xmm1,0x10(%rdx,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%rcx
jne    3b70 <ConvertType+0x2a60>
jmp    4d9e <ConvertType+0x3c8e>
mov    %r9d,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rcx
mov    %rcx,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x30,%rcx
jae    4971 <ConvertType+0x3861>
xor    %ecx,%ecx
jmp    49d3 <ConvertType+0x38c3>
mov    %r9d,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rcx
mov    %rcx,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x30,%rcx
jae    4a22 <ConvertType+0x3912>
xor    %ecx,%ecx
jmp    4a84 <ConvertType+0x3974>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,4),%xmm0
movups 0x10(%rdi,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x20(%rdi,%rcx,4),%xmm0
movups 0x30(%rdi,%rcx,4),%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
movups 0x40(%rdi,%rcx,4),%xmm0
movups 0x50(%rdi,%rcx,4),%xmm1
movups %xmm0,0x40(%rdx,%rcx,4)
movups %xmm1,0x50(%rdx,%rcx,4)
movupd 0x60(%rdi,%rcx,4),%xmm0
movupd 0x70(%rdi,%rcx,4),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,4)
movupd %xmm1,0x70(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rax
jne    3c26 <ConvertType+0x2b16>
test   %r8,%r8
je     3cbe <ConvertType+0x2bae>
lea    (%rdx,%rcx,4),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    3c9d <ConvertType+0x2b8d>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1253 <ConvertType+0x143>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,4),%xmm0
movups 0x10(%rdi,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x20(%rdi,%rcx,4),%xmm0
movups 0x30(%rdi,%rcx,4),%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
movups 0x40(%rdi,%rcx,4),%xmm0
movups 0x50(%rdi,%rcx,4),%xmm1
movups %xmm0,0x40(%rdx,%rcx,4)
movups %xmm1,0x50(%rdx,%rcx,4)
movupd 0x60(%rdi,%rcx,4),%xmm0
movupd 0x70(%rdi,%rcx,4),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,4)
movupd %xmm1,0x70(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rax
jne    3ce4 <ConvertType+0x2bd4>
test   %r8,%r8
je     3d7c <ConvertType+0x2c6c>
lea    (%rdx,%rcx,4),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    3d5b <ConvertType+0x2c4b>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    149d <ConvertType+0x38d>
cmp    $0x20,%r8d
jae    4ad3 <ConvertType+0x39c3>
xor    %esi,%esi
jmp    4f2a <ConvertType+0x3e1a>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     4ddb <ConvertType+0x3ccb>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
xor    %eax,%eax
pxor   %xmm0,%xmm0
movzwl (%rdi,%rax,1),%ecx
movd   %ecx,%xmm1
movzwl 0x2(%rdi,%rax,1),%ecx
movd   %ecx,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
cvtdq2pd %xmm2,%xmm2
movups %xmm1,(%rdx,%rax,8)
movups %xmm2,0x10(%rdx,%rax,8)
movzwl 0x4(%rdi,%rax,1),%ecx
movd   %ecx,%xmm1
movzwl 0x6(%rdi,%rax,1),%ecx
movd   %ecx,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
cvtdq2pd %xmm2,%xmm2
movupd %xmm1,0x20(%rdx,%rax,8)
movdqu %xmm2,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r10
jne    3dcb <ConvertType+0x2cbb>
jmp    4ddd <ConvertType+0x3ccd>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     4e2e <ConvertType+0x3d1e>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
xor    %eax,%eax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,%ecx
mov    %cx,(%rdx,%rax,1)
movd   %xmm1,%ecx
mov    %cx,0x2(%rdx,%rax,1)
movupd 0x20(%rdi,%rax,8),%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,%ecx
mov    %cx,0x4(%rdx,%rax,1)
movd   %xmm1,%ecx
mov    %cx,0x6(%rdx,%rax,1)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r10
jne    3e69 <ConvertType+0x2d59>
jmp    4e30 <ConvertType+0x3d20>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rcx
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0xc,%rcx
jae    4b00 <ConvertType+0x39f0>
xor    %ecx,%ecx
jmp    4b6f <ConvertType+0x3a5f>
xor    %eax,%eax
test   $0x1,%r8b
je     3f41 <ConvertType+0x2e31>
movd   (%rdi,%rax,1),%xmm0
movd   0x4(%rdi,%rax,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1301 <ConvertType+0x1f1>
xor    %eax,%eax
test   $0x1,%r8b
je     3f92 <ConvertType+0x2e82>
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
movdqa 0x1101(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rdx,%rax,1)
movd   %xmm1,0x4(%rdx,%rax,1)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    152a <ConvertType+0x41a>
xor    %eax,%eax
test   $0x1,%r8b
je     4012 <ConvertType+0x2f02>
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
movdqa 0x1070(%rip),%xmm2
movdqa %xmm0,%xmm3
pand   %xmm2,%xmm3
movdqa 0x1070(%rip),%xmm4
por    %xmm4,%xmm3
psrld  $0x10,%xmm0
movdqa 0x106f(%rip),%xmm5
por    %xmm5,%xmm0
movaps 0x1074(%rip),%xmm6
subps  %xmm6,%xmm0
addps  %xmm3,%xmm0
pand   %xmm1,%xmm2
por    %xmm4,%xmm2
psrld  $0x10,%xmm1
por    %xmm5,%xmm1
subps  %xmm6,%xmm1
addps  %xmm2,%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
mov    (%rdi,%rsi,4),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    4020 <ConvertType+0x2f10>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     407a <ConvertType+0x2f6a>
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,4),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    4088 <ConvertType+0x2f78>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     40da <ConvertType+0x2fca>
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,4),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    40e8 <ConvertType+0x2fd8>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     4124 <ConvertType+0x3014>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
xor    %eax,%eax
movsd  (%rdi,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r9
jne    4134 <ConvertType+0x3024>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     4180 <ConvertType+0x3070>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
movd   %xmm0,(%rdx,%rax,2)
movd   %xmm1,0x4(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
cvttsd2si (%rdi,%rsi,8),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    418e <ConvertType+0x307e>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     41d7 <ConvertType+0x30c7>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
movd   %xmm0,(%rdx,%rax,2)
movd   %xmm1,0x4(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
cvttsd2si (%rdi,%rsi,8),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    41e5 <ConvertType+0x30d5>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     4259 <ConvertType+0x3149>
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm2
movdqa %xmm2,%xmm3
psrad  $0x1f,%xmm3
movaps 0xded(%rip),%xmm4
subps  %xmm4,%xmm0
cvttps2dq %xmm0,%xmm0
pand   %xmm3,%xmm0
por    %xmm2,%xmm0
cvttps2dq %xmm1,%xmm2
movdqa %xmm2,%xmm3
psrad  $0x1f,%xmm3
subps  %xmm4,%xmm1
cvttps2dq %xmm1,%xmm1
pand   %xmm3,%xmm1
por    %xmm2,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
cvttss2si (%rdi,%rsi,4),%rax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    4267 <ConvertType+0x3157>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     429b <ConvertType+0x318b>
cvtps2pd (%rdi,%rax,4),%xmm0
cvtps2pd 0x8(%rdi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
xor    %eax,%eax
movss  (%rdi,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r9
jne    42ab <ConvertType+0x319b>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     42e9 <ConvertType+0x31d9>
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
packssdw %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
cvttss2si (%rdi,%rsi,4),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    42f7 <ConvertType+0x31e7>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     4350 <ConvertType+0x3240>
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
cvttss2si (%rdi,%rsi,4),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    435e <ConvertType+0x324e>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     43a7 <ConvertType+0x3297>
movq   (%rdi,%rax,2),%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
punpcklwd %xmm0,%xmm0
psrad  $0x10,%xmm0
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movswl (%rdi,%rsi,2),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    43b5 <ConvertType+0x32a5>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     4406 <ConvertType+0x32f6>
movd   (%rdi,%rax,2),%xmm0
movd   0x4(%rdi,%rax,2),%xmm1
pshuflw $0x60,%xmm0,%xmm0
psrad  $0x10,%xmm0
cvtdq2pd %xmm0,%xmm0
pshuflw $0x60,%xmm1,%xmm1
psrad  $0x10,%xmm1
cvtdq2pd %xmm1,%xmm1
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movswl (%rdi,%rsi,2),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    4414 <ConvertType+0x3304>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     4468 <ConvertType+0x3358>
movq   (%rdi,%rax,2),%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
punpcklwd %xmm0,%xmm0
psrad  $0x10,%xmm0
cvtdq2ps %xmm0,%xmm0
punpcklwd %xmm1,%xmm1
psrad  $0x10,%xmm1
cvtdq2ps %xmm1,%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movswl (%rdi,%rsi,2),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    4476 <ConvertType+0x3366>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     44c0 <ConvertType+0x33b0>
movq   (%rdi,%rax,2),%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
pxor   %xmm2,%xmm2
punpcklwd %xmm2,%xmm0
punpcklwd %xmm2,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,2),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    44ce <ConvertType+0x33be>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     4517 <ConvertType+0x3407>
movd   (%rdi,%rax,2),%xmm0
movd   0x4(%rdi,%rax,2),%xmm1
pxor   %xmm2,%xmm2
punpcklwd %xmm2,%xmm0
cvtdq2pd %xmm0,%xmm0
punpcklwd %xmm2,%xmm1
cvtdq2pd %xmm1,%xmm1
movdqu %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,2),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    4525 <ConvertType+0x3415>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     4572 <ConvertType+0x3462>
movq   (%rdi,%rax,2),%xmm0
movq   0x8(%rdi,%rax,2),%xmm1
xorps  %xmm2,%xmm2
punpcklwd %xmm2,%xmm0
cvtdq2ps %xmm0,%xmm0
punpcklwd %xmm2,%xmm1
cvtdq2ps %xmm1,%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
movzwl (%rdi,%rsi,2),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    4580 <ConvertType+0x3470>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     45e0 <ConvertType+0x34d0>
movsd  (%rdi,%rax,4),%xmm0
movsd  0x8(%rdi,%rax,4),%xmm1
xorpd  %xmm2,%xmm2
unpcklps %xmm2,%xmm0
movapd 0xa5e(%rip),%xmm3
orpd   %xmm3,%xmm0
subpd  %xmm3,%xmm0
unpcklps %xmm2,%xmm1
orpd   %xmm3,%xmm1
subpd  %xmm3,%xmm1
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
mov    (%rdi,%rsi,4),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    45ee <ConvertType+0x34de>
jmp    1118 <ConvertType+0x8>
xor    %eax,%eax
test   $0x1,%r8b
je     466c <ConvertType+0x355c>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm2
movapd %xmm2,%xmm3
psrad  $0x1f,%xmm3
movapd 0x9ca(%rip),%xmm4
subpd  %xmm4,%xmm0
cvttpd2dq %xmm0,%xmm0
andpd  %xmm3,%xmm0
orpd   %xmm2,%xmm0
cvttpd2dq %xmm1,%xmm2
movapd %xmm2,%xmm3
psrad  $0x1f,%xmm3
subpd  %xmm4,%xmm1
cvttpd2dq %xmm1,%xmm1
andpd  %xmm3,%xmm1
orpd   %xmm2,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
cvttsd2si (%rdi,%rsi,8),%rax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
xor    %eax,%eax
cmp    %rsi,%r9
jne    467a <ConvertType+0x356a>
jmp    1118 <ConvertType+0x8>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,4),%xmm0
movups 0x10(%rdi,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x20(%rdi,%rcx,4),%xmm0
movups 0x30(%rdi,%rcx,4),%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
movups 0x40(%rdi,%rcx,4),%xmm0
movups 0x50(%rdi,%rcx,4),%xmm1
movups %xmm0,0x40(%rdx,%rcx,4)
movups %xmm1,0x50(%rdx,%rcx,4)
movupd 0x60(%rdi,%rcx,4),%xmm0
movupd 0x70(%rdi,%rcx,4),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,4)
movupd %xmm1,0x70(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rax
jne    46a6 <ConvertType+0x3596>
test   %r8,%r8
je     473e <ConvertType+0x362e>
lea    (%rdx,%rcx,4),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    471d <ConvertType+0x360d>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1644 <ConvertType+0x534>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,4),%xmm0
movups 0x10(%rdi,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x20(%rdi,%rcx,4),%xmm0
movups 0x30(%rdi,%rcx,4),%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
movups 0x40(%rdi,%rcx,4),%xmm0
movups 0x50(%rdi,%rcx,4),%xmm1
movups %xmm0,0x40(%rdx,%rcx,4)
movups %xmm1,0x50(%rdx,%rcx,4)
movupd 0x60(%rdi,%rcx,4),%xmm0
movupd 0x70(%rdi,%rcx,4),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,4)
movupd %xmm1,0x70(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rax
jne    4764 <ConvertType+0x3654>
test   %r8,%r8
je     47fc <ConvertType+0x36ec>
lea    (%rdx,%rcx,4),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    47db <ConvertType+0x36cb>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1e47 <ConvertType+0xd37>
and    $0xfffffffffffffffc,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,2),%xmm0
movups 0x10(%rdi,%rcx,2),%xmm1
movups %xmm0,(%rdx,%rcx,2)
movups %xmm1,0x10(%rdx,%rcx,2)
movups 0x20(%rdi,%rcx,2),%xmm0
movups 0x30(%rdi,%rcx,2),%xmm1
movups %xmm0,0x20(%rdx,%rcx,2)
movups %xmm1,0x30(%rdx,%rcx,2)
movups 0x40(%rdi,%rcx,2),%xmm0
movups 0x50(%rdi,%rcx,2),%xmm1
movups %xmm0,0x40(%rdx,%rcx,2)
movups %xmm1,0x50(%rdx,%rcx,2)
movupd 0x60(%rdi,%rcx,2),%xmm0
movupd 0x70(%rdi,%rcx,2),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,2)
movupd %xmm1,0x70(%rdx,%rcx,2)
add    $0x40,%rcx
add    $0xfffffffffffffffc,%rax
jne    4815 <ConvertType+0x3705>
test   %r8,%r8
je     48ad <ConvertType+0x379d>
lea    (%rdx,%rcx,2),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,2),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    488c <ConvertType+0x377c>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    2024 <ConvertType+0xf14>
and    $0xfffffffffffffffc,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,2),%xmm0
movups 0x10(%rdi,%rcx,2),%xmm1
movups %xmm0,(%rdx,%rcx,2)
movups %xmm1,0x10(%rdx,%rcx,2)
movups 0x20(%rdi,%rcx,2),%xmm0
movups 0x30(%rdi,%rcx,2),%xmm1
movups %xmm0,0x20(%rdx,%rcx,2)
movups %xmm1,0x30(%rdx,%rcx,2)
movups 0x40(%rdi,%rcx,2),%xmm0
movups 0x50(%rdi,%rcx,2),%xmm1
movups %xmm0,0x40(%rdx,%rcx,2)
movups %xmm1,0x50(%rdx,%rcx,2)
movupd 0x60(%rdi,%rcx,2),%xmm0
movupd 0x70(%rdi,%rcx,2),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,2)
movupd %xmm1,0x70(%rdx,%rcx,2)
add    $0x40,%rcx
add    $0xfffffffffffffffc,%rax
jne    48c6 <ConvertType+0x37b6>
test   %r8,%r8
je     495e <ConvertType+0x384e>
lea    (%rdx,%rcx,2),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,2),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    493d <ConvertType+0x382d>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    20bb <ConvertType+0xfab>
and    $0xfffffffffffffffc,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,2),%xmm0
movups 0x10(%rdi,%rcx,2),%xmm1
movups %xmm0,(%rdx,%rcx,2)
movups %xmm1,0x10(%rdx,%rcx,2)
movups 0x20(%rdi,%rcx,2),%xmm0
movups 0x30(%rdi,%rcx,2),%xmm1
movups %xmm0,0x20(%rdx,%rcx,2)
movups %xmm1,0x30(%rdx,%rcx,2)
movups 0x40(%rdi,%rcx,2),%xmm0
movups 0x50(%rdi,%rcx,2),%xmm1
movups %xmm0,0x40(%rdx,%rcx,2)
movups %xmm1,0x50(%rdx,%rcx,2)
movupd 0x60(%rdi,%rcx,2),%xmm0
movupd 0x70(%rdi,%rcx,2),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,2)
movupd %xmm1,0x70(%rdx,%rcx,2)
add    $0x40,%rcx
add    $0xfffffffffffffffc,%rax
jne    4977 <ConvertType+0x3867>
test   %r8,%r8
je     4a0f <ConvertType+0x38ff>
lea    (%rdx,%rcx,2),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,2),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    49ee <ConvertType+0x38de>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    224a <ConvertType+0x113a>
and    $0xfffffffffffffffc,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,2),%xmm0
movups 0x10(%rdi,%rcx,2),%xmm1
movups %xmm0,(%rdx,%rcx,2)
movups %xmm1,0x10(%rdx,%rcx,2)
movups 0x20(%rdi,%rcx,2),%xmm0
movups 0x30(%rdi,%rcx,2),%xmm1
movups %xmm0,0x20(%rdx,%rcx,2)
movups %xmm1,0x30(%rdx,%rcx,2)
movups 0x40(%rdi,%rcx,2),%xmm0
movups 0x50(%rdi,%rcx,2),%xmm1
movups %xmm0,0x40(%rdx,%rcx,2)
movups %xmm1,0x50(%rdx,%rcx,2)
movupd 0x60(%rdi,%rcx,2),%xmm0
movupd 0x70(%rdi,%rcx,2),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,2)
movupd %xmm1,0x70(%rdx,%rcx,2)
add    $0x40,%rcx
add    $0xfffffffffffffffc,%rax
jne    4a28 <ConvertType+0x3918>
test   %r8,%r8
je     4ac0 <ConvertType+0x39b0>
lea    (%rdx,%rcx,2),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,2),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    4a9f <ConvertType+0x398f>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    22e1 <ConvertType+0x11d1>
mov    %r9d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rcx
mov    %rcx,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x60,%rcx
jae    4e7d <ConvertType+0x3d6d>
xor    %ecx,%ecx
jmp    4edb <ConvertType+0x3dcb>
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,8),%xmm0
movups 0x10(%rdi,%rcx,8),%xmm1
movups %xmm0,(%rdx,%rcx,8)
movups %xmm1,0x10(%rdx,%rcx,8)
movups 0x20(%rdi,%rcx,8),%xmm0
movups 0x30(%rdi,%rcx,8),%xmm1
movups %xmm0,0x20(%rdx,%rcx,8)
movups %xmm1,0x30(%rdx,%rcx,8)
movups 0x40(%rdi,%rcx,8),%xmm0
movups 0x50(%rdi,%rcx,8),%xmm1
movups %xmm0,0x40(%rdx,%rcx,8)
movups %xmm1,0x50(%rdx,%rcx,8)
movupd 0x60(%rdi,%rcx,8),%xmm0
movupd 0x70(%rdi,%rcx,8),%xmm1
movupd %xmm0,0x60(%rdx,%rcx,8)
movupd %xmm1,0x70(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    4b13 <ConvertType+0x3a03>
test   %r8,%r8
je     4bab <ConvertType+0x3a9b>
lea    (%rdx,%rcx,8),%r10
add    $0x10,%r10
lea    (%rdi,%rcx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movupd -0x10(%rcx,%rax,1),%xmm0
movupd (%rcx,%rax,1),%xmm1
movupd %xmm0,-0x10(%r10,%rax,1)
movupd %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    4b8a <ConvertType+0x3a7a>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1c65 <ConvertType+0xb55>
xor    %eax,%eax
test   $0x1,%r8b
je     4bfc <ConvertType+0x3aec>
movdqu (%rdi,%rax,4),%xmm0
movdqu 0x10(%rdi,%rax,4),%xmm1
movdqa 0x497(%rip),%xmm2
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rdx,%rax,1)
movd   %xmm1,0x4(%rdx,%rax,1)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    16d1 <ConvertType+0x5c1>
xor    %eax,%eax
test   $0x1,%r8b
je     4c41 <ConvertType+0x3b31>
movd   (%rdi,%rax,1),%xmm0
movd   0x4(%rdi,%rax,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    17eb <ConvertType+0x6db>
xor    %eax,%eax
test   $0x1,%r8b
je     4c89 <ConvertType+0x3b79>
movd   (%rdi,%rax,1),%xmm0
movd   0x4(%rdi,%rax,1),%xmm1
xorps  %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
cvtdq2ps %xmm0,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
cvtdq2ps %xmm1,%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    19ca <ConvertType+0x8ba>
xor    %eax,%eax
test   $0x1,%r8b
je     4cc6 <ConvertType+0x3bb6>
movq   (%rdi,%rax,1),%xmm0
movq   0x8(%rdi,%rax,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
movdqu %xmm0,(%rdx,%rax,2)
movdqu %xmm1,0x10(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1a87 <ConvertType+0x977>
xor    %eax,%eax
test   $0x1,%r8b
je     4d03 <ConvertType+0x3bf3>
movq   (%rdi,%rax,1),%xmm0
movq   0x8(%rdi,%rax,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
movdqu %xmm0,(%rdx,%rax,2)
movdqu %xmm1,0x10(%rdx,%rax,2)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1b1c <ConvertType+0xa0c>
xor    %eax,%eax
test   $0x1,%r8b
je     4d4a <ConvertType+0x3c3a>
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
cvttps2dq %xmm0,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
cvttps2dq %xmm1,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rdx,%rax,1)
movd   %xmm1,0x4(%rdx,%rax,1)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1d8e <ConvertType+0xc7e>
xor    %eax,%eax
test   $0x1,%r8b
je     4d89 <ConvertType+0x3c79>
movdqu (%rdi,%rax,2),%xmm0
movdqu 0x10(%rdi,%rax,2),%xmm1
movdqa 0x308(%rip),%xmm2
pand   %xmm2,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,1)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1f4e <ConvertType+0xe3e>
xor    %eax,%eax
test   $0x1,%r8b
je     4dc8 <ConvertType+0x3cb8>
movdqu (%rdi,%rax,2),%xmm0
movdqu 0x10(%rdi,%rax,2),%xmm1
movdqa 0x2c9(%rip),%xmm2
pand   %xmm2,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm0
movdqu %xmm0,(%rdx,%rax,1)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    2174 <ConvertType+0x1064>
xor    %eax,%eax
test   $0x1,%r8b
je     4e1b <ConvertType+0x3d0b>
movzwl (%rdi,%rax,1),%ecx
movd   %ecx,%xmm0
movzwl 0x2(%rdi,%rax,1),%ecx
movd   %ecx,%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
cvtdq2pd %xmm0,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
cvtdq2pd %xmm1,%xmm1
movdqu %xmm0,(%rdx,%rax,8)
movupd %xmm1,0x10(%rdx,%rax,8)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    190b <ConvertType+0x7fb>
xor    %eax,%eax
test   $0x1,%r8b
je     4e6a <ConvertType+0x3d5a>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
cvttpd2dq %xmm0,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
cvttpd2dq %xmm1,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,%ecx
mov    %cx,(%rdx,%rax,1)
movd   %xmm1,%ecx
mov    %cx,0x2(%rdx,%rax,1)
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    1bce <ConvertType+0xabe>
and    $0xfffffffffffffffc,%rax
xor    %ecx,%ecx
movups (%rdi,%rcx,1),%xmm0
movups 0x10(%rdi,%rcx,1),%xmm1
movups %xmm0,(%rdx,%rcx,1)
movups %xmm1,0x10(%rdx,%rcx,1)
movups 0x20(%rdi,%rcx,1),%xmm0
movups 0x30(%rdi,%rcx,1),%xmm1
movups %xmm0,0x20(%rdx,%rcx,1)
movups %xmm1,0x30(%rdx,%rcx,1)
movups 0x40(%rdi,%rcx,1),%xmm0
movups 0x50(%rdi,%rcx,1),%xmm1
movups %xmm0,0x40(%rdx,%rcx,1)
movups %xmm1,0x50(%rdx,%rcx,1)
movups 0x60(%rdi,%rcx,1),%xmm0
movups 0x70(%rdi,%rcx,1),%xmm1
movups %xmm0,0x60(%rdx,%rcx,1)
movups %xmm1,0x70(%rdx,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rax
jne    4e83 <ConvertType+0x3d73>
test   %r8,%r8
je     4f12 <ConvertType+0x3e02>
lea    (%rdx,%rcx,1),%r10
add    $0x10,%r10
add    %rdi,%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %eax,%eax
movups -0x10(%rcx,%rax,1),%xmm0
movups (%rcx,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    4ef5 <ConvertType+0x3de5>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
test   $0x18,%r9b
je     187b <ConvertType+0x76b>
mov    %rsi,%rax
mov    %r9d,%esi
and    $0xfffffff8,%esi
mov    (%rdi,%rax,1),%rcx
mov    %rcx,(%rdx,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    4f33 <ConvertType+0x3e23>
mov    $0x0,%eax
cmp    %r9,%rsi
je     1118 <ConvertType+0x8>
jmp    187b <ConvertType+0x76b>

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

LLVM IR (-O2):
@str = [59 x i8] c"internal getdata bug: unknown type shouldn't make it here!\00"
define i32 @ConvertType(i8* %0, i8 signext %1, i8* writeonly %2, i8 signext %3, i32 %4) {
%6 = sext i8 %3 to i32
%7 = icmp eq i8 %3, 110
br i1 %7, label %4771, label %8
8: ; preds = %5
%9 = sext i8 %1 to i32
switch i32 %9, label %4769 [
i32 99, label %10
i32 115, label %835
i32 117, label %1509
i32 105, label %2183
i32 83, label %2183
i32 85, label %2857
i32 102, label %3531
i32 100, label %4150
]
10: ; preds = %8
switch i32 %6, label %4771 [
i32 99, label %461
i32 115, label %371
i32 117, label %281
i32 105, label %653
i32 83, label %653
i32 85, label %191
i32 102, label %101
i32 100, label %11
]
11: ; preds = %10
%12 = icmp sgt i32 %4, 0
br i1 %12, label %13, label %4771
13: ; preds = %11
%14 = bitcast i8* %2 to double*
%15 = zext i32 %4 to i64
%16 = icmp ult i32 %4, 4
br i1 %16, label %82, label %17
17: ; preds = %13
%18 = shl nuw nsw i64 %15, 3
%19 = getelementptr i8, i8* %2, i64 %18
%20 = getelementptr i8, i8* %0, i64 %15
%21 = icmp ugt i8* %20, %2
%22 = icmp ugt i8* %19, %0
%23 = and i1 %21, %22
br i1 %23, label %82, label %24
24: ; preds = %17
%25 = and i64 %15, 4294967292
%26 = add nsw i64 %25, -4
%27 = lshr exact i64 %26, 2
%28 = add nuw nsw i64 %27, 1
%29 = and i64 %28, 1
%30 = icmp eq i64 %26, 0
br i1 %30, label %64, label %31
31: ; preds = %24
%32 = and i64 %28, 9223372036854775806
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %61, %33 ]
%35 = phi i64 [ 0, %31 ], [ %62, %33 ]
%36 = getelementptr inbounds i8, i8* %0, i64 %34
%37 = bitcast i8* %36 to <2 x i8>*
%38 = load <2 x i8>, <2 x i8>* %37
%39 = getelementptr inbounds i8, i8* %36, i64 2
%40 = bitcast i8* %39 to <2 x i8>*
%41 = load <2 x i8>, <2 x i8>* %40
%42 = uitofp <2 x i8> %38 to <2 x double>
%43 = uitofp <2 x i8> %41 to <2 x double>
%44 = getelementptr inbounds double, double* %14, i64 %34
%45 = bitcast double* %44 to <2 x double>*
store <2 x double> %42, <2 x double>* %45
%46 = getelementptr inbounds double, double* %44, i64 2
%47 = bitcast double* %46 to <2 x double>*
store <2 x double> %43, <2 x double>* %47
%48 = or i64 %34, 4
%49 = getelementptr inbounds i8, i8* %0, i64 %48
%50 = bitcast i8* %49 to <2 x i8>*
%51 = load <2 x i8>, <2 x i8>* %50
%52 = getelementptr inbounds i8, i8* %49, i64 2
%53 = bitcast i8* %52 to <2 x i8>*
%54 = load <2 x i8>, <2 x i8>* %53
%55 = uitofp <2 x i8> %51 to <2 x double>
%56 = uitofp <2 x i8> %54 to <2 x double>
%57 = getelementptr inbounds double, double* %14, i64 %48
%58 = bitcast double* %57 to <2 x double>*
store <2 x double> %55, <2 x double>* %58
%59 = getelementptr inbounds double, double* %57, i64 2
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> %56, <2 x double>* %60
%61 = add nuw i64 %34, 8
%62 = add i64 %35, 2
%63 = icmp eq i64 %62, %32
br i1 %63, label %64, label %33
64: ; preds = %33, %24
%65 = phi i64 [ 0, %24 ], [ %61, %33 ]
%66 = icmp eq i64 %29, 0
br i1 %66, label %80, label %67
67: ; preds = %64
%68 = getelementptr inbounds i8, i8* %0, i64 %65
%69 = bitcast i8* %68 to <2 x i8>*
%70 = load <2 x i8>, <2 x i8>* %69
%71 = getelementptr inbounds i8, i8* %68, i64 2
%72 = bitcast i8* %71 to <2 x i8>*
%73 = load <2 x i8>, <2 x i8>* %72
%74 = uitofp <2 x i8> %70 to <2 x double>
%75 = uitofp <2 x i8> %73 to <2 x double>
%76 = getelementptr inbounds double, double* %14, i64 %65
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %74, <2 x double>* %77
%78 = getelementptr inbounds double, double* %76, i64 2
%79 = bitcast double* %78 to <2 x double>*
store <2 x double> %75, <2 x double>* %79
br label %80
80: ; preds = %64, %67
%81 = icmp eq i64 %25, %15
br i1 %81, label %4771, label %82
82: ; preds = %17, %13, %80
%83 = phi i64 [ 0, %17 ], [ 0, %13 ], [ %25, %80 ]
%84 = xor i64 %83, -1
%85 = add nsw i64 %84, %15
%86 = and i64 %15, 3
%87 = icmp eq i64 %86, 0
br i1 %87, label %98, label %88
88: ; preds = %82, %88
%89 = phi i64 [ %95, %88 ], [ %83, %82 ]
%90 = phi i64 [ %96, %88 ], [ 0, %82 ]
%91 = getelementptr inbounds i8, i8* %0, i64 %89
%92 = load i8, i8* %91
%93 = uitofp i8 %92 to double
%94 = getelementptr inbounds double, double* %14, i64 %89
store double %93, double* %94
%95 = add nuw nsw i64 %89, 1
%96 = add i64 %90, 1
%97 = icmp eq i64 %96, %86
br i1 %97, label %98, label %88
98: ; preds = %88, %82
%99 = phi i64 [ %83, %82 ], [ %95, %88 ]
%100 = icmp ult i64 %85, 3
br i1 %100, label %4771, label %812
101: ; preds = %10
%102 = icmp sgt i32 %4, 0
br i1 %102, label %103, label %4771
103: ; preds = %101
%104 = bitcast i8* %2 to float*
%105 = zext i32 %4 to i64
%106 = icmp ult i32 %4, 8
br i1 %106, label %172, label %107
107: ; preds = %103
%108 = shl nuw nsw i64 %105, 2
%109 = getelementptr i8, i8* %2, i64 %108
%110 = getelementptr i8, i8* %0, i64 %105
%111 = icmp ugt i8* %110, %2
%112 = icmp ugt i8* %109, %0
%113 = and i1 %111, %112
br i1 %113, label %172, label %114
114: ; preds = %107
%115 = and i64 %105, 4294967288
%116 = add nsw i64 %115, -8
%117 = lshr exact i64 %116, 3
%118 = add nuw nsw i64 %117, 1
%119 = and i64 %118, 1
%120 = icmp eq i64 %116, 0
br i1 %120, label %154, label %121
121: ; preds = %114
%122 = and i64 %118, 4611686018427387902
br label %123
123: ; preds = %123, %121
%124 = phi i64 [ 0, %121 ], [ %151, %123 ]
%125 = phi i64 [ 0, %121 ], [ %152, %123 ]
%126 = getelementptr inbounds i8, i8* %0, i64 %124
%127 = bitcast i8* %126 to <4 x i8>*
%128 = load <4 x i8>, <4 x i8>* %127
%129 = getelementptr inbounds i8, i8* %126, i64 4
%130 = bitcast i8* %129 to <4 x i8>*
%131 = load <4 x i8>, <4 x i8>* %130
%132 = uitofp <4 x i8> %128 to <4 x float>
%133 = uitofp <4 x i8> %131 to <4 x float>
%134 = getelementptr inbounds float, float* %104, i64 %124
%135 = bitcast float* %134 to <4 x float>*
store <4 x float> %132, <4 x float>* %135
%136 = getelementptr inbounds float, float* %134, i64 4
%137 = bitcast float* %136 to <4 x float>*
store <4 x float> %133, <4 x float>* %137
%138 = or i64 %124, 8
%139 = getelementptr inbounds i8, i8* %0, i64 %138
%140 = bitcast i8* %139 to <4 x i8>*
%141 = load <4 x i8>, <4 x i8>* %140
%142 = getelementptr inbounds i8, i8* %139, i64 4
%143 = bitcast i8* %142 to <4 x i8>*
%144 = load <4 x i8>, <4 x i8>* %143
%145 = uitofp <4 x i8> %141 to <4 x float>
%146 = uitofp <4 x i8> %144 to <4 x float>
%147 = getelementptr inbounds float, float* %104, i64 %138
%148 = bitcast float* %147 to <4 x float>*
store <4 x float> %145, <4 x float>* %148
%149 = getelementptr inbounds float, float* %147, i64 4
%150 = bitcast float* %149 to <4 x float>*
store <4 x float> %146, <4 x float>* %150
%151 = add nuw i64 %124, 16
%152 = add i64 %125, 2
%153 = icmp eq i64 %152, %122
br i1 %153, label %154, label %123
154: ; preds = %123, %114
%155 = phi i64 [ 0, %114 ], [ %151, %123 ]
%156 = icmp eq i64 %119, 0
br i1 %156, label %170, label %157
157: ; preds = %154
%158 = getelementptr inbounds i8, i8* %0, i64 %155
%159 = bitcast i8* %158 to <4 x i8>*
%160 = load <4 x i8>, <4 x i8>* %159
%161 = getelementptr inbounds i8, i8* %158, i64 4
%162 = bitcast i8* %161 to <4 x i8>*
%163 = load <4 x i8>, <4 x i8>* %162
%164 = uitofp <4 x i8> %160 to <4 x float>
%165 = uitofp <4 x i8> %163 to <4 x float>
%166 = getelementptr inbounds float, float* %104, i64 %155
%167 = bitcast float* %166 to <4 x float>*
store <4 x float> %164, <4 x float>* %167
%168 = getelementptr inbounds float, float* %166, i64 4
%169 = bitcast float* %168 to <4 x float>*
store <4 x float> %165, <4 x float>* %169
br label %170
170: ; preds = %154, %157
%171 = icmp eq i64 %115, %105
br i1 %171, label %4771, label %172
172: ; preds = %107, %103, %170
%173 = phi i64 [ 0, %107 ], [ 0, %103 ], [ %115, %170 ]
%174 = xor i64 %173, -1
%175 = add nsw i64 %174, %105
%176 = and i64 %105, 3
%177 = icmp eq i64 %176, 0
br i1 %177, label %188, label %178
178: ; preds = %172, %178
%179 = phi i64 [ %185, %178 ], [ %173, %172 ]
%180 = phi i64 [ %186, %178 ], [ 0, %172 ]
%181 = getelementptr inbounds i8, i8* %0, i64 %179
%182 = load i8, i8* %181
%183 = uitofp i8 %182 to float
%184 = getelementptr inbounds float, float* %104, i64 %179
store float %183, float* %184
%185 = add nuw nsw i64 %179, 1
%186 = add i64 %180, 1
%187 = icmp eq i64 %186, %176
br i1 %187, label %188, label %178
188: ; preds = %178, %172
%189 = phi i64 [ %173, %172 ], [ %185, %178 ]
%190 = icmp ult i64 %175, 3
br i1 %190, label %4771, label %789
191: ; preds = %10
%192 = icmp sgt i32 %4, 0
br i1 %192, label %193, label %4771
193: ; preds = %191
%194 = bitcast i8* %2 to i32*
%195 = zext i32 %4 to i64
%196 = icmp ult i32 %4, 8
br i1 %196, label %262, label %197
197: ; preds = %193
%198 = shl nuw nsw i64 %195, 2
%199 = getelementptr i8, i8* %2, i64 %198
%200 = getelementptr i8, i8* %0, i64 %195
%201 = icmp ugt i8* %200, %2
%202 = icmp ugt i8* %199, %0
%203 = and i1 %201, %202
br i1 %203, label %262, label %204
204: ; preds = %197
%205 = and i64 %195, 4294967288
%206 = add nsw i64 %205, -8
%207 = lshr exact i64 %206, 3
%208 = add nuw nsw i64 %207, 1
%209 = and i64 %208, 1
%210 = icmp eq i64 %206, 0
br i1 %210, label %244, label %211
211: ; preds = %204
%212 = and i64 %208, 4611686018427387902
br label %213
213: ; preds = %213, %211
%214 = phi i64 [ 0, %211 ], [ %241, %213 ]
%215 = phi i64 [ 0, %211 ], [ %242, %213 ]
%216 = getelementptr inbounds i8, i8* %0, i64 %214
%217 = bitcast i8* %216 to <4 x i8>*
%218 = load <4 x i8>, <4 x i8>* %217
%219 = getelementptr inbounds i8, i8* %216, i64 4
%220 = bitcast i8* %219 to <4 x i8>*
%221 = load <4 x i8>, <4 x i8>* %220
%222 = zext <4 x i8> %218 to <4 x i32>
%223 = zext <4 x i8> %221 to <4 x i32>
%224 = getelementptr inbounds i32, i32* %194, i64 %214
%225 = bitcast i32* %224 to <4 x i32>*
store <4 x i32> %222, <4 x i32>* %225
%226 = getelementptr inbounds i32, i32* %224, i64 4
%227 = bitcast i32* %226 to <4 x i32>*
store <4 x i32> %223, <4 x i32>* %227
%228 = or i64 %214, 8
%229 = getelementptr inbounds i8, i8* %0, i64 %228
%230 = bitcast i8* %229 to <4 x i8>*
%231 = load <4 x i8>, <4 x i8>* %230
%232 = getelementptr inbounds i8, i8* %229, i64 4
%233 = bitcast i8* %232 to <4 x i8>*
%234 = load <4 x i8>, <4 x i8>* %233
%235 = zext <4 x i8> %231 to <4 x i32>
%236 = zext <4 x i8> %234 to <4 x i32>
%237 = getelementptr inbounds i32, i32* %194, i64 %228
%238 = bitcast i32* %237 to <4 x i32>*
store <4 x i32> %235, <4 x i32>* %238
%239 = getelementptr inbounds i32, i32* %237, i64 4
%240 = bitcast i32* %239 to <4 x i32>*
store <4 x i32> %236, <4 x i32>* %240
%241 = add nuw i64 %214, 16
%242 = add i64 %215, 2
%243 = icmp eq i64 %242, %212
br i1 %243, label %244, label %213
244: ; preds = %213, %204
%245 = phi i64 [ 0, %204 ], [ %241, %213 ]
%246 = icmp eq i64 %209, 0
br i1 %246, label %260, label %247
247: ; preds = %244
%248 = getelementptr inbounds i8, i8* %0, i64 %245
%249 = bitcast i8* %248 to <4 x i8>*
%250 = load <4 x i8>, <4 x i8>* %249
%251 = getelementptr inbounds i8, i8* %248, i64 4
%252 = bitcast i8* %251 to <4 x i8>*
%253 = load <4 x i8>, <4 x i8>* %252
%254 = zext <4 x i8> %250 to <4 x i32>
%255 = zext <4 x i8> %253 to <4 x i32>
%256 = getelementptr inbounds i32, i32* %194, i64 %245
%257 = bitcast i32* %256 to <4 x i32>*
store <4 x i32> %254, <4 x i32>* %257
%258 = getelementptr inbounds i32, i32* %256, i64 4
%259 = bitcast i32* %258 to <4 x i32>*
store <4 x i32> %255, <4 x i32>* %259
br label %260
260: ; preds = %244, %247
%261 = icmp eq i64 %205, %195
br i1 %261, label %4771, label %262
262: ; preds = %197, %193, %260
%263 = phi i64 [ 0, %197 ], [ 0, %193 ], [ %205, %260 ]
%264 = xor i64 %263, -1
%265 = add nsw i64 %264, %195
%266 = and i64 %195, 3
%267 = icmp eq i64 %266, 0
br i1 %267, label %278, label %268
268: ; preds = %262, %268
%269 = phi i64 [ %275, %268 ], [ %263, %262 ]
%270 = phi i64 [ %276, %268 ], [ 0, %262 ]
%271 = getelementptr inbounds i8, i8* %0, i64 %269
%272 = load i8, i8* %271
%273 = zext i8 %272 to i32
%274 = getelementptr inbounds i32, i32* %194, i64 %269
store i32 %273, i32* %274
%275 = add nuw nsw i64 %269, 1
%276 = add i64 %270, 1
%277 = icmp eq i64 %276, %266
br i1 %277, label %278, label %268
278: ; preds = %268, %262
%279 = phi i64 [ %263, %262 ], [ %275, %268 ]
%280 = icmp ult i64 %265, 3
br i1 %280, label %4771, label %766
281: ; preds = %10
%282 = icmp sgt i32 %4, 0
br i1 %282, label %283, label %4771
283: ; preds = %281
%284 = bitcast i8* %2 to i16*
%285 = zext i32 %4 to i64
%286 = icmp ult i32 %4, 16
br i1 %286, label %352, label %287
287: ; preds = %283
%288 = shl nuw nsw i64 %285, 1
%289 = getelementptr i8, i8* %2, i64 %288
%290 = getelementptr i8, i8* %0, i64 %285
%291 = icmp ugt i8* %290, %2
%292 = icmp ugt i8* %289, %0
%293 = and i1 %291, %292
br i1 %293, label %352, label %294
294: ; preds = %287
%295 = and i64 %285, 4294967280
%296 = add nsw i64 %295, -16
%297 = lshr exact i64 %296, 4
%298 = add nuw nsw i64 %297, 1
%299 = and i64 %298, 1
%300 = icmp eq i64 %296, 0
br i1 %300, label %334, label %301
301: ; preds = %294
%302 = and i64 %298, 2305843009213693950
br label %303
303: ; preds = %303, %301
%304 = phi i64 [ 0, %301 ], [ %331, %303 ]
%305 = phi i64 [ 0, %301 ], [ %332, %303 ]
%306 = getelementptr inbounds i8, i8* %0, i64 %304
%307 = bitcast i8* %306 to <8 x i8>*
%308 = load <8 x i8>, <8 x i8>* %307
%309 = getelementptr inbounds i8, i8* %306, i64 8
%310 = bitcast i8* %309 to <8 x i8>*
%311 = load <8 x i8>, <8 x i8>* %310
%312 = zext <8 x i8> %308 to <8 x i16>
%313 = zext <8 x i8> %311 to <8 x i16>
%314 = getelementptr inbounds i16, i16* %284, i64 %304
%315 = bitcast i16* %314 to <8 x i16>*
store <8 x i16> %312, <8 x i16>* %315
%316 = getelementptr inbounds i16, i16* %314, i64 8
%317 = bitcast i16* %316 to <8 x i16>*
store <8 x i16> %313, <8 x i16>* %317
%318 = or i64 %304, 16
%319 = getelementptr inbounds i8, i8* %0, i64 %318
%320 = bitcast i8* %319 to <8 x i8>*
%321 = load <8 x i8>, <8 x i8>* %320
%322 = getelementptr inbounds i8, i8* %319, i64 8
%323 = bitcast i8* %322 to <8 x i8>*
%324 = load <8 x i8>, <8 x i8>* %323
%325 = zext <8 x i8> %321 to <8 x i16>
%326 = zext <8 x i8> %324 to <8 x i16>
%327 = getelementptr inbounds i16, i16* %284, i64 %318
%328 = bitcast i16* %327 to <8 x i16>*
store <8 x i16> %325, <8 x i16>* %328
%329 = getelementptr inbounds i16, i16* %327, i64 8
%330 = bitcast i16* %329 to <8 x i16>*
store <8 x i16> %326, <8 x i16>* %330
%331 = add nuw i64 %304, 32
%332 = add i64 %305, 2
%333 = icmp eq i64 %332, %302
br i1 %333, label %334, label %303
334: ; preds = %303, %294
%335 = phi i64 [ 0, %294 ], [ %331, %303 ]
%336 = icmp eq i64 %299, 0
br i1 %336, label %350, label %337
337: ; preds = %334
%338 = getelementptr inbounds i8, i8* %0, i64 %335
%339 = bitcast i8* %338 to <8 x i8>*
%340 = load <8 x i8>, <8 x i8>* %339
%341 = getelementptr inbounds i8, i8* %338, i64 8
%342 = bitcast i8* %341 to <8 x i8>*
%343 = load <8 x i8>, <8 x i8>* %342
%344 = zext <8 x i8> %340 to <8 x i16>
%345 = zext <8 x i8> %343 to <8 x i16>
%346 = getelementptr inbounds i16, i16* %284, i64 %335
%347 = bitcast i16* %346 to <8 x i16>*
store <8 x i16> %344, <8 x i16>* %347
%348 = getelementptr inbounds i16, i16* %346, i64 8
%349 = bitcast i16* %348 to <8 x i16>*
store <8 x i16> %345, <8 x i16>* %349
br label %350
350: ; preds = %334, %337
%351 = icmp eq i64 %295, %285
br i1 %351, label %4771, label %352
352: ; preds = %287, %283, %350
%353 = phi i64 [ 0, %287 ], [ 0, %283 ], [ %295, %350 ]
%354 = xor i64 %353, -1
%355 = add nsw i64 %354, %285
%356 = and i64 %285, 3
%357 = icmp eq i64 %356, 0
br i1 %357, label %368, label %358
358: ; preds = %352, %358
%359 = phi i64 [ %365, %358 ], [ %353, %352 ]
%360 = phi i64 [ %366, %358 ], [ 0, %352 ]
%361 = getelementptr inbounds i8, i8* %0, i64 %359
%362 = load i8, i8* %361
%363 = zext i8 %362 to i16
%364 = getelementptr inbounds i16, i16* %284, i64 %359
store i16 %363, i16* %364
%365 = add nuw nsw i64 %359, 1
%366 = add i64 %360, 1
%367 = icmp eq i64 %366, %356
br i1 %367, label %368, label %358
368: ; preds = %358, %352
%369 = phi i64 [ %353, %352 ], [ %365, %358 ]
%370 = icmp ult i64 %355, 3
br i1 %370, label %4771, label %630
371: ; preds = %10
%372 = icmp sgt i32 %4, 0
br i1 %372, label %373, label %4771
373: ; preds = %371
%374 = bitcast i8* %2 to i16*
%375 = zext i32 %4 to i64
%376 = icmp ult i32 %4, 16
br i1 %376, label %442, label %377
377: ; preds = %373
%378 = shl nuw nsw i64 %375, 1
%379 = getelementptr i8, i8* %2, i64 %378
%380 = getelementptr i8, i8* %0, i64 %375
%381 = icmp ugt i8* %380, %2
%382 = icmp ugt i8* %379, %0
%383 = and i1 %381, %382
br i1 %383, label %442, label %384
384: ; preds = %377
%385 = and i64 %375, 4294967280
%386 = add nsw i64 %385, -16
%387 = lshr exact i64 %386, 4
%388 = add nuw nsw i64 %387, 1
%389 = and i64 %388, 1
%390 = icmp eq i64 %386, 0
br i1 %390, label %424, label %391
391: ; preds = %384
%392 = and i64 %388, 2305843009213693950
br label %393
393: ; preds = %393, %391
%394 = phi i64 [ 0, %391 ], [ %421, %393 ]
%395 = phi i64 [ 0, %391 ], [ %422, %393 ]
%396 = getelementptr inbounds i8, i8* %0, i64 %394
%397 = bitcast i8* %396 to <8 x i8>*
%398 = load <8 x i8>, <8 x i8>* %397
%399 = getelementptr inbounds i8, i8* %396, i64 8
%400 = bitcast i8* %399 to <8 x i8>*
%401 = load <8 x i8>, <8 x i8>* %400
%402 = zext <8 x i8> %398 to <8 x i16>
%403 = zext <8 x i8> %401 to <8 x i16>
%404 = getelementptr inbounds i16, i16* %374, i64 %394
%405 = bitcast i16* %404 to <8 x i16>*
store <8 x i16> %402, <8 x i16>* %405
%406 = getelementptr inbounds i16, i16* %404, i64 8
%407 = bitcast i16* %406 to <8 x i16>*
store <8 x i16> %403, <8 x i16>* %407
%408 = or i64 %394, 16
%409 = getelementptr inbounds i8, i8* %0, i64 %408
%410 = bitcast i8* %409 to <8 x i8>*
%411 = load <8 x i8>, <8 x i8>* %410
%412 = getelementptr inbounds i8, i8* %409, i64 8
%413 = bitcast i8* %412 to <8 x i8>*
%414 = load <8 x i8>, <8 x i8>* %413
%415 = zext <8 x i8> %411 to <8 x i16>
%416 = zext <8 x i8> %414 to <8 x i16>
%417 = getelementptr inbounds i16, i16* %374, i64 %408
%418 = bitcast i16* %417 to <8 x i16>*
store <8 x i16> %415, <8 x i16>* %418
%419 = getelementptr inbounds i16, i16* %417, i64 8
%420 = bitcast i16* %419 to <8 x i16>*
store <8 x i16> %416, <8 x i16>* %420
%421 = add nuw i64 %394, 32
%422 = add i64 %395, 2
%423 = icmp eq i64 %422, %392
br i1 %423, label %424, label %393
424: ; preds = %393, %384
%425 = phi i64 [ 0, %384 ], [ %421, %393 ]
%426 = icmp eq i64 %389, 0
br i1 %426, label %440, label %427
427: ; preds = %424
%428 = getelementptr inbounds i8, i8* %0, i64 %425
%429 = bitcast i8* %428 to <8 x i8>*
%430 = load <8 x i8>, <8 x i8>* %429
%431 = getelementptr inbounds i8, i8* %428, i64 8
%432 = bitcast i8* %431 to <8 x i8>*
%433 = load <8 x i8>, <8 x i8>* %432
%434 = zext <8 x i8> %430 to <8 x i16>
%435 = zext <8 x i8> %433 to <8 x i16>
%436 = getelementptr inbounds i16, i16* %374, i64 %425
%437 = bitcast i16* %436 to <8 x i16>*
store <8 x i16> %434, <8 x i16>* %437
%438 = getelementptr inbounds i16, i16* %436, i64 8
%439 = bitcast i16* %438 to <8 x i16>*
store <8 x i16> %435, <8 x i16>* %439
br label %440
440: ; preds = %424, %427
%441 = icmp eq i64 %385, %375
br i1 %441, label %4771, label %442
442: ; preds = %377, %373, %440
%443 = phi i64 [ 0, %377 ], [ 0, %373 ], [ %385, %440 ]
%444 = xor i64 %443, -1
%445 = add nsw i64 %444, %375
%446 = and i64 %375, 3
%447 = icmp eq i64 %446, 0
br i1 %447, label %458, label %448
448: ; preds = %442, %448
%449 = phi i64 [ %455, %448 ], [ %443, %442 ]
%450 = phi i64 [ %456, %448 ], [ 0, %442 ]
%451 = getelementptr inbounds i8, i8* %0, i64 %449
%452 = load i8, i8* %451
%453 = zext i8 %452 to i16
%454 = getelementptr inbounds i16, i16* %374, i64 %449
store i16 %453, i16* %454
%455 = add nuw nsw i64 %449, 1
%456 = add i64 %450, 1
%457 = icmp eq i64 %456, %446
br i1 %457, label %458, label %448
458: ; preds = %448, %442
%459 = phi i64 [ %443, %442 ], [ %455, %448 ]
%460 = icmp ult i64 %445, 3
br i1 %460, label %4771, label %607
461: ; preds = %10
%462 = icmp sgt i32 %4, 0
br i1 %462, label %463, label %4771
463: ; preds = %461
%464 = zext i32 %4 to i64
%465 = icmp ult i32 %4, 8
br i1 %465, label %570, label %466
466: ; preds = %463
%467 = getelementptr i8, i8* %2, i64 %464
%468 = getelementptr i8, i8* %0, i64 %464
%469 = icmp ugt i8* %468, %2
%470 = icmp ugt i8* %467, %0
%471 = and i1 %469, %470
br i1 %471, label %570, label %472
472: ; preds = %466
%473 = icmp ult i32 %4, 32
br i1 %473, label %556, label %474
474: ; preds = %472
%475 = and i64 %464, 4294967264
%476 = add nsw i64 %475, -32
%477 = lshr exact i64 %476, 5
%478 = add nuw nsw i64 %477, 1
%479 = and i64 %478, 3
%480 = icmp ult i64 %476, 96
br i1 %480, label %532, label %481
481: ; preds = %474
%482 = and i64 %478, 1152921504606846972
br label %483
483: ; preds = %483, %481
%484 = phi i64 [ 0, %481 ], [ %529, %483 ]
%485 = phi i64 [ 0, %481 ], [ %530, %483 ]
%486 = getelementptr inbounds i8, i8* %0, i64 %484
%487 = bitcast i8* %486 to <16 x i8>*
%488 = load <16 x i8>, <16 x i8>* %487
%489 = getelementptr inbounds i8, i8* %486, i64 16
%490 = bitcast i8* %489 to <16 x i8>*
%491 = load <16 x i8>, <16 x i8>* %490
%492 = getelementptr inbounds i8, i8* %2, i64 %484
%493 = bitcast i8* %492 to <16 x i8>*
store <16 x i8> %488, <16 x i8>* %493
%494 = getelementptr inbounds i8, i8* %492, i64 16
%495 = bitcast i8* %494 to <16 x i8>*
store <16 x i8> %491, <16 x i8>* %495
%496 = or i64 %484, 32
%497 = getelementptr inbounds i8, i8* %0, i64 %496
%498 = bitcast i8* %497 to <16 x i8>*
%499 = load <16 x i8>, <16 x i8>* %498
%500 = getelementptr inbounds i8, i8* %497, i64 16
%501 = bitcast i8* %500 to <16 x i8>*
%502 = load <16 x i8>, <16 x i8>* %501
%503 = getelementptr inbounds i8, i8* %2, i64 %496
%504 = bitcast i8* %503 to <16 x i8>*
store <16 x i8> %499, <16 x i8>* %504
%505 = getelementptr inbounds i8, i8* %503, i64 16
%506 = bitcast i8* %505 to <16 x i8>*
store <16 x i8> %502, <16 x i8>* %506
%507 = or i64 %484, 64
%508 = getelementptr inbounds i8, i8* %0, i64 %507
%509 = bitcast i8* %508 to <16 x i8>*
%510 = load <16 x i8>, <16 x i8>* %509
%511 = getelementptr inbounds i8, i8* %508, i64 16
%512 = bitcast i8* %511 to <16 x i8>*
%513 = load <16 x i8>, <16 x i8>* %512
%514 = getelementptr inbounds i8, i8* %2, i64 %507
%515 = bitcast i8* %514 to <16 x i8>*
store <16 x i8> %510, <16 x i8>* %515
%516 = getelementptr inbounds i8, i8* %514, i64 16
%517 = bitcast i8* %516 to <16 x i8>*
store <16 x i8> %513, <16 x i8>* %517
%518 = or i64 %484, 96
%519 = getelementptr inbounds i8, i8* %0, i64 %518
%520 = bitcast i8* %519 to <16 x i8>*
%521 = load <16 x i8>, <16 x i8>* %520
%522 = getelementptr inbounds i8, i8* %519, i64 16
%523 = bitcast i8* %522 to <16 x i8>*
%524 = load <16 x i8>, <16 x i8>* %523
%525 = getelementptr inbounds i8, i8* %2, i64 %518
%526 = bitcast i8* %525 to <16 x i8>*
store <16 x i8> %521, <16 x i8>* %526
%527 = getelementptr inbounds i8, i8* %525, i64 16
%528 = bitcast i8* %527 to <16 x i8>*
store <16 x i8> %524, <16 x i8>* %528
%529 = add nuw i64 %484, 128
%530 = add i64 %485, 4
%531 = icmp eq i64 %530, %482
br i1 %531, label %532, label %483
532: ; preds = %483, %474
%533 = phi i64 [ 0, %474 ], [ %529, %483 ]
%534 = icmp eq i64 %479, 0
br i1 %534, label %551, label %535
535: ; preds = %532, %535
%536 = phi i64 [ %548, %535 ], [ %533, %532 ]
%537 = phi i64 [ %549, %535 ], [ 0, %532 ]
%538 = getelementptr inbounds i8, i8* %0, i64 %536
%539 = bitcast i8* %538 to <16 x i8>*
%540 = load <16 x i8>, <16 x i8>* %539
%541 = getelementptr inbounds i8, i8* %538, i64 16
%542 = bitcast i8* %541 to <16 x i8>*
%543 = load <16 x i8>, <16 x i8>* %542
%544 = getelementptr inbounds i8, i8* %2, i64 %536
%545 = bitcast i8* %544 to <16 x i8>*
store <16 x i8> %540, <16 x i8>* %545
%546 = getelementptr inbounds i8, i8* %544, i64 16
%547 = bitcast i8* %546 to <16 x i8>*
store <16 x i8> %543, <16 x i8>* %547
%548 = add nuw i64 %536, 32
%549 = add i64 %537, 1
%550 = icmp eq i64 %549, %479
br i1 %550, label %551, label %535
551: ; preds = %535, %532
%552 = icmp eq i64 %475, %464
br i1 %552, label %4771, label %553
553: ; preds = %551
%554 = and i64 %464, 24
%555 = icmp eq i64 %554, 0
br i1 %555, label %570, label %556
556: ; preds = %472, %553
%557 = phi i64 [ %475, %553 ], [ 0, %472 ]
%558 = and i64 %464, 4294967288
br label %559
559: ; preds = %559, %556
%560 = phi i64 [ %557, %556 ], [ %566, %559 ]
%561 = getelementptr inbounds i8, i8* %0, i64 %560
%562 = bitcast i8* %561 to <8 x i8>*
%563 = load <8 x i8>, <8 x i8>* %562
%564 = getelementptr inbounds i8, i8* %2, i64 %560
%565 = bitcast i8* %564 to <8 x i8>*
store <8 x i8> %563, <8 x i8>* %565
%566 = add nuw i64 %560, 8
%567 = icmp eq i64 %566, %558
br i1 %567, label %568, label %559
568: ; preds = %559
%569 = icmp eq i64 %558, %464
br i1 %569, label %4771, label %570
570: ; preds = %466, %463, %553, %568
%571 = phi i64 [ 0, %463 ], [ 0, %466 ], [ %475, %553 ], [ %558, %568 ]
%572 = xor i64 %571, -1
%573 = add nsw i64 %572, %464
%574 = and i64 %464, 3
%575 = icmp eq i64 %574, 0
br i1 %575, label %585, label %576
576: ; preds = %570, %576
%577 = phi i64 [ %582, %576 ], [ %571, %570 ]
%578 = phi i64 [ %583, %576 ], [ 0, %570 ]
%579 = getelementptr inbounds i8, i8* %0, i64 %577
%580 = load i8, i8* %579
%581 = getelementptr inbounds i8, i8* %2, i64 %577
store i8 %580, i8* %581
%582 = add nuw nsw i64 %577, 1
%583 = add i64 %578, 1
%584 = icmp eq i64 %583, %574
br i1 %584, label %585, label %576
585: ; preds = %576, %570
%586 = phi i64 [ %571, %570 ], [ %582, %576 ]
%587 = icmp ult i64 %573, 3
br i1 %587, label %4771, label %588
588: ; preds = %585, %588
%589 = phi i64 [ %605, %588 ], [ %586, %585 ]
%590 = getelementptr inbounds i8, i8* %0, i64 %589
%591 = load i8, i8* %590
%592 = getelementptr inbounds i8, i8* %2, i64 %589
store i8 %591, i8* %592
%593 = add nuw nsw i64 %589, 1
%594 = getelementptr inbounds i8, i8* %0, i64 %593
%595 = load i8, i8* %594
%596 = getelementptr inbounds i8, i8* %2, i64 %593
store i8 %595, i8* %596
%597 = add nuw nsw i64 %589, 2
%598 = getelementptr inbounds i8, i8* %0, i64 %597
%599 = load i8, i8* %598
%600 = getelementptr inbounds i8, i8* %2, i64 %597
store i8 %599, i8* %600
%601 = add nuw nsw i64 %589, 3
%602 = getelementptr inbounds i8, i8* %0, i64 %601
%603 = load i8, i8* %602
%604 = getelementptr inbounds i8, i8* %2, i64 %601
store i8 %603, i8* %604
%605 = add nuw nsw i64 %589, 4
%606 = icmp eq i64 %605, %464
br i1 %606, label %4771, label %588
607: ; preds = %458, %607
%608 = phi i64 [ %628, %607 ], [ %459, %458 ]
%609 = getelementptr inbounds i8, i8* %0, i64 %608
%610 = load i8, i8* %609
%611 = zext i8 %610 to i16
%612 = getelementptr inbounds i16, i16* %374, i64 %608
store i16 %611, i16* %612
%613 = add nuw nsw i64 %608, 1
%614 = getelementptr inbounds i8, i8* %0, i64 %613
%615 = load i8, i8* %614
%616 = zext i8 %615 to i16
%617 = getelementptr inbounds i16, i16* %374, i64 %613
store i16 %616, i16* %617
%618 = add nuw nsw i64 %608, 2
%619 = getelementptr inbounds i8, i8* %0, i64 %618
%620 = load i8, i8* %619
%621 = zext i8 %620 to i16
%622 = getelementptr inbounds i16, i16* %374, i64 %618
store i16 %621, i16* %622
%623 = add nuw nsw i64 %608, 3
%624 = getelementptr inbounds i8, i8* %0, i64 %623
%625 = load i8, i8* %624
%626 = zext i8 %625 to i16
%627 = getelementptr inbounds i16, i16* %374, i64 %623
store i16 %626, i16* %627
%628 = add nuw nsw i64 %608, 4
%629 = icmp eq i64 %628, %375
br i1 %629, label %4771, label %607
630: ; preds = %368, %630
%631 = phi i64 [ %651, %630 ], [ %369, %368 ]
%632 = getelementptr inbounds i8, i8* %0, i64 %631
%633 = load i8, i8* %632
%634 = zext i8 %633 to i16
%635 = getelementptr inbounds i16, i16* %284, i64 %631
store i16 %634, i16* %635
%636 = add nuw nsw i64 %631, 1
%637 = getelementptr inbounds i8, i8* %0, i64 %636
%638 = load i8, i8* %637
%639 = zext i8 %638 to i16
%640 = getelementptr inbounds i16, i16* %284, i64 %636
store i16 %639, i16* %640
%641 = add nuw nsw i64 %631, 2
%642 = getelementptr inbounds i8, i8* %0, i64 %641
%643 = load i8, i8* %642
%644 = zext i8 %643 to i16
%645 = getelementptr inbounds i16, i16* %284, i64 %641
store i16 %644, i16* %645
%646 = add nuw nsw i64 %631, 3
%647 = getelementptr inbounds i8, i8* %0, i64 %646
%648 = load i8, i8* %647
%649 = zext i8 %648 to i16
%650 = getelementptr inbounds i16, i16* %284, i64 %646
store i16 %649, i16* %650
%651 = add nuw nsw i64 %631, 4
%652 = icmp eq i64 %651, %285
br i1 %652, label %4771, label %630
653: ; preds = %10, %10
%654 = icmp sgt i32 %4, 0
br i1 %654, label %655, label %4771
655: ; preds = %653
%656 = bitcast i8* %2 to i32*
%657 = zext i32 %4 to i64
%658 = icmp ult i32 %4, 8
br i1 %658, label %724, label %659
659: ; preds = %655
%660 = shl nuw nsw i64 %657, 2
%661 = getelementptr i8, i8* %2, i64 %660
%662 = getelementptr i8, i8* %0, i64 %657
%663 = icmp ugt i8* %662, %2
%664 = icmp ugt i8* %661, %0
%665 = and i1 %663, %664
br i1 %665, label %724, label %666
666: ; preds = %659
%667 = and i64 %657, 4294967288
%668 = add nsw i64 %667, -8
%669 = lshr exact i64 %668, 3
%670 = add nuw nsw i64 %669, 1
%671 = and i64 %670, 1
%672 = icmp eq i64 %668, 0
br i1 %672, label %706, label %673
673: ; preds = %666
%674 = and i64 %670, 4611686018427387902
br label %675
675: ; preds = %675, %673
%676 = phi i64 [ 0, %673 ], [ %703, %675 ]
%677 = phi i64 [ 0, %673 ], [ %704, %675 ]
%678 = getelementptr inbounds i8, i8* %0, i64 %676
%679 = bitcast i8* %678 to <4 x i8>*
%680 = load <4 x i8>, <4 x i8>* %679
%681 = getelementptr inbounds i8, i8* %678, i64 4
%682 = bitcast i8* %681 to <4 x i8>*
%683 = load <4 x i8>, <4 x i8>* %682
%684 = zext <4 x i8> %680 to <4 x i32>
%685 = zext <4 x i8> %683 to <4 x i32>
%686 = getelementptr inbounds i32, i32* %656, i64 %676
%687 = bitcast i32* %686 to <4 x i32>*
store <4 x i32> %684, <4 x i32>* %687
%688 = getelementptr inbounds i32, i32* %686, i64 4
%689 = bitcast i32* %688 to <4 x i32>*
store <4 x i32> %685, <4 x i32>* %689
%690 = or i64 %676, 8
%691 = getelementptr inbounds i8, i8* %0, i64 %690
%692 = bitcast i8* %691 to <4 x i8>*
%693 = load <4 x i8>, <4 x i8>* %692
%694 = getelementptr inbounds i8, i8* %691, i64 4
%695 = bitcast i8* %694 to <4 x i8>*
%696 = load <4 x i8>, <4 x i8>* %695
%697 = zext <4 x i8> %693 to <4 x i32>
%698 = zext <4 x i8> %696 to <4 x i32>
%699 = getelementptr inbounds i32, i32* %656, i64 %690
%700 = bitcast i32* %699 to <4 x i32>*
store <4 x i32> %697, <4 x i32>* %700
%701 = getelementptr inbounds i32, i32* %699, i64 4
%702 = bitcast i32* %701 to <4 x i32>*
store <4 x i32> %698, <4 x i32>* %702
%703 = add nuw i64 %676, 16
%704 = add i64 %677, 2
%705 = icmp eq i64 %704, %674
br i1 %705, label %706, label %675
706: ; preds = %675, %666
%707 = phi i64 [ 0, %666 ], [ %703, %675 ]
%708 = icmp eq i64 %671, 0
br i1 %708, label %722, label %709
709: ; preds = %706
%710 = getelementptr inbounds i8, i8* %0, i64 %707
%711 = bitcast i8* %710 to <4 x i8>*
%712 = load <4 x i8>, <4 x i8>* %711
%713 = getelementptr inbounds i8, i8* %710, i64 4
%714 = bitcast i8* %713 to <4 x i8>*
%715 = load <4 x i8>, <4 x i8>* %714
%716 = zext <4 x i8> %712 to <4 x i32>
%717 = zext <4 x i8> %715 to <4 x i32>
%718 = getelementptr inbounds i32, i32* %656, i64 %707
%719 = bitcast i32* %718 to <4 x i32>*
store <4 x i32> %716, <4 x i32>* %719
%720 = getelementptr inbounds i32, i32* %718, i64 4
%721 = bitcast i32* %720 to <4 x i32>*
store <4 x i32> %717, <4 x i32>* %721
br label %722
722: ; preds = %706, %709
%723 = icmp eq i64 %667, %657
br i1 %723, label %4771, label %724
724: ; preds = %659, %655, %722
%725 = phi i64 [ 0, %659 ], [ 0, %655 ], [ %667, %722 ]
%726 = xor i64 %725, -1
%727 = add nsw i64 %726, %657
%728 = and i64 %657, 3
%729 = icmp eq i64 %728, 0
br i1 %729, label %740, label %730
730: ; preds = %724, %730
%731 = phi i64 [ %737, %730 ], [ %725, %724 ]
%732 = phi i64 [ %738, %730 ], [ 0, %724 ]
%733 = getelementptr inbounds i8, i8* %0, i64 %731
%734 = load i8, i8* %733
%735 = zext i8 %734 to i32
%736 = getelementptr inbounds i32, i32* %656, i64 %731
store i32 %735, i32* %736
%737 = add nuw nsw i64 %731, 1
%738 = add i64 %732, 1
%739 = icmp eq i64 %738, %728
br i1 %739, label %740, label %730
740: ; preds = %730, %724
%741 = phi i64 [ %725, %724 ], [ %737, %730 ]
%742 = icmp ult i64 %727, 3
br i1 %742, label %4771, label %743
743: ; preds = %740, %743
%744 = phi i64 [ %764, %743 ], [ %741, %740 ]
%745 = getelementptr inbounds i8, i8* %0, i64 %744
%746 = load i8, i8* %745
%747 = zext i8 %746 to i32
%748 = getelementptr inbounds i32, i32* %656, i64 %744
store i32 %747, i32* %748
%749 = add nuw nsw i64 %744, 1
%750 = getelementptr inbounds i8, i8* %0, i64 %749
%751 = load i8, i8* %750
%752 = zext i8 %751 to i32
%753 = getelementptr inbounds i32, i32* %656, i64 %749
store i32 %752, i32* %753
%754 = add nuw nsw i64 %744, 2
%755 = getelementptr inbounds i8, i8* %0, i64 %754
%756 = load i8, i8* %755
%757 = zext i8 %756 to i32
%758 = getelementptr inbounds i32, i32* %656, i64 %754
store i32 %757, i32* %758
%759 = add nuw nsw i64 %744, 3
%760 = getelementptr inbounds i8, i8* %0, i64 %759
%761 = load i8, i8* %760
%762 = zext i8 %761 to i32
%763 = getelementptr inbounds i32, i32* %656, i64 %759
store i32 %762, i32* %763
%764 = add nuw nsw i64 %744, 4
%765 = icmp eq i64 %764, %657
br i1 %765, label %4771, label %743
766: ; preds = %278, %766
%767 = phi i64 [ %787, %766 ], [ %279, %278 ]
%768 = getelementptr inbounds i8, i8* %0, i64 %767
%769 = load i8, i8* %768
%770 = zext i8 %769 to i32
%771 = getelementptr inbounds i32, i32* %194, i64 %767
store i32 %770, i32* %771
%772 = add nuw nsw i64 %767, 1
%773 = getelementptr inbounds i8, i8* %0, i64 %772
%774 = load i8, i8* %773
%775 = zext i8 %774 to i32
%776 = getelementptr inbounds i32, i32* %194, i64 %772
store i32 %775, i32* %776
%777 = add nuw nsw i64 %767, 2
%778 = getelementptr inbounds i8, i8* %0, i64 %777
%779 = load i8, i8* %778
%780 = zext i8 %779 to i32
%781 = getelementptr inbounds i32, i32* %194, i64 %777
store i32 %780, i32* %781
%782 = add nuw nsw i64 %767, 3
%783 = getelementptr inbounds i8, i8* %0, i64 %782
%784 = load i8, i8* %783
%785 = zext i8 %784 to i32
%786 = getelementptr inbounds i32, i32* %194, i64 %782
store i32 %785, i32* %786
%787 = add nuw nsw i64 %767, 4
%788 = icmp eq i64 %787, %195
br i1 %788, label %4771, label %766
789: ; preds = %188, %789
%790 = phi i64 [ %810, %789 ], [ %189, %188 ]
%791 = getelementptr inbounds i8, i8* %0, i64 %790
%792 = load i8, i8* %791
%793 = uitofp i8 %792 to float
%794 = getelementptr inbounds float, float* %104, i64 %790
store float %793, float* %794
%795 = add nuw nsw i64 %790, 1
%796 = getelementptr inbounds i8, i8* %0, i64 %795
%797 = load i8, i8* %796
%798 = uitofp i8 %797 to float
%799 = getelementptr inbounds float, float* %104, i64 %795
store float %798, float* %799
%800 = add nuw nsw i64 %790, 2
%801 = getelementptr inbounds i8, i8* %0, i64 %800
%802 = load i8, i8* %801
%803 = uitofp i8 %802 to float
%804 = getelementptr inbounds float, float* %104, i64 %800
store float %803, float* %804
%805 = add nuw nsw i64 %790, 3
%806 = getelementptr inbounds i8, i8* %0, i64 %805
%807 = load i8, i8* %806
%808 = uitofp i8 %807 to float
%809 = getelementptr inbounds float, float* %104, i64 %805
store float %808, float* %809
%810 = add nuw nsw i64 %790, 4
%811 = icmp eq i64 %810, %105
br i1 %811, label %4771, label %789
812: ; preds = %98, %812
%813 = phi i64 [ %833, %812 ], [ %99, %98 ]
%814 = getelementptr inbounds i8, i8* %0, i64 %813
%815 = load i8, i8* %814
%816 = uitofp i8 %815 to double
%817 = getelementptr inbounds double, double* %14, i64 %813
store double %816, double* %817
%818 = add nuw nsw i64 %813, 1
%819 = getelementptr inbounds i8, i8* %0, i64 %818
%820 = load i8, i8* %819
%821 = uitofp i8 %820 to double
%822 = getelementptr inbounds double, double* %14, i64 %818
store double %821, double* %822
%823 = add nuw nsw i64 %813, 2
%824 = getelementptr inbounds i8, i8* %0, i64 %823
%825 = load i8, i8* %824
%826 = uitofp i8 %825 to double
%827 = getelementptr inbounds double, double* %14, i64 %823
store double %826, double* %827
%828 = add nuw nsw i64 %813, 3
%829 = getelementptr inbounds i8, i8* %0, i64 %828
%830 = load i8, i8* %829
%831 = uitofp i8 %830 to double
%832 = getelementptr inbounds double, double* %14, i64 %828
store double %831, double* %832
%833 = add nuw nsw i64 %813, 4
%834 = icmp eq i64 %833, %15
br i1 %834, label %4771, label %812
835: ; preds = %8
switch i32 %6, label %4771 [
i32 99, label %1259
i32 115, label %1148
i32 117, label %1037
i32 83, label %1410
i32 105, label %1410
i32 85, label %970
i32 102, label %903
i32 100, label %836
]
836: ; preds = %835
%837 = icmp sgt i32 %4, 0
br i1 %837, label %838, label %4771
838: ; preds = %836
%839 = bitcast i8* %0 to i16*
%840 = bitcast i8* %2 to double*
%841 = zext i32 %4 to i64
%842 = icmp ult i32 %4, 4
br i1 %842, label %901, label %843
843: ; preds = %838
%844 = and i64 %841, 4294967292
%845 = add nsw i64 %844, -4
%846 = lshr exact i64 %845, 2
%847 = add nuw nsw i64 %846, 1
%848 = and i64 %847, 1
%849 = icmp eq i64 %845, 0
br i1 %849, label %883, label %850
850: ; preds = %843
%851 = and i64 %847, 9223372036854775806
br label %852
852: ; preds = %852, %850
%853 = phi i64 [ 0, %850 ], [ %880, %852 ]
%854 = phi i64 [ 0, %850 ], [ %881, %852 ]
%855 = getelementptr inbounds i16, i16* %839, i64 %853
%856 = bitcast i16* %855 to <2 x i16>*
%857 = load <2 x i16>, <2 x i16>* %856
%858 = getelementptr inbounds i16, i16* %855, i64 2
%859 = bitcast i16* %858 to <2 x i16>*
%860 = load <2 x i16>, <2 x i16>* %859
%861 = sitofp <2 x i16> %857 to <2 x double>
%862 = sitofp <2 x i16> %860 to <2 x double>
%863 = getelementptr inbounds double, double* %840, i64 %853
%864 = bitcast double* %863 to <2 x double>*
store <2 x double> %861, <2 x double>* %864
%865 = getelementptr inbounds double, double* %863, i64 2
%866 = bitcast double* %865 to <2 x double>*
store <2 x double> %862, <2 x double>* %866
%867 = or i64 %853, 4
%868 = getelementptr inbounds i16, i16* %839, i64 %867
%869 = bitcast i16* %868 to <2 x i16>*
%870 = load <2 x i16>, <2 x i16>* %869
%871 = getelementptr inbounds i16, i16* %868, i64 2
%872 = bitcast i16* %871 to <2 x i16>*
%873 = load <2 x i16>, <2 x i16>* %872
%874 = sitofp <2 x i16> %870 to <2 x double>
%875 = sitofp <2 x i16> %873 to <2 x double>
%876 = getelementptr inbounds double, double* %840, i64 %867
%877 = bitcast double* %876 to <2 x double>*
store <2 x double> %874, <2 x double>* %877
%878 = getelementptr inbounds double, double* %876, i64 2
%879 = bitcast double* %878 to <2 x double>*
store <2 x double> %875, <2 x double>* %879
%880 = add nuw i64 %853, 8
%881 = add i64 %854, 2
%882 = icmp eq i64 %881, %851
br i1 %882, label %883, label %852
883: ; preds = %852, %843
%884 = phi i64 [ 0, %843 ], [ %880, %852 ]
%885 = icmp eq i64 %848, 0
br i1 %885, label %899, label %886
886: ; preds = %883
%887 = getelementptr inbounds i16, i16* %839, i64 %884
%888 = bitcast i16* %887 to <2 x i16>*
%889 = load <2 x i16>, <2 x i16>* %888
%890 = getelementptr inbounds i16, i16* %887, i64 2
%891 = bitcast i16* %890 to <2 x i16>*
%892 = load <2 x i16>, <2 x i16>* %891
%893 = sitofp <2 x i16> %889 to <2 x double>
%894 = sitofp <2 x i16> %892 to <2 x double>
%895 = getelementptr inbounds double, double* %840, i64 %884
%896 = bitcast double* %895 to <2 x double>*
store <2 x double> %893, <2 x double>* %896
%897 = getelementptr inbounds double, double* %895, i64 2
%898 = bitcast double* %897 to <2 x double>*
store <2 x double> %894, <2 x double>* %898
br label %899
899: ; preds = %883, %886
%900 = icmp eq i64 %844, %841
br i1 %900, label %4771, label %901
901: ; preds = %838, %899
%902 = phi i64 [ 0, %838 ], [ %844, %899 ]
br label %1501
903: ; preds = %835
%904 = icmp sgt i32 %4, 0
br i1 %904, label %905, label %4771
905: ; preds = %903
%906 = bitcast i8* %0 to i16*
%907 = bitcast i8* %2 to float*
%908 = zext i32 %4 to i64
%909 = icmp ult i32 %4, 8
br i1 %909, label %968, label %910
910: ; preds = %905
%911 = and i64 %908, 4294967288
%912 = add nsw i64 %911, -8
%913 = lshr exact i64 %912, 3
%914 = add nuw nsw i64 %913, 1
%915 = and i64 %914, 1
%916 = icmp eq i64 %912, 0
br i1 %916, label %950, label %917
917: ; preds = %910
%918 = and i64 %914, 4611686018427387902
br label %919
919: ; preds = %919, %917
%920 = phi i64 [ 0, %917 ], [ %947, %919 ]
%921 = phi i64 [ 0, %917 ], [ %948, %919 ]
%922 = getelementptr inbounds i16, i16* %906, i64 %920
%923 = bitcast i16* %922 to <4 x i16>*
%924 = load <4 x i16>, <4 x i16>* %923
%925 = getelementptr inbounds i16, i16* %922, i64 4
%926 = bitcast i16* %925 to <4 x i16>*
%927 = load <4 x i16>, <4 x i16>* %926
%928 = sitofp <4 x i16> %924 to <4 x float>
%929 = sitofp <4 x i16> %927 to <4 x float>
%930 = getelementptr inbounds float, float* %907, i64 %920
%931 = bitcast float* %930 to <4 x float>*
store <4 x float> %928, <4 x float>* %931
%932 = getelementptr inbounds float, float* %930, i64 4
%933 = bitcast float* %932 to <4 x float>*
store <4 x float> %929, <4 x float>* %933
%934 = or i64 %920, 8
%935 = getelementptr inbounds i16, i16* %906, i64 %934
%936 = bitcast i16* %935 to <4 x i16>*
%937 = load <4 x i16>, <4 x i16>* %936
%938 = getelementptr inbounds i16, i16* %935, i64 4
%939 = bitcast i16* %938 to <4 x i16>*
%940 = load <4 x i16>, <4 x i16>* %939
%941 = sitofp <4 x i16> %937 to <4 x float>
%942 = sitofp <4 x i16> %940 to <4 x float>
%943 = getelementptr inbounds float, float* %907, i64 %934
%944 = bitcast float* %943 to <4 x float>*
store <4 x float> %941, <4 x float>* %944
%945 = getelementptr inbounds float, float* %943, i64 4
%946 = bitcast float* %945 to <4 x float>*
store <4 x float> %942, <4 x float>* %946
%947 = add nuw i64 %920, 16
%948 = add i64 %921, 2
%949 = icmp eq i64 %948, %918
br i1 %949, label %950, label %919
950: ; preds = %919, %910
%951 = phi i64 [ 0, %910 ], [ %947, %919 ]
%952 = icmp eq i64 %915, 0
br i1 %952, label %966, label %953
953: ; preds = %950
%954 = getelementptr inbounds i16, i16* %906, i64 %951
%955 = bitcast i16* %954 to <4 x i16>*
%956 = load <4 x i16>, <4 x i16>* %955
%957 = getelementptr inbounds i16, i16* %954, i64 4
%958 = bitcast i16* %957 to <4 x i16>*
%959 = load <4 x i16>, <4 x i16>* %958
%960 = sitofp <4 x i16> %956 to <4 x float>
%961 = sitofp <4 x i16> %959 to <4 x float>
%962 = getelementptr inbounds float, float* %907, i64 %951
%963 = bitcast float* %962 to <4 x float>*
store <4 x float> %960, <4 x float>* %963
%964 = getelementptr inbounds float, float* %962, i64 4
%965 = bitcast float* %964 to <4 x float>*
store <4 x float> %961, <4 x float>* %965
br label %966
966: ; preds = %950, %953
%967 = icmp eq i64 %911, %908
br i1 %967, label %4771, label %968
968: ; preds = %905, %966
%969 = phi i64 [ 0, %905 ], [ %911, %966 ]
br label %1493
970: ; preds = %835
%971 = icmp sgt i32 %4, 0
br i1 %971, label %972, label %4771
972: ; preds = %970
%973 = bitcast i8* %0 to i16*
%974 = bitcast i8* %2 to i32*
%975 = zext i32 %4 to i64
%976 = icmp ult i32 %4, 8
br i1 %976, label %1035, label %977
977: ; preds = %972
%978 = and i64 %975, 4294967288
%979 = add nsw i64 %978, -8
%980 = lshr exact i64 %979, 3
%981 = add nuw nsw i64 %980, 1
%982 = and i64 %981, 1
%983 = icmp eq i64 %979, 0
br i1 %983, label %1017, label %984
984: ; preds = %977
%985 = and i64 %981, 4611686018427387902
br label %986
986: ; preds = %986, %984
%987 = phi i64 [ 0, %984 ], [ %1014, %986 ]
%988 = phi i64 [ 0, %984 ], [ %1015, %986 ]
%989 = getelementptr inbounds i16, i16* %973, i64 %987
%990 = bitcast i16* %989 to <4 x i16>*
%991 = load <4 x i16>, <4 x i16>* %990
%992 = getelementptr inbounds i16, i16* %989, i64 4
%993 = bitcast i16* %992 to <4 x i16>*
%994 = load <4 x i16>, <4 x i16>* %993
%995 = sext <4 x i16> %991 to <4 x i32>
%996 = sext <4 x i16> %994 to <4 x i32>
%997 = getelementptr inbounds i32, i32* %974, i64 %987
%998 = bitcast i32* %997 to <4 x i32>*
store <4 x i32> %995, <4 x i32>* %998
%999 = getelementptr inbounds i32, i32* %997, i64 4
%1000 = bitcast i32* %999 to <4 x i32>*
store <4 x i32> %996, <4 x i32>* %1000
%1001 = or i64 %987, 8
%1002 = getelementptr inbounds i16, i16* %973, i64 %1001
%1003 = bitcast i16* %1002 to <4 x i16>*
%1004 = load <4 x i16>, <4 x i16>* %1003
%1005 = getelementptr inbounds i16, i16* %1002, i64 4
%1006 = bitcast i16* %1005 to <4 x i16>*
%1007 = load <4 x i16>, <4 x i16>* %1006
%1008 = sext <4 x i16> %1004 to <4 x i32>
%1009 = sext <4 x i16> %1007 to <4 x i32>
%1010 = getelementptr inbounds i32, i32* %974, i64 %1001
%1011 = bitcast i32* %1010 to <4 x i32>*
store <4 x i32> %1008, <4 x i32>* %1011
%1012 = getelementptr inbounds i32, i32* %1010, i64 4
%1013 = bitcast i32* %1012 to <4 x i32>*
store <4 x i32> %1009, <4 x i32>* %1013
%1014 = add nuw i64 %987, 16
%1015 = add i64 %988, 2
%1016 = icmp eq i64 %1015, %985
br i1 %1016, label %1017, label %986
1017: ; preds = %986, %977
%1018 = phi i64 [ 0, %977 ], [ %1014, %986 ]
%1019 = icmp eq i64 %982, 0
br i1 %1019, label %1033, label %1020
1020: ; preds = %1017
%1021 = getelementptr inbounds i16, i16* %973, i64 %1018
%1022 = bitcast i16* %1021 to <4 x i16>*
%1023 = load <4 x i16>, <4 x i16>* %1022
%1024 = getelementptr inbounds i16, i16* %1021, i64 4
%1025 = bitcast i16* %1024 to <4 x i16>*
%1026 = load <4 x i16>, <4 x i16>* %1025
%1027 = sext <4 x i16> %1023 to <4 x i32>
%1028 = sext <4 x i16> %1026 to <4 x i32>
%1029 = getelementptr inbounds i32, i32* %974, i64 %1018
%1030 = bitcast i32* %1029 to <4 x i32>*
store <4 x i32> %1027, <4 x i32>* %1030
%1031 = getelementptr inbounds i32, i32* %1029, i64 4
%1032 = bitcast i32* %1031 to <4 x i32>*
store <4 x i32> %1028, <4 x i32>* %1032
br label %1033
1033: ; preds = %1017, %1020
%1034 = icmp eq i64 %978, %975
br i1 %1034, label %4771, label %1035
1035: ; preds = %972, %1033
%1036 = phi i64 [ 0, %972 ], [ %978, %1033 ]
br label %1485
1037: ; preds = %835
%1038 = icmp sgt i32 %4, 0
br i1 %1038, label %1039, label %4771
1039: ; preds = %1037
%1040 = bitcast i8* %0 to i16*
%1041 = bitcast i8* %2 to i16*
%1042 = zext i32 %4 to i64
%1043 = icmp ult i32 %4, 16
br i1 %1043, label %1130, label %1044
1044: ; preds = %1039
%1045 = shl nuw nsw i64 %1042, 1
%1046 = getelementptr i8, i8* %2, i64 %1045
%1047 = getelementptr i8, i8* %0, i64 %1045
%1048 = icmp ugt i8* %1047, %2
%1049 = icmp ugt i8* %1046, %0
%1050 = and i1 %1048, %1049
br i1 %1050, label %1130, label %1051
1051: ; preds = %1044
%1052 = and i64 %1042, 4294967280
%1053 = add nsw i64 %1052, -16
%1054 = lshr exact i64 %1053, 4
%1055 = add nuw nsw i64 %1054, 1
%1056 = and i64 %1055, 3
%1057 = icmp ult i64 %1053, 48
br i1 %1057, label %1109, label %1058
1058: ; preds = %1051
%1059 = and i64 %1055, 2305843009213693948
br label %1060
1060: ; preds = %1060, %1058
%1061 = phi i64 [ 0, %1058 ], [ %1106, %1060 ]
%1062 = phi i64 [ 0, %1058 ], [ %1107, %1060 ]
%1063 = getelementptr inbounds i16, i16* %1040, i64 %1061
%1064 = bitcast i16* %1063 to <8 x i16>*
%1065 = load <8 x i16>, <8 x i16>* %1064
%1066 = getelementptr inbounds i16, i16* %1063, i64 8
%1067 = bitcast i16* %1066 to <8 x i16>*
%1068 = load <8 x i16>, <8 x i16>* %1067
%1069 = getelementptr inbounds i16, i16* %1041, i64 %1061
%1070 = bitcast i16* %1069 to <8 x i16>*
store <8 x i16> %1065, <8 x i16>* %1070
%1071 = getelementptr inbounds i16, i16* %1069, i64 8
%1072 = bitcast i16* %1071 to <8 x i16>*
store <8 x i16> %1068, <8 x i16>* %1072
%1073 = or i64 %1061, 16
%1074 = getelementptr inbounds i16, i16* %1040, i64 %1073
%1075 = bitcast i16* %1074 to <8 x i16>*
%1076 = load <8 x i16>, <8 x i16>* %1075
%1077 = getelementptr inbounds i16, i16* %1074, i64 8
%1078 = bitcast i16* %1077 to <8 x i16>*
%1079 = load <8 x i16>, <8 x i16>* %1078
%1080 = getelementptr inbounds i16, i16* %1041, i64 %1073
%1081 = bitcast i16* %1080 to <8 x i16>*
store <8 x i16> %1076, <8 x i16>* %1081
%1082 = getelementptr inbounds i16, i16* %1080, i64 8
%1083 = bitcast i16* %1082 to <8 x i16>*
store <8 x i16> %1079, <8 x i16>* %1083
%1084 = or i64 %1061, 32
%1085 = getelementptr inbounds i16, i16* %1040, i64 %1084
%1086 = bitcast i16* %1085 to <8 x i16>*
%1087 = load <8 x i16>, <8 x i16>* %1086
%1088 = getelementptr inbounds i16, i16* %1085, i64 8
%1089 = bitcast i16* %1088 to <8 x i16>*
%1090 = load <8 x i16>, <8 x i16>* %1089
%1091 = getelementptr inbounds i16, i16* %1041, i64 %1084
%1092 = bitcast i16* %1091 to <8 x i16>*
store <8 x i16> %1087, <8 x i16>* %1092
%1093 = getelementptr inbounds i16, i16* %1091, i64 8
%1094 = bitcast i16* %1093 to <8 x i16>*
store <8 x i16> %1090, <8 x i16>* %1094
%1095 = or i64 %1061, 48
%1096 = getelementptr inbounds i16, i16* %1040, i64 %1095
%1097 = bitcast i16* %1096 to <8 x i16>*
%1098 = load <8 x i16>, <8 x i16>* %1097
%1099 = getelementptr inbounds i16, i16* %1096, i64 8
%1100 = bitcast i16* %1099 to <8 x i16>*
%1101 = load <8 x i16>, <8 x i16>* %1100
%1102 = getelementptr inbounds i16, i16* %1041, i64 %1095
%1103 = bitcast i16* %1102 to <8 x i16>*
store <8 x i16> %1098, <8 x i16>* %1103
%1104 = getelementptr inbounds i16, i16* %1102, i64 8
%1105 = bitcast i16* %1104 to <8 x i16>*
store <8 x i16> %1101, <8 x i16>* %1105
%1106 = add nuw i64 %1061, 64
%1107 = add i64 %1062, 4
%1108 = icmp eq i64 %1107, %1059
br i1 %1108, label %1109, label %1060
1109: ; preds = %1060, %1051
%1110 = phi i64 [ 0, %1051 ], [ %1106, %1060 ]
%1111 = icmp eq i64 %1056, 0
br i1 %1111, label %1128, label %1112
1112: ; preds = %1109, %1112
%1113 = phi i64 [ %1125, %1112 ], [ %1110, %1109 ]
%1114 = phi i64 [ %1126, %1112 ], [ 0, %1109 ]
%1115 = getelementptr inbounds i16, i16* %1040, i64 %1113
%1116 = bitcast i16* %1115 to <8 x i16>*
%1117 = load <8 x i16>, <8 x i16>* %1116
%1118 = getelementptr inbounds i16, i16* %1115, i64 8
%1119 = bitcast i16* %1118 to <8 x i16>*
%1120 = load <8 x i16>, <8 x i16>* %1119
%1121 = getelementptr inbounds i16, i16* %1041, i64 %1113
%1122 = bitcast i16* %1121 to <8 x i16>*
store <8 x i16> %1117, <8 x i16>* %1122
%1123 = getelementptr inbounds i16, i16* %1121, i64 8
%1124 = bitcast i16* %1123 to <8 x i16>*
store <8 x i16> %1120, <8 x i16>* %1124
%1125 = add nuw i64 %1113, 16
%1126 = add i64 %1114, 1
%1127 = icmp eq i64 %1126, %1056
br i1 %1127, label %1128, label %1112
1128: ; preds = %1112, %1109
%1129 = icmp eq i64 %1052, %1042
br i1 %1129, label %4771, label %1130
1130: ; preds = %1044, %1039, %1128
%1131 = phi i64 [ 0, %1044 ], [ 0, %1039 ], [ %1052, %1128 ]
%1132 = xor i64 %1131, -1
%1133 = add nsw i64 %1132, %1042
%1134 = and i64 %1042, 3
%1135 = icmp eq i64 %1134, 0
br i1 %1135, label %1145, label %1136
1136: ; preds = %1130, %1136
%1137 = phi i64 [ %1142, %1136 ], [ %1131, %1130 ]
%1138 = phi i64 [ %1143, %1136 ], [ 0, %1130 ]
%1139 = getelementptr inbounds i16, i16* %1040, i64 %1137
%1140 = load i16, i16* %1139
%1141 = getelementptr inbounds i16, i16* %1041, i64 %1137
store i16 %1140, i16* %1141
%1142 = add nuw nsw i64 %1137, 1
%1143 = add i64 %1138, 1
%1144 = icmp eq i64 %1143, %1134
br i1 %1144, label %1145, label %1136
1145: ; preds = %1136, %1130
%1146 = phi i64 [ %1131, %1130 ], [ %1142, %1136 ]
%1147 = icmp ult i64 %1133, 3
br i1 %1147, label %4771, label %1391
1148: ; preds = %835
%1149 = icmp sgt i32 %4, 0
br i1 %1149, label %1150, label %4771
1150: ; preds = %1148
%1151 = bitcast i8* %0 to i16*
%1152 = bitcast i8* %2 to i16*
%1153 = zext i32 %4 to i64
%1154 = icmp ult i32 %4, 16
br i1 %1154, label %1241, label %1155
1155: ; preds = %1150
%1156 = shl nuw nsw i64 %1153, 1
%1157 = getelementptr i8, i8* %2, i64 %1156
%1158 = getelementptr i8, i8* %0, i64 %1156
%1159 = icmp ugt i8* %1158, %2
%1160 = icmp ugt i8* %1157, %0
%1161 = and i1 %1159, %1160
br i1 %1161, label %1241, label %1162
1162: ; preds = %1155
%1163 = and i64 %1153, 4294967280
%1164 = add nsw i64 %1163, -16
%1165 = lshr exact i64 %1164, 4
%1166 = add nuw nsw i64 %1165, 1
%1167 = and i64 %1166, 3
%1168 = icmp ult i64 %1164, 48
br i1 %1168, label %1220, label %1169
1169: ; preds = %1162
%1170 = and i64 %1166, 2305843009213693948
br label %1171
1171: ; preds = %1171, %1169
%1172 = phi i64 [ 0, %1169 ], [ %1217, %1171 ]
%1173 = phi i64 [ 0, %1169 ], [ %1218, %1171 ]
%1174 = getelementptr inbounds i16, i16* %1151, i64 %1172
%1175 = bitcast i16* %1174 to <8 x i16>*
%1176 = load <8 x i16>, <8 x i16>* %1175
%1177 = getelementptr inbounds i16, i16* %1174, i64 8
%1178 = bitcast i16* %1177 to <8 x i16>*
%1179 = load <8 x i16>, <8 x i16>* %1178
%1180 = getelementptr inbounds i16, i16* %1152, i64 %1172
%1181 = bitcast i16* %1180 to <8 x i16>*
store <8 x i16> %1176, <8 x i16>* %1181
%1182 = getelementptr inbounds i16, i16* %1180, i64 8
%1183 = bitcast i16* %1182 to <8 x i16>*
store <8 x i16> %1179, <8 x i16>* %1183
%1184 = or i64 %1172, 16
%1185 = getelementptr inbounds i16, i16* %1151, i64 %1184
%1186 = bitcast i16* %1185 to <8 x i16>*
%1187 = load <8 x i16>, <8 x i16>* %1186
%1188 = getelementptr inbounds i16, i16* %1185, i64 8
%1189 = bitcast i16* %1188 to <8 x i16>*
%1190 = load <8 x i16>, <8 x i16>* %1189
%1191 = getelementptr inbounds i16, i16* %1152, i64 %1184
%1192 = bitcast i16* %1191 to <8 x i16>*
store <8 x i16> %1187, <8 x i16>* %1192
%1193 = getelementptr inbounds i16, i16* %1191, i64 8
%1194 = bitcast i16* %1193 to <8 x i16>*
store <8 x i16> %1190, <8 x i16>* %1194
%1195 = or i64 %1172, 32
%1196 = getelementptr inbounds i16, i16* %1151, i64 %1195
%1197 = bitcast i16* %1196 to <8 x i16>*
%1198 = load <8 x i16>, <8 x i16>* %1197
%1199 = getelementptr inbounds i16, i16* %1196, i64 8
%1200 = bitcast i16* %1199 to <8 x i16>*
%1201 = load <8 x i16>, <8 x i16>* %1200
%1202 = getelementptr inbounds i16, i16* %1152, i64 %1195
%1203 = bitcast i16* %1202 to <8 x i16>*
store <8 x i16> %1198, <8 x i16>* %1203
%1204 = getelementptr inbounds i16, i16* %1202, i64 8
%1205 = bitcast i16* %1204 to <8 x i16>*
store <8 x i16> %1201, <8 x i16>* %1205
%1206 = or i64 %1172, 48
%1207 = getelementptr inbounds i16, i16* %1151, i64 %1206
%1208 = bitcast i16* %1207 to <8 x i16>*
%1209 = load <8 x i16>, <8 x i16>* %1208
%1210 = getelementptr inbounds i16, i16* %1207, i64 8
%1211 = bitcast i16* %1210 to <8 x i16>*
%1212 = load <8 x i16>, <8 x i16>* %1211
%1213 = getelementptr inbounds i16, i16* %1152, i64 %1206
%1214 = bitcast i16* %1213 to <8 x i16>*
store <8 x i16> %1209, <8 x i16>* %1214
%1215 = getelementptr inbounds i16, i16* %1213, i64 8
%1216 = bitcast i16* %1215 to <8 x i16>*
store <8 x i16> %1212, <8 x i16>* %1216
%1217 = add nuw i64 %1172, 64
%1218 = add i64 %1173, 4
%1219 = icmp eq i64 %1218, %1170
br i1 %1219, label %1220, label %1171
1220: ; preds = %1171, %1162
%1221 = phi i64 [ 0, %1162 ], [ %1217, %1171 ]
%1222 = icmp eq i64 %1167, 0
br i1 %1222, label %1239, label %1223
1223: ; preds = %1220, %1223
%1224 = phi i64 [ %1236, %1223 ], [ %1221, %1220 ]
%1225 = phi i64 [ %1237, %1223 ], [ 0, %1220 ]
%1226 = getelementptr inbounds i16, i16* %1151, i64 %1224
%1227 = bitcast i16* %1226 to <8 x i16>*
%1228 = load <8 x i16>, <8 x i16>* %1227
%1229 = getelementptr inbounds i16, i16* %1226, i64 8
%1230 = bitcast i16* %1229 to <8 x i16>*
%1231 = load <8 x i16>, <8 x i16>* %1230
%1232 = getelementptr inbounds i16, i16* %1152, i64 %1224
%1233 = bitcast i16* %1232 to <8 x i16>*
store <8 x i16> %1228, <8 x i16>* %1233
%1234 = getelementptr inbounds i16, i16* %1232, i64 8
%1235 = bitcast i16* %1234 to <8 x i16>*
store <8 x i16> %1231, <8 x i16>* %1235
%1236 = add nuw i64 %1224, 16
%1237 = add i64 %1225, 1
%1238 = icmp eq i64 %1237, %1167
br i1 %1238, label %1239, label %1223
1239: ; preds = %1223, %1220
%1240 = icmp eq i64 %1163, %1153
br i1 %1240, label %4771, label %1241
1241: ; preds = %1155, %1150, %1239
%1242 = phi i64 [ 0, %1155 ], [ 0, %1150 ], [ %1163, %1239 ]
%1243 = xor i64 %1242, -1
%1244 = add nsw i64 %1243, %1153
%1245 = and i64 %1153, 3
%1246 = icmp eq i64 %1245, 0
br i1 %1246, label %1256, label %1247
1247: ; preds = %1241, %1247
%1248 = phi i64 [ %1253, %1247 ], [ %1242, %1241 ]
%1249 = phi i64 [ %1254, %1247 ], [ 0, %1241 ]
%1250 = getelementptr inbounds i16, i16* %1151, i64 %1248
%1251 = load i16, i16* %1250
%1252 = getelementptr inbounds i16, i16* %1152, i64 %1248
store i16 %1251, i16* %1252
%1253 = add nuw nsw i64 %1248, 1
%1254 = add i64 %1249, 1
%1255 = icmp eq i64 %1254, %1245
br i1 %1255, label %1256, label %1247
1256: ; preds = %1247, %1241
%1257 = phi i64 [ %1242, %1241 ], [ %1253, %1247 ]
%1258 = icmp ult i64 %1244, 3
br i1 %1258, label %4771, label %1372
1259: ; preds = %835
%1260 = icmp sgt i32 %4, 0
br i1 %1260, label %1261, label %4771
1261: ; preds = %1259
%1262 = bitcast i8* %0 to i16*
%1263 = zext i32 %4 to i64
%1264 = icmp ult i32 %4, 16
br i1 %1264, label %1330, label %1265
1265: ; preds = %1261
%1266 = getelementptr i8, i8* %2, i64 %1263
%1267 = shl nuw nsw i64 %1263, 1
%1268 = getelementptr i8, i8* %0, i64 %1267
%1269 = icmp ugt i8* %1268, %2
%1270 = icmp ugt i8* %1266, %0
%1271 = and i1 %1269, %1270
br i1 %1271, label %1330, label %1272
1272: ; preds = %1265
%1273 = and i64 %1263, 4294967280
%1274 = add nsw i64 %1273, -16
%1275 = lshr exact i64 %1274, 4
%1276 = add nuw nsw i64 %1275, 1
%1277 = and i64 %1276, 1
%1278 = icmp eq i64 %1274, 0
br i1 %1278, label %1312, label %1279
1279: ; preds = %1272
%1280 = and i64 %1276, 2305843009213693950
br label %1281
1281: ; preds = %1281, %1279
%1282 = phi i64 [ 0, %1279 ], [ %1309, %1281 ]
%1283 = phi i64 [ 0, %1279 ], [ %1310, %1281 ]
%1284 = getelementptr inbounds i16, i16* %1262, i64 %1282
%1285 = bitcast i16* %1284 to <8 x i16>*
%1286 = load <8 x i16>, <8 x i16>* %1285
%1287 = getelementptr inbounds i16, i16* %1284, i64 8
%1288 = bitcast i16* %1287 to <8 x i16>*
%1289 = load <8 x i16>, <8 x i16>* %1288
%1290 = trunc <8 x i16> %1286 to <8 x i8>
%1291 = trunc <8 x i16> %1289 to <8 x i8>
%1292 = getelementptr inbounds i8, i8* %2, i64 %1282
%1293 = bitcast i8* %1292 to <8 x i8>*
store <8 x i8> %1290, <8 x i8>* %1293
%1294 = getelementptr inbounds i8, i8* %1292, i64 8
%1295 = bitcast i8* %1294 to <8 x i8>*
store <8 x i8> %1291, <8 x i8>* %1295
%1296 = or i64 %1282, 16
%1297 = getelementptr inbounds i16, i16* %1262, i64 %1296
%1298 = bitcast i16* %1297 to <8 x i16>*
%1299 = load <8 x i16>, <8 x i16>* %1298
%1300 = getelementptr inbounds i16, i16* %1297, i64 8
%1301 = bitcast i16* %1300 to <8 x i16>*
%1302 = load <8 x i16>, <8 x i16>* %1301
%1303 = trunc <8 x i16> %1299 to <8 x i8>
%1304 = trunc <8 x i16> %1302 to <8 x i8>
%1305 = getelementptr inbounds i8, i8* %2, i64 %1296
%1306 = bitcast i8* %1305 to <8 x i8>*
store <8 x i8> %1303, <8 x i8>* %1306
%1307 = getelementptr inbounds i8, i8* %1305, i64 8
%1308 = bitcast i8* %1307 to <8 x i8>*
store <8 x i8> %1304, <8 x i8>* %1308
%1309 = add nuw i64 %1282, 32
%1310 = add i64 %1283, 2
%1311 = icmp eq i64 %1310, %1280
br i1 %1311, label %1312, label %1281
1312: ; preds = %1281, %1272
%1313 = phi i64 [ 0, %1272 ], [ %1309, %1281 ]
%1314 = icmp eq i64 %1277, 0
br i1 %1314, label %1328, label %1315
1315: ; preds = %1312
%1316 = getelementptr inbounds i16, i16* %1262, i64 %1313
%1317 = bitcast i16* %1316 to <8 x i16>*
%1318 = load <8 x i16>, <8 x i16>* %1317
%1319 = getelementptr inbounds i16, i16* %1316, i64 8
%1320 = bitcast i16* %1319 to <8 x i16>*
%1321 = load <8 x i16>, <8 x i16>* %1320
%1322 = trunc <8 x i16> %1318 to <8 x i8>
%1323 = trunc <8 x i16> %1321 to <8 x i8>
%1324 = getelementptr inbounds i8, i8* %2, i64 %1313
%1325 = bitcast i8* %1324 to <8 x i8>*
store <8 x i8> %1322, <8 x i8>* %1325
%1326 = getelementptr inbounds i8, i8* %1324, i64 8
%1327 = bitcast i8* %1326 to <8 x i8>*
store <8 x i8> %1323, <8 x i8>* %1327
br label %1328
1328: ; preds = %1312, %1315
%1329 = icmp eq i64 %1273, %1263
br i1 %1329, label %4771, label %1330
1330: ; preds = %1265, %1261, %1328
%1331 = phi i64 [ 0, %1265 ], [ 0, %1261 ], [ %1273, %1328 ]
%1332 = xor i64 %1331, -1
%1333 = add nsw i64 %1332, %1263
%1334 = and i64 %1263, 3
%1335 = icmp eq i64 %1334, 0
br i1 %1335, label %1346, label %1336
1336: ; preds = %1330, %1336
%1337 = phi i64 [ %1343, %1336 ], [ %1331, %1330 ]
%1338 = phi i64 [ %1344, %1336 ], [ 0, %1330 ]
%1339 = getelementptr inbounds i16, i16* %1262, i64 %1337
%1340 = load i16, i16* %1339
%1341 = trunc i16 %1340 to i8
%1342 = getelementptr inbounds i8, i8* %2, i64 %1337
store i8 %1341, i8* %1342
%1343 = add nuw nsw i64 %1337, 1
%1344 = add i64 %1338, 1
%1345 = icmp eq i64 %1344, %1334
br i1 %1345, label %1346, label %1336
1346: ; preds = %1336, %1330
%1347 = phi i64 [ %1331, %1330 ], [ %1343, %1336 ]
%1348 = icmp ult i64 %1333, 3
br i1 %1348, label %4771, label %1349
1349: ; preds = %1346, %1349
%1350 = phi i64 [ %1370, %1349 ], [ %1347, %1346 ]
%1351 = getelementptr inbounds i16, i16* %1262, i64 %1350
%1352 = load i16, i16* %1351
%1353 = trunc i16 %1352 to i8
%1354 = getelementptr inbounds i8, i8* %2, i64 %1350
store i8 %1353, i8* %1354
%1355 = add nuw nsw i64 %1350, 1
%1356 = getelementptr inbounds i16, i16* %1262, i64 %1355
%1357 = load i16, i16* %1356
%1358 = trunc i16 %1357 to i8
%1359 = getelementptr inbounds i8, i8* %2, i64 %1355
store i8 %1358, i8* %1359
%1360 = add nuw nsw i64 %1350, 2
%1361 = getelementptr inbounds i16, i16* %1262, i64 %1360
%1362 = load i16, i16* %1361
%1363 = trunc i16 %1362 to i8
%1364 = getelementptr inbounds i8, i8* %2, i64 %1360
store i8 %1363, i8* %1364
%1365 = add nuw nsw i64 %1350, 3
%1366 = getelementptr inbounds i16, i16* %1262, i64 %1365
%1367 = load i16, i16* %1366
%1368 = trunc i16 %1367 to i8
%1369 = getelementptr inbounds i8, i8* %2, i64 %1365
store i8 %1368, i8* %1369
%1370 = add nuw nsw i64 %1350, 4
%1371 = icmp eq i64 %1370, %1263
br i1 %1371, label %4771, label %1349
1372: ; preds = %1256, %1372
%1373 = phi i64 [ %1389, %1372 ], [ %1257, %1256 ]
%1374 = getelementptr inbounds i16, i16* %1151, i64 %1373
%1375 = load i16, i16* %1374
%1376 = getelementptr inbounds i16, i16* %1152, i64 %1373
store i16 %1375, i16* %1376
%1377 = add nuw nsw i64 %1373, 1
%1378 = getelementptr inbounds i16, i16* %1151, i64 %1377
%1379 = load i16, i16* %1378
%1380 = getelementptr inbounds i16, i16* %1152, i64 %1377
store i16 %1379, i16* %1380
%1381 = add nuw nsw i64 %1373, 2
%1382 = getelementptr inbounds i16, i16* %1151, i64 %1381
%1383 = load i16, i16* %1382
%1384 = getelementptr inbounds i16, i16* %1152, i64 %1381
store i16 %1383, i16* %1384
%1385 = add nuw nsw i64 %1373, 3
%1386 = getelementptr inbounds i16, i16* %1151, i64 %1385
%1387 = load i16, i16* %1386
%1388 = getelementptr inbounds i16, i16* %1152, i64 %1385
store i16 %1387, i16* %1388
%1389 = add nuw nsw i64 %1373, 4
%1390 = icmp eq i64 %1389, %1153
br i1 %1390, label %4771, label %1372
1391: ; preds = %1145, %1391
%1392 = phi i64 [ %1408, %1391 ], [ %1146, %1145 ]
%1393 = getelementptr inbounds i16, i16* %1040, i64 %1392
%1394 = load i16, i16* %1393
%1395 = getelementptr inbounds i16, i16* %1041, i64 %1392
store i16 %1394, i16* %1395
%1396 = add nuw nsw i64 %1392, 1
%1397 = getelementptr inbounds i16, i16* %1040, i64 %1396
%1398 = load i16, i16* %1397
%1399 = getelementptr inbounds i16, i16* %1041, i64 %1396
store i16 %1398, i16* %1399
%1400 = add nuw nsw i64 %1392, 2
%1401 = getelementptr inbounds i16, i16* %1040, i64 %1400
%1402 = load i16, i16* %1401
%1403 = getelementptr inbounds i16, i16* %1041, i64 %1400
store i16 %1402, i16* %1403
%1404 = add nuw nsw i64 %1392, 3
%1405 = getelementptr inbounds i16, i16* %1040, i64 %1404
%1406 = load i16, i16* %1405
%1407 = getelementptr inbounds i16, i16* %1041, i64 %1404
store i16 %1406, i16* %1407
%1408 = add nuw nsw i64 %1392, 4
%1409 = icmp eq i64 %1408, %1042
br i1 %1409, label %4771, label %1391
1410: ; preds = %835, %835
%1411 = icmp sgt i32 %4, 0
br i1 %1411, label %1412, label %4771
1412: ; preds = %1410
%1413 = bitcast i8* %0 to i16*
%1414 = bitcast i8* %2 to i32*
%1415 = zext i32 %4 to i64
%1416 = icmp ult i32 %4, 8
br i1 %1416, label %1475, label %1417
1417: ; preds = %1412
%1418 = and i64 %1415, 4294967288
%1419 = add nsw i64 %1418, -8
%1420 = lshr exact i64 %1419, 3
%1421 = add nuw nsw i64 %1420, 1
%1422 = and i64 %1421, 1
%1423 = icmp eq i64 %1419, 0
br i1 %1423, label %1457, label %1424
1424: ; preds = %1417
%1425 = and i64 %1421, 4611686018427387902
br label %1426
1426: ; preds = %1426, %1424
%1427 = phi i64 [ 0, %1424 ], [ %1454, %1426 ]
%1428 = phi i64 [ 0, %1424 ], [ %1455, %1426 ]
%1429 = getelementptr inbounds i16, i16* %1413, i64 %1427
%1430 = bitcast i16* %1429 to <4 x i16>*
%1431 = load <4 x i16>, <4 x i16>* %1430
%1432 = getelementptr inbounds i16, i16* %1429, i64 4
%1433 = bitcast i16* %1432 to <4 x i16>*
%1434 = load <4 x i16>, <4 x i16>* %1433
%1435 = sext <4 x i16> %1431 to <4 x i32>
%1436 = sext <4 x i16> %1434 to <4 x i32>
%1437 = getelementptr inbounds i32, i32* %1414, i64 %1427
%1438 = bitcast i32* %1437 to <4 x i32>*
store <4 x i32> %1435, <4 x i32>* %1438
%1439 = getelementptr inbounds i32, i32* %1437, i64 4
%1440 = bitcast i32* %1439 to <4 x i32>*
store <4 x i32> %1436, <4 x i32>* %1440
%1441 = or i64 %1427, 8
%1442 = getelementptr inbounds i16, i16* %1413, i64 %1441
%1443 = bitcast i16* %1442 to <4 x i16>*
%1444 = load <4 x i16>, <4 x i16>* %1443
%1445 = getelementptr inbounds i16, i16* %1442, i64 4
%1446 = bitcast i16* %1445 to <4 x i16>*
%1447 = load <4 x i16>, <4 x i16>* %1446
%1448 = sext <4 x i16> %1444 to <4 x i32>
%1449 = sext <4 x i16> %1447 to <4 x i32>
%1450 = getelementptr inbounds i32, i32* %1414, i64 %1441
%1451 = bitcast i32* %1450 to <4 x i32>*
store <4 x i32> %1448, <4 x i32>* %1451
%1452 = getelementptr inbounds i32, i32* %1450, i64 4
%1453 = bitcast i32* %1452 to <4 x i32>*
store <4 x i32> %1449, <4 x i32>* %1453
%1454 = add nuw i64 %1427, 16
%1455 = add i64 %1428, 2
%1456 = icmp eq i64 %1455, %1425
br i1 %1456, label %1457, label %1426
1457: ; preds = %1426, %1417
%1458 = phi i64 [ 0, %1417 ], [ %1454, %1426 ]
%1459 = icmp eq i64 %1422, 0
br i1 %1459, label %1473, label %1460
1460: ; preds = %1457
%1461 = getelementptr inbounds i16, i16* %1413, i64 %1458
%1462 = bitcast i16* %1461 to <4 x i16>*
%1463 = load <4 x i16>, <4 x i16>* %1462
%1464 = getelementptr inbounds i16, i16* %1461, i64 4
%1465 = bitcast i16* %1464 to <4 x i16>*
%1466 = load <4 x i16>, <4 x i16>* %1465
%1467 = sext <4 x i16> %1463 to <4 x i32>
%1468 = sext <4 x i16> %1466 to <4 x i32>
%1469 = getelementptr inbounds i32, i32* %1414, i64 %1458
%1470 = bitcast i32* %1469 to <4 x i32>*
store <4 x i32> %1467, <4 x i32>* %1470
%1471 = getelementptr inbounds i32, i32* %1469, i64 4
%1472 = bitcast i32* %1471 to <4 x i32>*
store <4 x i32> %1468, <4 x i32>* %1472
br label %1473
1473: ; preds = %1457, %1460
%1474 = icmp eq i64 %1418, %1415
br i1 %1474, label %4771, label %1475
1475: ; preds = %1412, %1473
%1476 = phi i64 [ 0, %1412 ], [ %1418, %1473 ]
br label %1477
1477: ; preds = %1475, %1477
%1478 = phi i64 [ %1483, %1477 ], [ %1476, %1475 ]
%1479 = getelementptr inbounds i16, i16* %1413, i64 %1478
%1480 = load i16, i16* %1479
%1481 = sext i16 %1480 to i32
%1482 = getelementptr inbounds i32, i32* %1414, i64 %1478
store i32 %1481, i32* %1482
%1483 = add nuw nsw i64 %1478, 1
%1484 = icmp eq i64 %1483, %1415
br i1 %1484, label %4771, label %1477
1485: ; preds = %1035, %1485
%1486 = phi i64 [ %1491, %1485 ], [ %1036, %1035 ]
%1487 = getelementptr inbounds i16, i16* %973, i64 %1486
%1488 = load i16, i16* %1487
%1489 = sext i16 %1488 to i32
%1490 = getelementptr inbounds i32, i32* %974, i64 %1486
store i32 %1489, i32* %1490
%1491 = add nuw nsw i64 %1486, 1
%1492 = icmp eq i64 %1491, %975
br i1 %1492, label %4771, label %1485
1493: ; preds = %968, %1493
%1494 = phi i64 [ %1499, %1493 ], [ %969, %968 ]
%1495 = getelementptr inbounds i16, i16* %906, i64 %1494
%1496 = load i16, i16* %1495
%1497 = sitofp i16 %1496 to float
%1498 = getelementptr inbounds float, float* %907, i64 %1494
store float %1497, float* %1498
%1499 = add nuw nsw i64 %1494, 1
%1500 = icmp eq i64 %1499, %908
br i1 %1500, label %4771, label %1493
1501: ; preds = %901, %1501
%1502 = phi i64 [ %1507, %1501 ], [ %902, %901 ]
%1503 = getelementptr inbounds i16, i16* %839, i64 %1502
%1504 = load i16, i16* %1503
%1505 = sitofp i16 %1504 to double
%1506 = getelementptr inbounds double, double* %840, i64 %1502
store double %1505, double* %1506
%1507 = add nuw nsw i64 %1502, 1
%1508 = icmp eq i64 %1507, %841
br i1 %1508, label %4771, label %1501
1509: ; preds = %8
switch i32 %6, label %4771 [
i32 99, label %1933
i32 115, label %1822
i32 117, label %1711
i32 105, label %2084
i32 83, label %2084
i32 85, label %1644
i32 102, label %1577
i32 100, label %1510
]
1510: ; preds = %1509
%1511 = icmp sgt i32 %4, 0
br i1 %1511, label %1512, label %4771
1512: ; preds = %1510
%1513 = bitcast i8* %0 to i16*
%1514 = bitcast i8* %2 to double*
%1515 = zext i32 %4 to i64
%1516 = icmp ult i32 %4, 4
br i1 %1516, label %1575, label %1517
1517: ; preds = %1512
%1518 = and i64 %1515, 4294967292
%1519 = add nsw i64 %1518, -4
%1520 = lshr exact i64 %1519, 2
%1521 = add nuw nsw i64 %1520, 1
%1522 = and i64 %1521, 1
%1523 = icmp eq i64 %1519, 0
br i1 %1523, label %1557, label %1524
1524: ; preds = %1517
%1525 = and i64 %1521, 9223372036854775806
br label %1526
1526: ; preds = %1526, %1524
%1527 = phi i64 [ 0, %1524 ], [ %1554, %1526 ]
%1528 = phi i64 [ 0, %1524 ], [ %1555, %1526 ]
%1529 = getelementptr inbounds i16, i16* %1513, i64 %1527
%1530 = bitcast i16* %1529 to <2 x i16>*
%1531 = load <2 x i16>, <2 x i16>* %1530
%1532 = getelementptr inbounds i16, i16* %1529, i64 2
%1533 = bitcast i16* %1532 to <2 x i16>*
%1534 = load <2 x i16>, <2 x i16>* %1533
%1535 = uitofp <2 x i16> %1531 to <2 x double>
%1536 = uitofp <2 x i16> %1534 to <2 x double>
%1537 = getelementptr inbounds double, double* %1514, i64 %1527
%1538 = bitcast double* %1537 to <2 x double>*
store <2 x double> %1535, <2 x double>* %1538
%1539 = getelementptr inbounds double, double* %1537, i64 2
%1540 = bitcast double* %1539 to <2 x double>*
store <2 x double> %1536, <2 x double>* %1540
%1541 = or i64 %1527, 4
%1542 = getelementptr inbounds i16, i16* %1513, i64 %1541
%1543 = bitcast i16* %1542 to <2 x i16>*
%1544 = load <2 x i16>, <2 x i16>* %1543
%1545 = getelementptr inbounds i16, i16* %1542, i64 2
%1546 = bitcast i16* %1545 to <2 x i16>*
%1547 = load <2 x i16>, <2 x i16>* %1546
%1548 = uitofp <2 x i16> %1544 to <2 x double>
%1549 = uitofp <2 x i16> %1547 to <2 x double>
%1550 = getelementptr inbounds double, double* %1514, i64 %1541
%1551 = bitcast double* %1550 to <2 x double>*
store <2 x double> %1548, <2 x double>* %1551
%1552 = getelementptr inbounds double, double* %1550, i64 2
%1553 = bitcast double* %1552 to <2 x double>*
store <2 x double> %1549, <2 x double>* %1553
%1554 = add nuw i64 %1527, 8
%1555 = add i64 %1528, 2
%1556 = icmp eq i64 %1555, %1525
br i1 %1556, label %1557, label %1526
1557: ; preds = %1526, %1517
%1558 = phi i64 [ 0, %1517 ], [ %1554, %1526 ]
%1559 = icmp eq i64 %1522, 0
br i1 %1559, label %1573, label %1560
1560: ; preds = %1557
%1561 = getelementptr inbounds i16, i16* %1513, i64 %1558
%1562 = bitcast i16* %1561 to <2 x i16>*
%1563 = load <2 x i16>, <2 x i16>* %1562
%1564 = getelementptr inbounds i16, i16* %1561, i64 2
%1565 = bitcast i16* %1564 to <2 x i16>*
%1566 = load <2 x i16>, <2 x i16>* %1565
%1567 = uitofp <2 x i16> %1563 to <2 x double>
%1568 = uitofp <2 x i16> %1566 to <2 x double>
%1569 = getelementptr inbounds double, double* %1514, i64 %1558
%1570 = bitcast double* %1569 to <2 x double>*
store <2 x double> %1567, <2 x double>* %1570
%1571 = getelementptr inbounds double, double* %1569, i64 2
%1572 = bitcast double* %1571 to <2 x double>*
store <2 x double> %1568, <2 x double>* %1572
br label %1573
1573: ; preds = %1557, %1560
%1574 = icmp eq i64 %1518, %1515
br i1 %1574, label %4771, label %1575
1575: ; preds = %1512, %1573
%1576 = phi i64 [ 0, %1512 ], [ %1518, %1573 ]
br label %2175
1577: ; preds = %1509
%1578 = icmp sgt i32 %4, 0
br i1 %1578, label %1579, label %4771
1579: ; preds = %1577
%1580 = bitcast i8* %0 to i16*
%1581 = bitcast i8* %2 to float*
%1582 = zext i32 %4 to i64
%1583 = icmp ult i32 %4, 8
br i1 %1583, label %1642, label %1584
1584: ; preds = %1579
%1585 = and i64 %1582, 4294967288
%1586 = add nsw i64 %1585, -8
%1587 = lshr exact i64 %1586, 3
%1588 = add nuw nsw i64 %1587, 1
%1589 = and i64 %1588, 1
%1590 = icmp eq i64 %1586, 0
br i1 %1590, label %1624, label %1591
1591: ; preds = %1584
%1592 = and i64 %1588, 4611686018427387902
br label %1593
1593: ; preds = %1593, %1591
%1594 = phi i64 [ 0, %1591 ], [ %1621, %1593 ]
%1595 = phi i64 [ 0, %1591 ], [ %1622, %1593 ]
%1596 = getelementptr inbounds i16, i16* %1580, i64 %1594
%1597 = bitcast i16* %1596 to <4 x i16>*
%1598 = load <4 x i16>, <4 x i16>* %1597
%1599 = getelementptr inbounds i16, i16* %1596, i64 4
%1600 = bitcast i16* %1599 to <4 x i16>*
%1601 = load <4 x i16>, <4 x i16>* %1600
%1602 = uitofp <4 x i16> %1598 to <4 x float>
%1603 = uitofp <4 x i16> %1601 to <4 x float>
%1604 = getelementptr inbounds float, float* %1581, i64 %1594
%1605 = bitcast float* %1604 to <4 x float>*
store <4 x float> %1602, <4 x float>* %1605
%1606 = getelementptr inbounds float, float* %1604, i64 4
%1607 = bitcast float* %1606 to <4 x float>*
store <4 x float> %1603, <4 x float>* %1607
%1608 = or i64 %1594, 8
%1609 = getelementptr inbounds i16, i16* %1580, i64 %1608
%1610 = bitcast i16* %1609 to <4 x i16>*
%1611 = load <4 x i16>, <4 x i16>* %1610
%1612 = getelementptr inbounds i16, i16* %1609, i64 4
%1613 = bitcast i16* %1612 to <4 x i16>*
%1614 = load <4 x i16>, <4 x i16>* %1613
%1615 = uitofp <4 x i16> %1611 to <4 x float>
%1616 = uitofp <4 x i16> %1614 to <4 x float>
%1617 = getelementptr inbounds float, float* %1581, i64 %1608
%1618 = bitcast float* %1617 to <4 x float>*
store <4 x float> %1615, <4 x float>* %1618
%1619 = getelementptr inbounds float, float* %1617, i64 4
%1620 = bitcast float* %1619 to <4 x float>*
store <4 x float> %1616, <4 x float>* %1620
%1621 = add nuw i64 %1594, 16
%1622 = add i64 %1595, 2
%1623 = icmp eq i64 %1622, %1592
br i1 %1623, label %1624, label %1593
1624: ; preds = %1593, %1584
%1625 = phi i64 [ 0, %1584 ], [ %1621, %1593 ]
%1626 = icmp eq i64 %1589, 0
br i1 %1626, label %1640, label %1627
1627: ; preds = %1624
%1628 = getelementptr inbounds i16, i16* %1580, i64 %1625
%1629 = bitcast i16* %1628 to <4 x i16>*
%1630 = load <4 x i16>, <4 x i16>* %1629
%1631 = getelementptr inbounds i16, i16* %1628, i64 4
%1632 = bitcast i16* %1631 to <4 x i16>*
%1633 = load <4 x i16>, <4 x i16>* %1632
%1634 = uitofp <4 x i16> %1630 to <4 x float>
%1635 = uitofp <4 x i16> %1633 to <4 x float>
%1636 = getelementptr inbounds float, float* %1581, i64 %1625
%1637 = bitcast float* %1636 to <4 x float>*
store <4 x float> %1634, <4 x float>* %1637
%1638 = getelementptr inbounds float, float* %1636, i64 4
%1639 = bitcast float* %1638 to <4 x float>*
store <4 x float> %1635, <4 x float>* %1639
br label %1640
1640: ; preds = %1624, %1627
%1641 = icmp eq i64 %1585, %1582
br i1 %1641, label %4771, label %1642
1642: ; preds = %1579, %1640
%1643 = phi i64 [ 0, %1579 ], [ %1585, %1640 ]
br label %2167
1644: ; preds = %1509
%1645 = icmp sgt i32 %4, 0
br i1 %1645, label %1646, label %4771
1646: ; preds = %1644
%1647 = bitcast i8* %0 to i16*
%1648 = bitcast i8* %2 to i32*
%1649 = zext i32 %4 to i64
%1650 = icmp ult i32 %4, 8
br i1 %1650, label %1709, label %1651
1651: ; preds = %1646
%1652 = and i64 %1649, 4294967288
%1653 = add nsw i64 %1652, -8
%1654 = lshr exact i64 %1653, 3
%1655 = add nuw nsw i64 %1654, 1
%1656 = and i64 %1655, 1
%1657 = icmp eq i64 %1653, 0
br i1 %1657, label %1691, label %1658
1658: ; preds = %1651
%1659 = and i64 %1655, 4611686018427387902
br label %1660
1660: ; preds = %1660, %1658
%1661 = phi i64 [ 0, %1658 ], [ %1688, %1660 ]
%1662 = phi i64 [ 0, %1658 ], [ %1689, %1660 ]
%1663 = getelementptr inbounds i16, i16* %1647, i64 %1661
%1664 = bitcast i16* %1663 to <4 x i16>*
%1665 = load <4 x i16>, <4 x i16>* %1664
%1666 = getelementptr inbounds i16, i16* %1663, i64 4
%1667 = bitcast i16* %1666 to <4 x i16>*
%1668 = load <4 x i16>, <4 x i16>* %1667
%1669 = zext <4 x i16> %1665 to <4 x i32>
%1670 = zext <4 x i16> %1668 to <4 x i32>
%1671 = getelementptr inbounds i32, i32* %1648, i64 %1661
%1672 = bitcast i32* %1671 to <4 x i32>*
store <4 x i32> %1669, <4 x i32>* %1672
%1673 = getelementptr inbounds i32, i32* %1671, i64 4
%1674 = bitcast i32* %1673 to <4 x i32>*
store <4 x i32> %1670, <4 x i32>* %1674
%1675 = or i64 %1661, 8
%1676 = getelementptr inbounds i16, i16* %1647, i64 %1675
%1677 = bitcast i16* %1676 to <4 x i16>*
%1678 = load <4 x i16>, <4 x i16>* %1677
%1679 = getelementptr inbounds i16, i16* %1676, i64 4
%1680 = bitcast i16* %1679 to <4 x i16>*
%1681 = load <4 x i16>, <4 x i16>* %1680
%1682 = zext <4 x i16> %1678 to <4 x i32>
%1683 = zext <4 x i16> %1681 to <4 x i32>
%1684 = getelementptr inbounds i32, i32* %1648, i64 %1675
%1685 = bitcast i32* %1684 to <4 x i32>*
store <4 x i32> %1682, <4 x i32>* %1685
%1686 = getelementptr inbounds i32, i32* %1684, i64 4
%1687 = bitcast i32* %1686 to <4 x i32>*
store <4 x i32> %1683, <4 x i32>* %1687
%1688 = add nuw i64 %1661, 16
%1689 = add i64 %1662, 2
%1690 = icmp eq i64 %1689, %1659
br i1 %1690, label %1691, label %1660
1691: ; preds = %1660, %1651
%1692 = phi i64 [ 0, %1651 ], [ %1688, %1660 ]
%1693 = icmp eq i64 %1656, 0
br i1 %1693, label %1707, label %1694
1694: ; preds = %1691
%1695 = getelementptr inbounds i16, i16* %1647, i64 %1692
%1696 = bitcast i16* %1695 to <4 x i16>*
%1697 = load <4 x i16>, <4 x i16>* %1696
%1698 = getelementptr inbounds i16, i16* %1695, i64 4
%1699 = bitcast i16* %1698 to <4 x i16>*
%1700 = load <4 x i16>, <4 x i16>* %1699
%1701 = zext <4 x i16> %1697 to <4 x i32>
%1702 = zext <4 x i16> %1700 to <4 x i32>
%1703 = getelementptr inbounds i32, i32* %1648, i64 %1692
%1704 = bitcast i32* %1703 to <4 x i32>*
store <4 x i32> %1701, <4 x i32>* %1704
%1705 = getelementptr inbounds i32, i32* %1703, i64 4
%1706 = bitcast i32* %1705 to <4 x i32>*
store <4 x i32> %1702, <4 x i32>* %1706
br label %1707
1707: ; preds = %1691, %1694
%1708 = icmp eq i64 %1652, %1649
br i1 %1708, label %4771, label %1709
1709: ; preds = %1646, %1707
%1710 = phi i64 [ 0, %1646 ], [ %1652, %1707 ]
br label %2159
1711: ; preds = %1509
%1712 = icmp sgt i32 %4, 0
br i1 %1712, label %1713, label %4771
1713: ; preds = %1711
%1714 = bitcast i8* %0 to i16*
%1715 = bitcast i8* %2 to i16*
%1716 = zext i32 %4 to i64
%1717 = icmp ult i32 %4, 16
br i1 %1717, label %1804, label %1718
1718: ; preds = %1713
%1719 = shl nuw nsw i64 %1716, 1
%1720 = getelementptr i8, i8* %2, i64 %1719
%1721 = getelementptr i8, i8* %0, i64 %1719
%1722 = icmp ugt i8* %1721, %2
%1723 = icmp ugt i8* %1720, %0
%1724 = and i1 %1722, %1723
br i1 %1724, label %1804, label %1725
1725: ; preds = %1718
%1726 = and i64 %1716, 4294967280
%1727 = add nsw i64 %1726, -16
%1728 = lshr exact i64 %1727, 4
%1729 = add nuw nsw i64 %1728, 1
%1730 = and i64 %1729, 3
%1731 = icmp ult i64 %1727, 48
br i1 %1731, label %1783, label %1732
1732: ; preds = %1725
%1733 = and i64 %1729, 2305843009213693948
br label %1734
1734: ; preds = %1734, %1732
%1735 = phi i64 [ 0, %1732 ], [ %1780, %1734 ]
%1736 = phi i64 [ 0, %1732 ], [ %1781, %1734 ]
%1737 = getelementptr inbounds i16, i16* %1714, i64 %1735
%1738 = bitcast i16* %1737 to <8 x i16>*
%1739 = load <8 x i16>, <8 x i16>* %1738
%1740 = getelementptr inbounds i16, i16* %1737, i64 8
%1741 = bitcast i16* %1740 to <8 x i16>*
%1742 = load <8 x i16>, <8 x i16>* %1741
%1743 = getelementptr inbounds i16, i16* %1715, i64 %1735
%1744 = bitcast i16* %1743 to <8 x i16>*
store <8 x i16> %1739, <8 x i16>* %1744
%1745 = getelementptr inbounds i16, i16* %1743, i64 8
%1746 = bitcast i16* %1745 to <8 x i16>*
store <8 x i16> %1742, <8 x i16>* %1746
%1747 = or i64 %1735, 16
%1748 = getelementptr inbounds i16, i16* %1714, i64 %1747
%1749 = bitcast i16* %1748 to <8 x i16>*
%1750 = load <8 x i16>, <8 x i16>* %1749
%1751 = getelementptr inbounds i16, i16* %1748, i64 8
%1752 = bitcast i16* %1751 to <8 x i16>*
%1753 = load <8 x i16>, <8 x i16>* %1752
%1754 = getelementptr inbounds i16, i16* %1715, i64 %1747
%1755 = bitcast i16* %1754 to <8 x i16>*
store <8 x i16> %1750, <8 x i16>* %1755
%1756 = getelementptr inbounds i16, i16* %1754, i64 8
%1757 = bitcast i16* %1756 to <8 x i16>*
store <8 x i16> %1753, <8 x i16>* %1757
%1758 = or i64 %1735, 32
%1759 = getelementptr inbounds i16, i16* %1714, i64 %1758
%1760 = bitcast i16* %1759 to <8 x i16>*
%1761 = load <8 x i16>, <8 x i16>* %1760
%1762 = getelementptr inbounds i16, i16* %1759, i64 8
%1763 = bitcast i16* %1762 to <8 x i16>*
%1764 = load <8 x i16>, <8 x i16>* %1763
%1765 = getelementptr inbounds i16, i16* %1715, i64 %1758
%1766 = bitcast i16* %1765 to <8 x i16>*
store <8 x i16> %1761, <8 x i16>* %1766
%1767 = getelementptr inbounds i16, i16* %1765, i64 8
%1768 = bitcast i16* %1767 to <8 x i16>*
store <8 x i16> %1764, <8 x i16>* %1768
%1769 = or i64 %1735, 48
%1770 = getelementptr inbounds i16, i16* %1714, i64 %1769
%1771 = bitcast i16* %1770 to <8 x i16>*
%1772 = load <8 x i16>, <8 x i16>* %1771
%1773 = getelementptr inbounds i16, i16* %1770, i64 8
%1774 = bitcast i16* %1773 to <8 x i16>*
%1775 = load <8 x i16>, <8 x i16>* %1774
%1776 = getelementptr inbounds i16, i16* %1715, i64 %1769
%1777 = bitcast i16* %1776 to <8 x i16>*
store <8 x i16> %1772, <8 x i16>* %1777
%1778 = getelementptr inbounds i16, i16* %1776, i64 8
%1779 = bitcast i16* %1778 to <8 x i16>*
store <8 x i16> %1775, <8 x i16>* %1779
%1780 = add nuw i64 %1735, 64
%1781 = add i64 %1736, 4
%1782 = icmp eq i64 %1781, %1733
br i1 %1782, label %1783, label %1734
1783: ; preds = %1734, %1725
%1784 = phi i64 [ 0, %1725 ], [ %1780, %1734 ]
%1785 = icmp eq i64 %1730, 0
br i1 %1785, label %1802, label %1786
1786: ; preds = %1783, %1786
%1787 = phi i64 [ %1799, %1786 ], [ %1784, %1783 ]
%1788 = phi i64 [ %1800, %1786 ], [ 0, %1783 ]
%1789 = getelementptr inbounds i16, i16* %1714, i64 %1787
%1790 = bitcast i16* %1789 to <8 x i16>*
%1791 = load <8 x i16>, <8 x i16>* %1790
%1792 = getelementptr inbounds i16, i16* %1789, i64 8
%1793 = bitcast i16* %1792 to <8 x i16>*
%1794 = load <8 x i16>, <8 x i16>* %1793
%1795 = getelementptr inbounds i16, i16* %1715, i64 %1787
%1796 = bitcast i16* %1795 to <8 x i16>*
store <8 x i16> %1791, <8 x i16>* %1796
%1797 = getelementptr inbounds i16, i16* %1795, i64 8
%1798 = bitcast i16* %1797 to <8 x i16>*
store <8 x i16> %1794, <8 x i16>* %1798
%1799 = add nuw i64 %1787, 16
%1800 = add i64 %1788, 1
%1801 = icmp eq i64 %1800, %1730
br i1 %1801, label %1802, label %1786
1802: ; preds = %1786, %1783
%1803 = icmp eq i64 %1726, %1716
br i1 %1803, label %4771, label %1804
1804: ; preds = %1718, %1713, %1802
%1805 = phi i64 [ 0, %1718 ], [ 0, %1713 ], [ %1726, %1802 ]
%1806 = xor i64 %1805, -1
%1807 = add nsw i64 %1806, %1716
%1808 = and i64 %1716, 3
%1809 = icmp eq i64 %1808, 0
br i1 %1809, label %1819, label %1810
1810: ; preds = %1804, %1810
%1811 = phi i64 [ %1816, %1810 ], [ %1805, %1804 ]
%1812 = phi i64 [ %1817, %1810 ], [ 0, %1804 ]
%1813 = getelementptr inbounds i16, i16* %1714, i64 %1811
%1814 = load i16, i16* %1813
%1815 = getelementptr inbounds i16, i16* %1715, i64 %1811
store i16 %1814, i16* %1815
%1816 = add nuw nsw i64 %1811, 1
%1817 = add i64 %1812, 1
%1818 = icmp eq i64 %1817, %1808
br i1 %1818, label %1819, label %1810
1819: ; preds = %1810, %1804
%1820 = phi i64 [ %1805, %1804 ], [ %1816, %1810 ]
%1821 = icmp ult i64 %1807, 3
br i1 %1821, label %4771, label %2065
1822: ; preds = %1509
%1823 = icmp sgt i32 %4, 0
br i1 %1823, label %1824, label %4771
1824: ; preds = %1822
%1825 = bitcast i8* %0 to i16*
%1826 = bitcast i8* %2 to i16*
%1827 = zext i32 %4 to i64
%1828 = icmp ult i32 %4, 16
br i1 %1828, label %1915, label %1829
1829: ; preds = %1824
%1830 = shl nuw nsw i64 %1827, 1
%1831 = getelementptr i8, i8* %2, i64 %1830
%1832 = getelementptr i8, i8* %0, i64 %1830
%1833 = icmp ugt i8* %1832, %2
%1834 = icmp ugt i8* %1831, %0
%1835 = and i1 %1833, %1834
br i1 %1835, label %1915, label %1836
1836: ; preds = %1829
%1837 = and i64 %1827, 4294967280
%1838 = add nsw i64 %1837, -16
%1839 = lshr exact i64 %1838, 4
%1840 = add nuw nsw i64 %1839, 1
%1841 = and i64 %1840, 3
%1842 = icmp ult i64 %1838, 48
br i1 %1842, label %1894, label %1843
1843: ; preds = %1836
%1844 = and i64 %1840, 2305843009213693948
br label %1845
1845: ; preds = %1845, %1843
%1846 = phi i64 [ 0, %1843 ], [ %1891, %1845 ]
%1847 = phi i64 [ 0, %1843 ], [ %1892, %1845 ]
%1848 = getelementptr inbounds i16, i16* %1825, i64 %1846
%1849 = bitcast i16* %1848 to <8 x i16>*
%1850 = load <8 x i16>, <8 x i16>* %1849
%1851 = getelementptr inbounds i16, i16* %1848, i64 8
%1852 = bitcast i16* %1851 to <8 x i16>*
%1853 = load <8 x i16>, <8 x i16>* %1852
%1854 = getelementptr inbounds i16, i16* %1826, i64 %1846
%1855 = bitcast i16* %1854 to <8 x i16>*
store <8 x i16> %1850, <8 x i16>* %1855
%1856 = getelementptr inbounds i16, i16* %1854, i64 8
%1857 = bitcast i16* %1856 to <8 x i16>*
store <8 x i16> %1853, <8 x i16>* %1857
%1858 = or i64 %1846, 16
%1859 = getelementptr inbounds i16, i16* %1825, i64 %1858
%1860 = bitcast i16* %1859 to <8 x i16>*
%1861 = load <8 x i16>, <8 x i16>* %1860
%1862 = getelementptr inbounds i16, i16* %1859, i64 8
%1863 = bitcast i16* %1862 to <8 x i16>*
%1864 = load <8 x i16>, <8 x i16>* %1863
%1865 = getelementptr inbounds i16, i16* %1826, i64 %1858
%1866 = bitcast i16* %1865 to <8 x i16>*
store <8 x i16> %1861, <8 x i16>* %1866
%1867 = getelementptr inbounds i16, i16* %1865, i64 8
%1868 = bitcast i16* %1867 to <8 x i16>*
store <8 x i16> %1864, <8 x i16>* %1868
%1869 = or i64 %1846, 32
%1870 = getelementptr inbounds i16, i16* %1825, i64 %1869
%1871 = bitcast i16* %1870 to <8 x i16>*
%1872 = load <8 x i16>, <8 x i16>* %1871
%1873 = getelementptr inbounds i16, i16* %1870, i64 8
%1874 = bitcast i16* %1873 to <8 x i16>*
%1875 = load <8 x i16>, <8 x i16>* %1874
%1876 = getelementptr inbounds i16, i16* %1826, i64 %1869
%1877 = bitcast i16* %1876 to <8 x i16>*
store <8 x i16> %1872, <8 x i16>* %1877
%1878 = getelementptr inbounds i16, i16* %1876, i64 8
%1879 = bitcast i16* %1878 to <8 x i16>*
store <8 x i16> %1875, <8 x i16>* %1879
%1880 = or i64 %1846, 48
%1881 = getelementptr inbounds i16, i16* %1825, i64 %1880
%1882 = bitcast i16* %1881 to <8 x i16>*
%1883 = load <8 x i16>, <8 x i16>* %1882
%1884 = getelementptr inbounds i16, i16* %1881, i64 8
%1885 = bitcast i16* %1884 to <8 x i16>*
%1886 = load <8 x i16>, <8 x i16>* %1885
%1887 = getelementptr inbounds i16, i16* %1826, i64 %1880
%1888 = bitcast i16* %1887 to <8 x i16>*
store <8 x i16> %1883, <8 x i16>* %1888
%1889 = getelementptr inbounds i16, i16* %1887, i64 8
%1890 = bitcast i16* %1889 to <8 x i16>*
store <8 x i16> %1886, <8 x i16>* %1890
%1891 = add nuw i64 %1846, 64
%1892 = add i64 %1847, 4
%1893 = icmp eq i64 %1892, %1844
br i1 %1893, label %1894, label %1845
1894: ; preds = %1845, %1836
%1895 = phi i64 [ 0, %1836 ], [ %1891, %1845 ]
%1896 = icmp eq i64 %1841, 0
br i1 %1896, label %1913, label %1897
1897: ; preds = %1894, %1897
%1898 = phi i64 [ %1910, %1897 ], [ %1895, %1894 ]
%1899 = phi i64 [ %1911, %1897 ], [ 0, %1894 ]
%1900 = getelementptr inbounds i16, i16* %1825, i64 %1898
%1901 = bitcast i16* %1900 to <8 x i16>*
%1902 = load <8 x i16>, <8 x i16>* %1901
%1903 = getelementptr inbounds i16, i16* %1900, i64 8
%1904 = bitcast i16* %1903 to <8 x i16>*
%1905 = load <8 x i16>, <8 x i16>* %1904
%1906 = getelementptr inbounds i16, i16* %1826, i64 %1898
%1907 = bitcast i16* %1906 to <8 x i16>*
store <8 x i16> %1902, <8 x i16>* %1907
%1908 = getelementptr inbounds i16, i16* %1906, i64 8
%1909 = bitcast i16* %1908 to <8 x i16>*
store <8 x i16> %1905, <8 x i16>* %1909
%1910 = add nuw i64 %1898, 16
%1911 = add i64 %1899, 1
%1912 = icmp eq i64 %1911, %1841
br i1 %1912, label %1913, label %1897
1913: ; preds = %1897, %1894
%1914 = icmp eq i64 %1837, %1827
br i1 %1914, label %4771, label %1915
1915: ; preds = %1829, %1824, %1913
%1916 = phi i64 [ 0, %1829 ], [ 0, %1824 ], [ %1837, %1913 ]
%1917 = xor i64 %1916, -1
%1918 = add nsw i64 %1917, %1827
%1919 = and i64 %1827, 3
%1920 = icmp eq i64 %1919, 0
br i1 %1920, label %1930, label %1921
1921: ; preds = %1915, %1921
%1922 = phi i64 [ %1927, %1921 ], [ %1916, %1915 ]
%1923 = phi i64 [ %1928, %1921 ], [ 0, %1915 ]
%1924 = getelementptr inbounds i16, i16* %1825, i64 %1922
%1925 = load i16, i16* %1924
%1926 = getelementptr inbounds i16, i16* %1826, i64 %1922
store i16 %1925, i16* %1926
%1927 = add nuw nsw i64 %1922, 1
%1928 = add i64 %1923, 1
%1929 = icmp eq i64 %1928, %1919
br i1 %1929, label %1930, label %1921
1930: ; preds = %1921, %1915
%1931 = phi i64 [ %1916, %1915 ], [ %1927, %1921 ]
%1932 = icmp ult i64 %1918, 3
br i1 %1932, label %4771, label %2046
1933: ; preds = %1509
%1934 = icmp sgt i32 %4, 0
br i1 %1934, label %1935, label %4771
1935: ; preds = %1933
%1936 = bitcast i8* %0 to i16*
%1937 = zext i32 %4 to i64
%1938 = icmp ult i32 %4, 16
br i1 %1938, label %2004, label %1939
1939: ; preds = %1935
%1940 = getelementptr i8, i8* %2, i64 %1937
%1941 = shl nuw nsw i64 %1937, 1
%1942 = getelementptr i8, i8* %0, i64 %1941
%1943 = icmp ugt i8* %1942, %2
%1944 = icmp ugt i8* %1940, %0
%1945 = and i1 %1943, %1944
br i1 %1945, label %2004, label %1946
1946: ; preds = %1939
%1947 = and i64 %1937, 4294967280
%1948 = add nsw i64 %1947, -16
%1949 = lshr exact i64 %1948, 4
%1950 = add nuw nsw i64 %1949, 1
%1951 = and i64 %1950, 1
%1952 = icmp eq i64 %1948, 0
br i1 %1952, label %1986, label %1953
1953: ; preds = %1946
%1954 = and i64 %1950, 2305843009213693950
br label %1955
1955: ; preds = %1955, %1953
%1956 = phi i64 [ 0, %1953 ], [ %1983, %1955 ]
%1957 = phi i64 [ 0, %1953 ], [ %1984, %1955 ]
%1958 = getelementptr inbounds i16, i16* %1936, i64 %1956
%1959 = bitcast i16* %1958 to <8 x i16>*
%1960 = load <8 x i16>, <8 x i16>* %1959
%1961 = getelementptr inbounds i16, i16* %1958, i64 8
%1962 = bitcast i16* %1961 to <8 x i16>*
%1963 = load <8 x i16>, <8 x i16>* %1962
%1964 = trunc <8 x i16> %1960 to <8 x i8>
%1965 = trunc <8 x i16> %1963 to <8 x i8>
%1966 = getelementptr inbounds i8, i8* %2, i64 %1956
%1967 = bitcast i8* %1966 to <8 x i8>*
store <8 x i8> %1964, <8 x i8>* %1967
%1968 = getelementptr inbounds i8, i8* %1966, i64 8
%1969 = bitcast i8* %1968 to <8 x i8>*
store <8 x i8> %1965, <8 x i8>* %1969
%1970 = or i64 %1956, 16
%1971 = getelementptr inbounds i16, i16* %1936, i64 %1970
%1972 = bitcast i16* %1971 to <8 x i16>*
%1973 = load <8 x i16>, <8 x i16>* %1972
%1974 = getelementptr inbounds i16, i16* %1971, i64 8
%1975 = bitcast i16* %1974 to <8 x i16>*
%1976 = load <8 x i16>, <8 x i16>* %1975
%1977 = trunc <8 x i16> %1973 to <8 x i8>
%1978 = trunc <8 x i16> %1976 to <8 x i8>
%1979 = getelementptr inbounds i8, i8* %2, i64 %1970
%1980 = bitcast i8* %1979 to <8 x i8>*
store <8 x i8> %1977, <8 x i8>* %1980
%1981 = getelementptr inbounds i8, i8* %1979, i64 8
%1982 = bitcast i8* %1981 to <8 x i8>*
store <8 x i8> %1978, <8 x i8>* %1982
%1983 = add nuw i64 %1956, 32
%1984 = add i64 %1957, 2
%1985 = icmp eq i64 %1984, %1954
br i1 %1985, label %1986, label %1955
1986: ; preds = %1955, %1946
%1987 = phi i64 [ 0, %1946 ], [ %1983, %1955 ]
%1988 = icmp eq i64 %1951, 0
br i1 %1988, label %2002, label %1989
1989: ; preds = %1986
%1990 = getelementptr inbounds i16, i16* %1936, i64 %1987
%1991 = bitcast i16* %1990 to <8 x i16>*
%1992 = load <8 x i16>, <8 x i16>* %1991
%1993 = getelementptr inbounds i16, i16* %1990, i64 8
%1994 = bitcast i16* %1993 to <8 x i16>*
%1995 = load <8 x i16>, <8 x i16>* %1994
%1996 = trunc <8 x i16> %1992 to <8 x i8>
%1997 = trunc <8 x i16> %1995 to <8 x i8>
%1998 = getelementptr inbounds i8, i8* %2, i64 %1987
%1999 = bitcast i8* %1998 to <8 x i8>*
store <8 x i8> %1996, <8 x i8>* %1999
%2000 = getelementptr inbounds i8, i8* %1998, i64 8
%2001 = bitcast i8* %2000 to <8 x i8>*
store <8 x i8> %1997, <8 x i8>* %2001
br label %2002
2002: ; preds = %1986, %1989
%2003 = icmp eq i64 %1947, %1937
br i1 %2003, label %4771, label %2004
2004: ; preds = %1939, %1935, %2002
%2005 = phi i64 [ 0, %1939 ], [ 0, %1935 ], [ %1947, %2002 ]
%2006 = xor i64 %2005, -1
%2007 = add nsw i64 %2006, %1937
%2008 = and i64 %1937, 3
%2009 = icmp eq i64 %2008, 0
br i1 %2009, label %2020, label %2010
2010: ; preds = %2004, %2010
%2011 = phi i64 [ %2017, %2010 ], [ %2005, %2004 ]
%2012 = phi i64 [ %2018, %2010 ], [ 0, %2004 ]
%2013 = getelementptr inbounds i16, i16* %1936, i64 %2011
%2014 = load i16, i16* %2013
%2015 = trunc i16 %2014 to i8
%2016 = getelementptr inbounds i8, i8* %2, i64 %2011
store i8 %2015, i8* %2016
%2017 = add nuw nsw i64 %2011, 1
%2018 = add i64 %2012, 1
%2019 = icmp eq i64 %2018, %2008
br i1 %2019, label %2020, label %2010
2020: ; preds = %2010, %2004
%2021 = phi i64 [ %2005, %2004 ], [ %2017, %2010 ]
%2022 = icmp ult i64 %2007, 3
br i1 %2022, label %4771, label %2023
2023: ; preds = %2020, %2023
%2024 = phi i64 [ %2044, %2023 ], [ %2021, %2020 ]
%2025 = getelementptr inbounds i16, i16* %1936, i64 %2024
%2026 = load i16, i16* %2025
%2027 = trunc i16 %2026 to i8
%2028 = getelementptr inbounds i8, i8* %2, i64 %2024
store i8 %2027, i8* %2028
%2029 = add nuw nsw i64 %2024, 1
%2030 = getelementptr inbounds i16, i16* %1936, i64 %2029
%2031 = load i16, i16* %2030
%2032 = trunc i16 %2031 to i8
%2033 = getelementptr inbounds i8, i8* %2, i64 %2029
store i8 %2032, i8* %2033
%2034 = add nuw nsw i64 %2024, 2
%2035 = getelementptr inbounds i16, i16* %1936, i64 %2034
%2036 = load i16, i16* %2035
%2037 = trunc i16 %2036 to i8
%2038 = getelementptr inbounds i8, i8* %2, i64 %2034
store i8 %2037, i8* %2038
%2039 = add nuw nsw i64 %2024, 3
%2040 = getelementptr inbounds i16, i16* %1936, i64 %2039
%2041 = load i16, i16* %2040
%2042 = trunc i16 %2041 to i8
%2043 = getelementptr inbounds i8, i8* %2, i64 %2039
store i8 %2042, i8* %2043
%2044 = add nuw nsw i64 %2024, 4
%2045 = icmp eq i64 %2044, %1937
br i1 %2045, label %4771, label %2023
2046: ; preds = %1930, %2046
%2047 = phi i64 [ %2063, %2046 ], [ %1931, %1930 ]
%2048 = getelementptr inbounds i16, i16* %1825, i64 %2047
%2049 = load i16, i16* %2048
%2050 = getelementptr inbounds i16, i16* %1826, i64 %2047
store i16 %2049, i16* %2050
%2051 = add nuw nsw i64 %2047, 1
%2052 = getelementptr inbounds i16, i16* %1825, i64 %2051
%2053 = load i16, i16* %2052
%2054 = getelementptr inbounds i16, i16* %1826, i64 %2051
store i16 %2053, i16* %2054
%2055 = add nuw nsw i64 %2047, 2
%2056 = getelementptr inbounds i16, i16* %1825, i64 %2055
%2057 = load i16, i16* %2056
%2058 = getelementptr inbounds i16, i16* %1826, i64 %2055
store i16 %2057, i16* %2058
%2059 = add nuw nsw i64 %2047, 3
%2060 = getelementptr inbounds i16, i16* %1825, i64 %2059
%2061 = load i16, i16* %2060
%2062 = getelementptr inbounds i16, i16* %1826, i64 %2059
store i16 %2061, i16* %2062
%2063 = add nuw nsw i64 %2047, 4
%2064 = icmp eq i64 %2063, %1827
br i1 %2064, label %4771, label %2046
2065: ; preds = %1819, %2065
%2066 = phi i64 [ %2082, %2065 ], [ %1820, %1819 ]
%2067 = getelementptr inbounds i16, i16* %1714, i64 %2066
%2068 = load i16, i16* %2067
%2069 = getelementptr inbounds i16, i16* %1715, i64 %2066
store i16 %2068, i16* %2069
%2070 = add nuw nsw i64 %2066, 1
%2071 = getelementptr inbounds i16, i16* %1714, i64 %2070
%2072 = load i16, i16* %2071
%2073 = getelementptr inbounds i16, i16* %1715, i64 %2070
store i16 %2072, i16* %2073
%2074 = add nuw nsw i64 %2066, 2
%2075 = getelementptr inbounds i16, i16* %1714, i64 %2074
%2076 = load i16, i16* %2075
%2077 = getelementptr inbounds i16, i16* %1715, i64 %2074
store i16 %2076, i16* %2077
%2078 = add nuw nsw i64 %2066, 3
%2079 = getelementptr inbounds i16, i16* %1714, i64 %2078
%2080 = load i16, i16* %2079
%2081 = getelementptr inbounds i16, i16* %1715, i64 %2078
store i16 %2080, i16* %2081
%2082 = add nuw nsw i64 %2066, 4
%2083 = icmp eq i64 %2082, %1716
br i1 %2083, label %4771, label %2065
2084: ; preds = %1509, %1509
%2085 = icmp sgt i32 %4, 0
br i1 %2085, label %2086, label %4771
2086: ; preds = %2084
%2087 = bitcast i8* %0 to i16*
%2088 = bitcast i8* %2 to i32*
%2089 = zext i32 %4 to i64
%2090 = icmp ult i32 %4, 8
br i1 %2090, label %2149, label %2091
2091: ; preds = %2086
%2092 = and i64 %2089, 4294967288
%2093 = add nsw i64 %2092, -8
%2094 = lshr exact i64 %2093, 3
%2095 = add nuw nsw i64 %2094, 1
%2096 = and i64 %2095, 1
%2097 = icmp eq i64 %2093, 0
br i1 %2097, label %2131, label %2098
2098: ; preds = %2091
%2099 = and i64 %2095, 4611686018427387902
br label %2100
2100: ; preds = %2100, %2098
%2101 = phi i64 [ 0, %2098 ], [ %2128, %2100 ]
%2102 = phi i64 [ 0, %2098 ], [ %2129, %2100 ]
%2103 = getelementptr inbounds i16, i16* %2087, i64 %2101
%2104 = bitcast i16* %2103 to <4 x i16>*
%2105 = load <4 x i16>, <4 x i16>* %2104
%2106 = getelementptr inbounds i16, i16* %2103, i64 4
%2107 = bitcast i16* %2106 to <4 x i16>*
%2108 = load <4 x i16>, <4 x i16>* %2107
%2109 = zext <4 x i16> %2105 to <4 x i32>
%2110 = zext <4 x i16> %2108 to <4 x i32>
%2111 = getelementptr inbounds i32, i32* %2088, i64 %2101
%2112 = bitcast i32* %2111 to <4 x i32>*
store <4 x i32> %2109, <4 x i32>* %2112
%2113 = getelementptr inbounds i32, i32* %2111, i64 4
%2114 = bitcast i32* %2113 to <4 x i32>*
store <4 x i32> %2110, <4 x i32>* %2114
%2115 = or i64 %2101, 8
%2116 = getelementptr inbounds i16, i16* %2087, i64 %2115
%2117 = bitcast i16* %2116 to <4 x i16>*
%2118 = load <4 x i16>, <4 x i16>* %2117
%2119 = getelementptr inbounds i16, i16* %2116, i64 4
%2120 = bitcast i16* %2119 to <4 x i16>*
%2121 = load <4 x i16>, <4 x i16>* %2120
%2122 = zext <4 x i16> %2118 to <4 x i32>
%2123 = zext <4 x i16> %2121 to <4 x i32>
%2124 = getelementptr inbounds i32, i32* %2088, i64 %2115
%2125 = bitcast i32* %2124 to <4 x i32>*
store <4 x i32> %2122, <4 x i32>* %2125
%2126 = getelementptr inbounds i32, i32* %2124, i64 4
%2127 = bitcast i32* %2126 to <4 x i32>*
store <4 x i32> %2123, <4 x i32>* %2127
%2128 = add nuw i64 %2101, 16
%2129 = add i64 %2102, 2
%2130 = icmp eq i64 %2129, %2099
br i1 %2130, label %2131, label %2100
2131: ; preds = %2100, %2091
%2132 = phi i64 [ 0, %2091 ], [ %2128, %2100 ]
%2133 = icmp eq i64 %2096, 0
br i1 %2133, label %2147, label %2134
2134: ; preds = %2131
%2135 = getelementptr inbounds i16, i16* %2087, i64 %2132
%2136 = bitcast i16* %2135 to <4 x i16>*
%2137 = load <4 x i16>, <4 x i16>* %2136
%2138 = getelementptr inbounds i16, i16* %2135, i64 4
%2139 = bitcast i16* %2138 to <4 x i16>*
%2140 = load <4 x i16>, <4 x i16>* %2139
%2141 = zext <4 x i16> %2137 to <4 x i32>
%2142 = zext <4 x i16> %2140 to <4 x i32>
%2143 = getelementptr inbounds i32, i32* %2088, i64 %2132
%2144 = bitcast i32* %2143 to <4 x i32>*
store <4 x i32> %2141, <4 x i32>* %2144
%2145 = getelementptr inbounds i32, i32* %2143, i64 4
%2146 = bitcast i32* %2145 to <4 x i32>*
store <4 x i32> %2142, <4 x i32>* %2146
br label %2147
2147: ; preds = %2131, %2134
%2148 = icmp eq i64 %2092, %2089
br i1 %2148, label %4771, label %2149
2149: ; preds = %2086, %2147
%2150 = phi i64 [ 0, %2086 ], [ %2092, %2147 ]
br label %2151
2151: ; preds = %2149, %2151
%2152 = phi i64 [ %2157, %2151 ], [ %2150, %2149 ]
%2153 = getelementptr inbounds i16, i16* %2087, i64 %2152
%2154 = load i16, i16* %2153
%2155 = zext i16 %2154 to i32
%2156 = getelementptr inbounds i32, i32* %2088, i64 %2152
store i32 %2155, i32* %2156
%2157 = add nuw nsw i64 %2152, 1
%2158 = icmp eq i64 %2157, %2089
br i1 %2158, label %4771, label %2151
2159: ; preds = %1709, %2159
%2160 = phi i64 [ %2165, %2159 ], [ %1710, %1709 ]
%2161 = getelementptr inbounds i16, i16* %1647, i64 %2160
%2162 = load i16, i16* %2161
%2163 = zext i16 %2162 to i32
%2164 = getelementptr inbounds i32, i32* %1648, i64 %2160
store i32 %2163, i32* %2164
%2165 = add nuw nsw i64 %2160, 1
%2166 = icmp eq i64 %2165, %1649
br i1 %2166, label %4771, label %2159
2167: ; preds = %1642, %2167
%2168 = phi i64 [ %2173, %2167 ], [ %1643, %1642 ]
%2169 = getelementptr inbounds i16, i16* %1580, i64 %2168
%2170 = load i16, i16* %2169
%2171 = uitofp i16 %2170 to float
%2172 = getelementptr inbounds float, float* %1581, i64 %2168
store float %2171, float* %2172
%2173 = add nuw nsw i64 %2168, 1
%2174 = icmp eq i64 %2173, %1582
br i1 %2174, label %4771, label %2167
2175: ; preds = %1575, %2175
%2176 = phi i64 [ %2181, %2175 ], [ %1576, %1575 ]
%2177 = getelementptr inbounds i16, i16* %1513, i64 %2176
%2178 = load i16, i16* %2177
%2179 = uitofp i16 %2178 to double
%2180 = getelementptr inbounds double, double* %1514, i64 %2176
store double %2179, double* %2180
%2181 = add nuw nsw i64 %2176, 1
%2182 = icmp eq i64 %2181, %1515
br i1 %2182, label %4771, label %2175
2183: ; preds = %8, %8
switch i32 %6, label %4771 [
i32 99, label %2563
i32 115, label %2496
i32 117, label %2429
i32 105, label %2692
i32 83, label %2692
i32 85, label %2318
i32 102, label %2251
i32 100, label %2184
]
2184: ; preds = %2183
%2185 = icmp sgt i32 %4, 0
br i1 %2185, label %2186, label %4771
2186: ; preds = %2184
%2187 = bitcast i8* %0 to i32*
%2188 = bitcast i8* %2 to double*
%2189 = zext i32 %4 to i64
%2190 = icmp ult i32 %4, 4
br i1 %2190, label %2249, label %2191
2191: ; preds = %2186
%2192 = and i64 %2189, 4294967292
%2193 = add nsw i64 %2192, -4
%2194 = lshr exact i64 %2193, 2
%2195 = add nuw nsw i64 %2194, 1
%2196 = and i64 %2195, 1
%2197 = icmp eq i64 %2193, 0
br i1 %2197, label %2231, label %2198
2198: ; preds = %2191
%2199 = and i64 %2195, 9223372036854775806
br label %2200
2200: ; preds = %2200, %2198
%2201 = phi i64 [ 0, %2198 ], [ %2228, %2200 ]
%2202 = phi i64 [ 0, %2198 ], [ %2229, %2200 ]
%2203 = getelementptr inbounds i32, i32* %2187, i64 %2201
%2204 = bitcast i32* %2203 to <2 x i32>*
%2205 = load <2 x i32>, <2 x i32>* %2204
%2206 = getelementptr inbounds i32, i32* %2203, i64 2
%2207 = bitcast i32* %2206 to <2 x i32>*
%2208 = load <2 x i32>, <2 x i32>* %2207
%2209 = sitofp <2 x i32> %2205 to <2 x double>
%2210 = sitofp <2 x i32> %2208 to <2 x double>
%2211 = getelementptr inbounds double, double* %2188, i64 %2201
%2212 = bitcast double* %2211 to <2 x double>*
store <2 x double> %2209, <2 x double>* %2212
%2213 = getelementptr inbounds double, double* %2211, i64 2
%2214 = bitcast double* %2213 to <2 x double>*
store <2 x double> %2210, <2 x double>* %2214
%2215 = or i64 %2201, 4
%2216 = getelementptr inbounds i32, i32* %2187, i64 %2215
%2217 = bitcast i32* %2216 to <2 x i32>*
%2218 = load <2 x i32>, <2 x i32>* %2217
%2219 = getelementptr inbounds i32, i32* %2216, i64 2
%2220 = bitcast i32* %2219 to <2 x i32>*
%2221 = load <2 x i32>, <2 x i32>* %2220
%2222 = sitofp <2 x i32> %2218 to <2 x double>
%2223 = sitofp <2 x i32> %2221 to <2 x double>
%2224 = getelementptr inbounds double, double* %2188, i64 %2215
%2225 = bitcast double* %2224 to <2 x double>*
store <2 x double> %2222, <2 x double>* %2225
%2226 = getelementptr inbounds double, double* %2224, i64 2
%2227 = bitcast double* %2226 to <2 x double>*
store <2 x double> %2223, <2 x double>* %2227
%2228 = add nuw i64 %2201, 8
%2229 = add i64 %2202, 2
%2230 = icmp eq i64 %2229, %2199
br i1 %2230, label %2231, label %2200
2231: ; preds = %2200, %2191
%2232 = phi i64 [ 0, %2191 ], [ %2228, %2200 ]
%2233 = icmp eq i64 %2196, 0
br i1 %2233, label %2247, label %2234
2234: ; preds = %2231
%2235 = getelementptr inbounds i32, i32* %2187, i64 %2232
%2236 = bitcast i32* %2235 to <2 x i32>*
%2237 = load <2 x i32>, <2 x i32>* %2236
%2238 = getelementptr inbounds i32, i32* %2235, i64 2
%2239 = bitcast i32* %2238 to <2 x i32>*
%2240 = load <2 x i32>, <2 x i32>* %2239
%2241 = sitofp <2 x i32> %2237 to <2 x double>
%2242 = sitofp <2 x i32> %2240 to <2 x double>
%2243 = getelementptr inbounds double, double* %2188, i64 %2232
%2244 = bitcast double* %2243 to <2 x double>*
store <2 x double> %2241, <2 x double>* %2244
%2245 = getelementptr inbounds double, double* %2243, i64 2
%2246 = bitcast double* %2245 to <2 x double>*
store <2 x double> %2242, <2 x double>* %2246
br label %2247
2247: ; preds = %2231, %2234
%2248 = icmp eq i64 %2192, %2189
br i1 %2248, label %4771, label %2249
2249: ; preds = %2186, %2247
%2250 = phi i64 [ 0, %2186 ], [ %2192, %2247 ]
br label %2849
2251: ; preds = %2183
%2252 = icmp sgt i32 %4, 0
br i1 %2252, label %2253, label %4771
2253: ; preds = %2251
%2254 = bitcast i8* %0 to i32*
%2255 = bitcast i8* %2 to float*
%2256 = zext i32 %4 to i64
%2257 = icmp ult i32 %4, 8
br i1 %2257, label %2316, label %2258
2258: ; preds = %2253
%2259 = and i64 %2256, 4294967288
%2260 = add nsw i64 %2259, -8
%2261 = lshr exact i64 %2260, 3
%2262 = add nuw nsw i64 %2261, 1
%2263 = and i64 %2262, 1
%2264 = icmp eq i64 %2260, 0
br i1 %2264, label %2298, label %2265
2265: ; preds = %2258
%2266 = and i64 %2262, 4611686018427387902
br label %2267
2267: ; preds = %2267, %2265
%2268 = phi i64 [ 0, %2265 ], [ %2295, %2267 ]
%2269 = phi i64 [ 0, %2265 ], [ %2296, %2267 ]
%2270 = getelementptr inbounds i32, i32* %2254, i64 %2268
%2271 = bitcast i32* %2270 to <4 x i32>*
%2272 = load <4 x i32>, <4 x i32>* %2271
%2273 = getelementptr inbounds i32, i32* %2270, i64 4
%2274 = bitcast i32* %2273 to <4 x i32>*
%2275 = load <4 x i32>, <4 x i32>* %2274
%2276 = sitofp <4 x i32> %2272 to <4 x float>
%2277 = sitofp <4 x i32> %2275 to <4 x float>
%2278 = getelementptr inbounds float, float* %2255, i64 %2268
%2279 = bitcast float* %2278 to <4 x float>*
store <4 x float> %2276, <4 x float>* %2279
%2280 = getelementptr inbounds float, float* %2278, i64 4
%2281 = bitcast float* %2280 to <4 x float>*
store <4 x float> %2277, <4 x float>* %2281
%2282 = or i64 %2268, 8
%2283 = getelementptr inbounds i32, i32* %2254, i64 %2282
%2284 = bitcast i32* %2283 to <4 x i32>*
%2285 = load <4 x i32>, <4 x i32>* %2284
%2286 = getelementptr inbounds i32, i32* %2283, i64 4
%2287 = bitcast i32* %2286 to <4 x i32>*
%2288 = load <4 x i32>, <4 x i32>* %2287
%2289 = sitofp <4 x i32> %2285 to <4 x float>
%2290 = sitofp <4 x i32> %2288 to <4 x float>
%2291 = getelementptr inbounds float, float* %2255, i64 %2282
%2292 = bitcast float* %2291 to <4 x float>*
store <4 x float> %2289, <4 x float>* %2292
%2293 = getelementptr inbounds float, float* %2291, i64 4
%2294 = bitcast float* %2293 to <4 x float>*
store <4 x float> %2290, <4 x float>* %2294
%2295 = add nuw i64 %2268, 16
%2296 = add i64 %2269, 2
%2297 = icmp eq i64 %2296, %2266
br i1 %2297, label %2298, label %2267
2298: ; preds = %2267, %2258
%2299 = phi i64 [ 0, %2258 ], [ %2295, %2267 ]
%2300 = icmp eq i64 %2263, 0
br i1 %2300, label %2314, label %2301
2301: ; preds = %2298
%2302 = getelementptr inbounds i32, i32* %2254, i64 %2299
%2303 = bitcast i32* %2302 to <4 x i32>*
%2304 = load <4 x i32>, <4 x i32>* %2303
%2305 = getelementptr inbounds i32, i32* %2302, i64 4
%2306 = bitcast i32* %2305 to <4 x i32>*
%2307 = load <4 x i32>, <4 x i32>* %2306
%2308 = sitofp <4 x i32> %2304 to <4 x float>
%2309 = sitofp <4 x i32> %2307 to <4 x float>
%2310 = getelementptr inbounds float, float* %2255, i64 %2299
%2311 = bitcast float* %2310 to <4 x float>*
store <4 x float> %2308, <4 x float>* %2311
%2312 = getelementptr inbounds float, float* %2310, i64 4
%2313 = bitcast float* %2312 to <4 x float>*
store <4 x float> %2309, <4 x float>* %2313
br label %2314
2314: ; preds = %2298, %2301
%2315 = icmp eq i64 %2259, %2256
br i1 %2315, label %4771, label %2316
2316: ; preds = %2253, %2314
%2317 = phi i64 [ 0, %2253 ], [ %2259, %2314 ]
br label %2841
2318: ; preds = %2183
%2319 = icmp sgt i32 %4, 0
br i1 %2319, label %2320, label %4771
2320: ; preds = %2318
%2321 = bitcast i8* %0 to i32*
%2322 = bitcast i8* %2 to i32*
%2323 = zext i32 %4 to i64
%2324 = icmp ult i32 %4, 8
br i1 %2324, label %2411, label %2325
2325: ; preds = %2320
%2326 = shl nuw nsw i64 %2323, 2
%2327 = getelementptr i8, i8* %2, i64 %2326
%2328 = getelementptr i8, i8* %0, i64 %2326
%2329 = icmp ugt i8* %2328, %2
%2330 = icmp ugt i8* %2327, %0
%2331 = and i1 %2329, %2330
br i1 %2331, label %2411, label %2332
2332: ; preds = %2325
%2333 = and i64 %2323, 4294967288
%2334 = add nsw i64 %2333, -8
%2335 = lshr exact i64 %2334, 3
%2336 = add nuw nsw i64 %2335, 1
%2337 = and i64 %2336, 3
%2338 = icmp ult i64 %2334, 24
br i1 %2338, label %2390, label %2339
2339: ; preds = %2332
%2340 = and i64 %2336, 4611686018427387900
br label %2341
2341: ; preds = %2341, %2339
%2342 = phi i64 [ 0, %2339 ], [ %2387, %2341 ]
%2343 = phi i64 [ 0, %2339 ], [ %2388, %2341 ]
%2344 = getelementptr inbounds i32, i32* %2321, i64 %2342
%2345 = bitcast i32* %2344 to <4 x i32>*
%2346 = load <4 x i32>, <4 x i32>* %2345
%2347 = getelementptr inbounds i32, i32* %2344, i64 4
%2348 = bitcast i32* %2347 to <4 x i32>*
%2349 = load <4 x i32>, <4 x i32>* %2348
%2350 = getelementptr inbounds i32, i32* %2322, i64 %2342
%2351 = bitcast i32* %2350 to <4 x i32>*
store <4 x i32> %2346, <4 x i32>* %2351
%2352 = getelementptr inbounds i32, i32* %2350, i64 4
%2353 = bitcast i32* %2352 to <4 x i32>*
store <4 x i32> %2349, <4 x i32>* %2353
%2354 = or i64 %2342, 8
%2355 = getelementptr inbounds i32, i32* %2321, i64 %2354
%2356 = bitcast i32* %2355 to <4 x i32>*
%2357 = load <4 x i32>, <4 x i32>* %2356
%2358 = getelementptr inbounds i32, i32* %2355, i64 4
%2359 = bitcast i32* %2358 to <4 x i32>*
%2360 = load <4 x i32>, <4 x i32>* %2359
%2361 = getelementptr inbounds i32, i32* %2322, i64 %2354
%2362 = bitcast i32* %2361 to <4 x i32>*
store <4 x i32> %2357, <4 x i32>* %2362
%2363 = getelementptr inbounds i32, i32* %2361, i64 4
%2364 = bitcast i32* %2363 to <4 x i32>*
store <4 x i32> %2360, <4 x i32>* %2364
%2365 = or i64 %2342, 16
%2366 = getelementptr inbounds i32, i32* %2321, i64 %2365
%2367 = bitcast i32* %2366 to <4 x i32>*
%2368 = load <4 x i32>, <4 x i32>* %2367
%2369 = getelementptr inbounds i32, i32* %2366, i64 4
%2370 = bitcast i32* %2369 to <4 x i32>*
%2371 = load <4 x i32>, <4 x i32>* %2370
%2372 = getelementptr inbounds i32, i32* %2322, i64 %2365
%2373 = bitcast i32* %2372 to <4 x i32>*
store <4 x i32> %2368, <4 x i32>* %2373
%2374 = getelementptr inbounds i32, i32* %2372, i64 4
%2375 = bitcast i32* %2374 to <4 x i32>*
store <4 x i32> %2371, <4 x i32>* %2375
%2376 = or i64 %2342, 24
%2377 = getelementptr inbounds i32, i32* %2321, i64 %2376
%2378 = bitcast i32* %2377 to <4 x i32>*
%2379 = load <4 x i32>, <4 x i32>* %2378
%2380 = getelementptr inbounds i32, i32* %2377, i64 4
%2381 = bitcast i32* %2380 to <4 x i32>*
%2382 = load <4 x i32>, <4 x i32>* %2381
%2383 = getelementptr inbounds i32, i32* %2322, i64 %2376
%2384 = bitcast i32* %2383 to <4 x i32>*
store <4 x i32> %2379, <4 x i32>* %2384
%2385 = getelementptr inbounds i32, i32* %2383, i64 4
%2386 = bitcast i32* %2385 to <4 x i32>*
store <4 x i32> %2382, <4 x i32>* %2386
%2387 = add nuw i64 %2342, 32
%2388 = add i64 %2343, 4
%2389 = icmp eq i64 %2388, %2340
br i1 %2389, label %2390, label %2341
2390: ; preds = %2341, %2332
%2391 = phi i64 [ 0, %2332 ], [ %2387, %2341 ]
%2392 = icmp eq i64 %2337, 0
br i1 %2392, label %2409, label %2393
2393: ; preds = %2390, %2393
%2394 = phi i64 [ %2406, %2393 ], [ %2391, %2390 ]
%2395 = phi i64 [ %2407, %2393 ], [ 0, %2390 ]
%2396 = getelementptr inbounds i32, i32* %2321, i64 %2394
%2397 = bitcast i32* %2396 to <4 x i32>*
%2398 = load <4 x i32>, <4 x i32>* %2397
%2399 = getelementptr inbounds i32, i32* %2396, i64 4
%2400 = bitcast i32* %2399 to <4 x i32>*
%2401 = load <4 x i32>, <4 x i32>* %2400
%2402 = getelementptr inbounds i32, i32* %2322, i64 %2394
%2403 = bitcast i32* %2402 to <4 x i32>*
store <4 x i32> %2398, <4 x i32>* %2403
%2404 = getelementptr inbounds i32, i32* %2402, i64 4
%2405 = bitcast i32* %2404 to <4 x i32>*
store <4 x i32> %2401, <4 x i32>* %2405
%2406 = add nuw i64 %2394, 8
%2407 = add i64 %2395, 1
%2408 = icmp eq i64 %2407, %2337
br i1 %2408, label %2409, label %2393
2409: ; preds = %2393, %2390
%2410 = icmp eq i64 %2333, %2323
br i1 %2410, label %4771, label %2411
2411: ; preds = %2325, %2320, %2409
%2412 = phi i64 [ 0, %2325 ], [ 0, %2320 ], [ %2333, %2409 ]
%2413 = xor i64 %2412, -1
%2414 = add nsw i64 %2413, %2323
%2415 = and i64 %2323, 3
%2416 = icmp eq i64 %2415, 0
br i1 %2416, label %2426, label %2417
2417: ; preds = %2411, %2417
%2418 = phi i64 [ %2423, %2417 ], [ %2412, %2411 ]
%2419 = phi i64 [ %2424, %2417 ], [ 0, %2411 ]
%2420 = getelementptr inbounds i32, i32* %2321, i64 %2418
%2421 = load i32, i32* %2420
%2422 = getelementptr inbounds i32, i32* %2322, i64 %2418
store i32 %2421, i32* %2422
%2423 = add nuw nsw i64 %2418, 1
%2424 = add i64 %2419, 1
%2425 = icmp eq i64 %2424, %2415
br i1 %2425, label %2426, label %2417
2426: ; preds = %2417, %2411
%2427 = phi i64 [ %2412, %2411 ], [ %2423, %2417 ]
%2428 = icmp ult i64 %2414, 3
br i1 %2428, label %4771, label %2822
2429: ; preds = %2183
%2430 = icmp sgt i32 %4, 0
br i1 %2430, label %2431, label %4771
2431: ; preds = %2429
%2432 = bitcast i8* %0 to i32*
%2433 = bitcast i8* %2 to i16*
%2434 = zext i32 %4 to i64
%2435 = icmp ult i32 %4, 8
br i1 %2435, label %2494, label %2436
2436: ; preds = %2431
%2437 = and i64 %2434, 4294967288
%2438 = add nsw i64 %2437, -8
%2439 = lshr exact i64 %2438, 3
%2440 = add nuw nsw i64 %2439, 1
%2441 = and i64 %2440, 1
%2442 = icmp eq i64 %2438, 0
br i1 %2442, label %2476, label %2443
2443: ; preds = %2436
%2444 = and i64 %2440, 4611686018427387902
br label %2445
2445: ; preds = %2445, %2443
%2446 = phi i64 [ 0, %2443 ], [ %2473, %2445 ]
%2447 = phi i64 [ 0, %2443 ], [ %2474, %2445 ]
%2448 = getelementptr inbounds i32, i32* %2432, i64 %2446
%2449 = bitcast i32* %2448 to <4 x i32>*
%2450 = load <4 x i32>, <4 x i32>* %2449
%2451 = getelementptr inbounds i32, i32* %2448, i64 4
%2452 = bitcast i32* %2451 to <4 x i32>*
%2453 = load <4 x i32>, <4 x i32>* %2452
%2454 = trunc <4 x i32> %2450 to <4 x i16>
%2455 = trunc <4 x i32> %2453 to <4 x i16>
%2456 = getelementptr inbounds i16, i16* %2433, i64 %2446
%2457 = bitcast i16* %2456 to <4 x i16>*
store <4 x i16> %2454, <4 x i16>* %2457
%2458 = getelementptr inbounds i16, i16* %2456, i64 4
%2459 = bitcast i16* %2458 to <4 x i16>*
store <4 x i16> %2455, <4 x i16>* %2459
%2460 = or i64 %2446, 8
%2461 = getelementptr inbounds i32, i32* %2432, i64 %2460
%2462 = bitcast i32* %2461 to <4 x i32>*
%2463 = load <4 x i32>, <4 x i32>* %2462
%2464 = getelementptr inbounds i32, i32* %2461, i64 4
%2465 = bitcast i32* %2464 to <4 x i32>*
%2466 = load <4 x i32>, <4 x i32>* %2465
%2467 = trunc <4 x i32> %2463 to <4 x i16>
%2468 = trunc <4 x i32> %2466 to <4 x i16>
%2469 = getelementptr inbounds i16, i16* %2433, i64 %2460
%2470 = bitcast i16* %2469 to <4 x i16>*
store <4 x i16> %2467, <4 x i16>* %2470
%2471 = getelementptr inbounds i16, i16* %2469, i64 4
%2472 = bitcast i16* %2471 to <4 x i16>*
store <4 x i16> %2468, <4 x i16>* %2472
%2473 = add nuw i64 %2446, 16
%2474 = add i64 %2447, 2
%2475 = icmp eq i64 %2474, %2444
br i1 %2475, label %2476, label %2445
2476: ; preds = %2445, %2436
%2477 = phi i64 [ 0, %2436 ], [ %2473, %2445 ]
%2478 = icmp eq i64 %2441, 0
br i1 %2478, label %2492, label %2479
2479: ; preds = %2476
%2480 = getelementptr inbounds i32, i32* %2432, i64 %2477
%2481 = bitcast i32* %2480 to <4 x i32>*
%2482 = load <4 x i32>, <4 x i32>* %2481
%2483 = getelementptr inbounds i32, i32* %2480, i64 4
%2484 = bitcast i32* %2483 to <4 x i32>*
%2485 = load <4 x i32>, <4 x i32>* %2484
%2486 = trunc <4 x i32> %2482 to <4 x i16>
%2487 = trunc <4 x i32> %2485 to <4 x i16>
%2488 = getelementptr inbounds i16, i16* %2433, i64 %2477
%2489 = bitcast i16* %2488 to <4 x i16>*
store <4 x i16> %2486, <4 x i16>* %2489
%2490 = getelementptr inbounds i16, i16* %2488, i64 4
%2491 = bitcast i16* %2490 to <4 x i16>*
store <4 x i16> %2487, <4 x i16>* %2491
br label %2492
2492: ; preds = %2476, %2479
%2493 = icmp eq i64 %2437, %2434
br i1 %2493, label %4771, label %2494
2494: ; preds = %2431, %2492
%2495 = phi i64 [ 0, %2431 ], [ %2437, %2492 ]
br label %2684
2496: ; preds = %2183
%2497 = icmp sgt i32 %4, 0
br i1 %2497, label %2498, label %4771
2498: ; preds = %2496
%2499 = bitcast i8* %0 to i32*
%2500 = bitcast i8* %2 to i16*
%2501 = zext i32 %4 to i64
%2502 = icmp ult i32 %4, 8
br i1 %2502, label %2561, label %2503
2503: ; preds = %2498
%2504 = and i64 %2501, 4294967288
%2505 = add nsw i64 %2504, -8
%2506 = lshr exact i64 %2505, 3
%2507 = add nuw nsw i64 %2506, 1
%2508 = and i64 %2507, 1
%2509 = icmp eq i64 %2505, 0
br i1 %2509, label %2543, label %2510
2510: ; preds = %2503
%2511 = and i64 %2507, 4611686018427387902
br label %2512
2512: ; preds = %2512, %2510
%2513 = phi i64 [ 0, %2510 ], [ %2540, %2512 ]
%2514 = phi i64 [ 0, %2510 ], [ %2541, %2512 ]
%2515 = getelementptr inbounds i32, i32* %2499, i64 %2513
%2516 = bitcast i32* %2515 to <4 x i32>*
%2517 = load <4 x i32>, <4 x i32>* %2516
%2518 = getelementptr inbounds i32, i32* %2515, i64 4
%2519 = bitcast i32* %2518 to <4 x i32>*
%2520 = load <4 x i32>, <4 x i32>* %2519
%2521 = trunc <4 x i32> %2517 to <4 x i16>
%2522 = trunc <4 x i32> %2520 to <4 x i16>
%2523 = getelementptr inbounds i16, i16* %2500, i64 %2513
%2524 = bitcast i16* %2523 to <4 x i16>*
store <4 x i16> %2521, <4 x i16>* %2524
%2525 = getelementptr inbounds i16, i16* %2523, i64 4
%2526 = bitcast i16* %2525 to <4 x i16>*
store <4 x i16> %2522, <4 x i16>* %2526
%2527 = or i64 %2513, 8
%2528 = getelementptr inbounds i32, i32* %2499, i64 %2527
%2529 = bitcast i32* %2528 to <4 x i32>*
%2530 = load <4 x i32>, <4 x i32>* %2529
%2531 = getelementptr inbounds i32, i32* %2528, i64 4
%2532 = bitcast i32* %2531 to <4 x i32>*
%2533 = load <4 x i32>, <4 x i32>* %2532
%2534 = trunc <4 x i32> %2530 to <4 x i16>
%2535 = trunc <4 x i32> %2533 to <4 x i16>
%2536 = getelementptr inbounds i16, i16* %2500, i64 %2527
%2537 = bitcast i16* %2536 to <4 x i16>*
store <4 x i16> %2534, <4 x i16>* %2537
%2538 = getelementptr inbounds i16, i16* %2536, i64 4
%2539 = bitcast i16* %2538 to <4 x i16>*
store <4 x i16> %2535, <4 x i16>* %2539
%2540 = add nuw i64 %2513, 16
%2541 = add i64 %2514, 2
%2542 = icmp eq i64 %2541, %2511
br i1 %2542, label %2543, label %2512
2543: ; preds = %2512, %2503
%2544 = phi i64 [ 0, %2503 ], [ %2540, %2512 ]
%2545 = icmp eq i64 %2508, 0
br i1 %2545, label %2559, label %2546
2546: ; preds = %2543
%2547 = getelementptr inbounds i32, i32* %2499, i64 %2544
%2548 = bitcast i32* %2547 to <4 x i32>*
%2549 = load <4 x i32>, <4 x i32>* %2548
%2550 = getelementptr inbounds i32, i32* %2547, i64 4
%2551 = bitcast i32* %2550 to <4 x i32>*
%2552 = load <4 x i32>, <4 x i32>* %2551
%2553 = trunc <4 x i32> %2549 to <4 x i16>
%2554 = trunc <4 x i32> %2552 to <4 x i16>
%2555 = getelementptr inbounds i16, i16* %2500, i64 %2544
%2556 = bitcast i16* %2555 to <4 x i16>*
store <4 x i16> %2553, <4 x i16>* %2556
%2557 = getelementptr inbounds i16, i16* %2555, i64 4
%2558 = bitcast i16* %2557 to <4 x i16>*
store <4 x i16> %2554, <4 x i16>* %2558
br label %2559
2559: ; preds = %2543, %2546
%2560 = icmp eq i64 %2504, %2501
br i1 %2560, label %4771, label %2561
2561: ; preds = %2498, %2559
%2562 = phi i64 [ 0, %2498 ], [ %2504, %2559 ]
br label %2676
2563: ; preds = %2183
%2564 = icmp sgt i32 %4, 0
br i1 %2564, label %2565, label %4771
2565: ; preds = %2563
%2566 = bitcast i8* %0 to i32*
%2567 = zext i32 %4 to i64
%2568 = icmp ult i32 %4, 8
br i1 %2568, label %2634, label %2569
2569: ; preds = %2565
%2570 = getelementptr i8, i8* %2, i64 %2567
%2571 = shl nuw nsw i64 %2567, 2
%2572 = getelementptr i8, i8* %0, i64 %2571
%2573 = icmp ugt i8* %2572, %2
%2574 = icmp ugt i8* %2570, %0
%2575 = and i1 %2573, %2574
br i1 %2575, label %2634, label %2576
2576: ; preds = %2569
%2577 = and i64 %2567, 4294967288
%2578 = add nsw i64 %2577, -8
%2579 = lshr exact i64 %2578, 3
%2580 = add nuw nsw i64 %2579, 1
%2581 = and i64 %2580, 1
%2582 = icmp eq i64 %2578, 0
br i1 %2582, label %2616, label %2583
2583: ; preds = %2576
%2584 = and i64 %2580, 4611686018427387902
br label %2585
2585: ; preds = %2585, %2583
%2586 = phi i64 [ 0, %2583 ], [ %2613, %2585 ]
%2587 = phi i64 [ 0, %2583 ], [ %2614, %2585 ]
%2588 = getelementptr inbounds i32, i32* %2566, i64 %2586
%2589 = bitcast i32* %2588 to <4 x i32>*
%2590 = load <4 x i32>, <4 x i32>* %2589
%2591 = getelementptr inbounds i32, i32* %2588, i64 4
%2592 = bitcast i32* %2591 to <4 x i32>*
%2593 = load <4 x i32>, <4 x i32>* %2592
%2594 = trunc <4 x i32> %2590 to <4 x i8>
%2595 = trunc <4 x i32> %2593 to <4 x i8>
%2596 = getelementptr inbounds i8, i8* %2, i64 %2586
%2597 = bitcast i8* %2596 to <4 x i8>*
store <4 x i8> %2594, <4 x i8>* %2597
%2598 = getelementptr inbounds i8, i8* %2596, i64 4
%2599 = bitcast i8* %2598 to <4 x i8>*
store <4 x i8> %2595, <4 x i8>* %2599
%2600 = or i64 %2586, 8
%2601 = getelementptr inbounds i32, i32* %2566, i64 %2600
%2602 = bitcast i32* %2601 to <4 x i32>*
%2603 = load <4 x i32>, <4 x i32>* %2602
%2604 = getelementptr inbounds i32, i32* %2601, i64 4
%2605 = bitcast i32* %2604 to <4 x i32>*
%2606 = load <4 x i32>, <4 x i32>* %2605
%2607 = trunc <4 x i32> %2603 to <4 x i8>
%2608 = trunc <4 x i32> %2606 to <4 x i8>
%2609 = getelementptr inbounds i8, i8* %2, i64 %2600
%2610 = bitcast i8* %2609 to <4 x i8>*
store <4 x i8> %2607, <4 x i8>* %2610
%2611 = getelementptr inbounds i8, i8* %2609, i64 4
%2612 = bitcast i8* %2611 to <4 x i8>*
store <4 x i8> %2608, <4 x i8>* %2612
%2613 = add nuw i64 %2586, 16
%2614 = add i64 %2587, 2
%2615 = icmp eq i64 %2614, %2584
br i1 %2615, label %2616, label %2585
2616: ; preds = %2585, %2576
%2617 = phi i64 [ 0, %2576 ], [ %2613, %2585 ]
%2618 = icmp eq i64 %2581, 0
br i1 %2618, label %2632, label %2619
2619: ; preds = %2616
%2620 = getelementptr inbounds i32, i32* %2566, i64 %2617
%2621 = bitcast i32* %2620 to <4 x i32>*
%2622 = load <4 x i32>, <4 x i32>* %2621
%2623 = getelementptr inbounds i32, i32* %2620, i64 4
%2624 = bitcast i32* %2623 to <4 x i32>*
%2625 = load <4 x i32>, <4 x i32>* %2624
%2626 = trunc <4 x i32> %2622 to <4 x i8>
%2627 = trunc <4 x i32> %2625 to <4 x i8>
%2628 = getelementptr inbounds i8, i8* %2, i64 %2617
%2629 = bitcast i8* %2628 to <4 x i8>*
store <4 x i8> %2626, <4 x i8>* %2629
%2630 = getelementptr inbounds i8, i8* %2628, i64 4
%2631 = bitcast i8* %2630 to <4 x i8>*
store <4 x i8> %2627, <4 x i8>* %2631
br label %2632
2632: ; preds = %2616, %2619
%2633 = icmp eq i64 %2577, %2567
br i1 %2633, label %4771, label %2634
2634: ; preds = %2569, %2565, %2632
%2635 = phi i64 [ 0, %2569 ], [ 0, %2565 ], [ %2577, %2632 ]
%2636 = xor i64 %2635, -1
%2637 = add nsw i64 %2636, %2567
%2638 = and i64 %2567, 3
%2639 = icmp eq i64 %2638, 0
br i1 %2639, label %2650, label %2640
2640: ; preds = %2634, %2640
%2641 = phi i64 [ %2647, %2640 ], [ %2635, %2634 ]
%2642 = phi i64 [ %2648, %2640 ], [ 0, %2634 ]
%2643 = getelementptr inbounds i32, i32* %2566, i64 %2641
%2644 = load i32, i32* %2643
%2645 = trunc i32 %2644 to i8
%2646 = getelementptr inbounds i8, i8* %2, i64 %2641
store i8 %2645, i8* %2646
%2647 = add nuw nsw i64 %2641, 1
%2648 = add i64 %2642, 1
%2649 = icmp eq i64 %2648, %2638
br i1 %2649, label %2650, label %2640
2650: ; preds = %2640, %2634
%2651 = phi i64 [ %2635, %2634 ], [ %2647, %2640 ]
%2652 = icmp ult i64 %2637, 3
br i1 %2652, label %4771, label %2653
2653: ; preds = %2650, %2653
%2654 = phi i64 [ %2674, %2653 ], [ %2651, %2650 ]
%2655 = getelementptr inbounds i32, i32* %2566, i64 %2654
%2656 = load i32, i32* %2655
%2657 = trunc i32 %2656 to i8
%2658 = getelementptr inbounds i8, i8* %2, i64 %2654
store i8 %2657, i8* %2658
%2659 = add nuw nsw i64 %2654, 1
%2660 = getelementptr inbounds i32, i32* %2566, i64 %2659
%2661 = load i32, i32* %2660
%2662 = trunc i32 %2661 to i8
%2663 = getelementptr inbounds i8, i8* %2, i64 %2659
store i8 %2662, i8* %2663
%2664 = add nuw nsw i64 %2654, 2
%2665 = getelementptr inbounds i32, i32* %2566, i64 %2664
%2666 = load i32, i32* %2665
%2667 = trunc i32 %2666 to i8
%2668 = getelementptr inbounds i8, i8* %2, i64 %2664
store i8 %2667, i8* %2668
%2669 = add nuw nsw i64 %2654, 3
%2670 = getelementptr inbounds i32, i32* %2566, i64 %2669
%2671 = load i32, i32* %2670
%2672 = trunc i32 %2671 to i8
%2673 = getelementptr inbounds i8, i8* %2, i64 %2669
store i8 %2672, i8* %2673
%2674 = add nuw nsw i64 %2654, 4
%2675 = icmp eq i64 %2674, %2567
br i1 %2675, label %4771, label %2653
2676: ; preds = %2561, %2676
%2677 = phi i64 [ %2682, %2676 ], [ %2562, %2561 ]
%2678 = getelementptr inbounds i32, i32* %2499, i64 %2677
%2679 = load i32, i32* %2678
%2680 = trunc i32 %2679 to i16
%2681 = getelementptr inbounds i16, i16* %2500, i64 %2677
store i16 %2680, i16* %2681
%2682 = add nuw nsw i64 %2677, 1
%2683 = icmp eq i64 %2682, %2501
br i1 %2683, label %4771, label %2676
2684: ; preds = %2494, %2684
%2685 = phi i64 [ %2690, %2684 ], [ %2495, %2494 ]
%2686 = getelementptr inbounds i32, i32* %2432, i64 %2685
%2687 = load i32, i32* %2686
%2688 = trunc i32 %2687 to i16
%2689 = getelementptr inbounds i16, i16* %2433, i64 %2685
store i16 %2688, i16* %2689
%2690 = add nuw nsw i64 %2685, 1
%2691 = icmp eq i64 %2690, %2434
br i1 %2691, label %4771, label %2684
2692: ; preds = %2183, %2183
%2693 = icmp sgt i32 %4, 0
br i1 %2693, label %2694, label %4771
2694: ; preds = %2692
%2695 = bitcast i8* %0 to i32*
%2696 = bitcast i8* %2 to i32*
%2697 = zext i32 %4 to i64
%2698 = icmp ult i32 %4, 8
br i1 %2698, label %2785, label %2699
2699: ; preds = %2694
%2700 = shl nuw nsw i64 %2697, 2
%2701 = getelementptr i8, i8* %2, i64 %2700
%2702 = getelementptr i8, i8* %0, i64 %2700
%2703 = icmp ugt i8* %2702, %2
%2704 = icmp ugt i8* %2701, %0
%2705 = and i1 %2703, %2704
br i1 %2705, label %2785, label %2706
2706: ; preds = %2699
%2707 = and i64 %2697, 4294967288
%2708 = add nsw i64 %2707, -8
%2709 = lshr exact i64 %2708, 3
%2710 = add nuw nsw i64 %2709, 1
%2711 = and i64 %2710, 3
%2712 = icmp ult i64 %2708, 24
br i1 %2712, label %2764, label %2713
2713: ; preds = %2706
%2714 = and i64 %2710, 4611686018427387900
br label %2715
2715: ; preds = %2715, %2713
%2716 = phi i64 [ 0, %2713 ], [ %2761, %2715 ]
%2717 = phi i64 [ 0, %2713 ], [ %2762, %2715 ]
%2718 = getelementptr inbounds i32, i32* %2695, i64 %2716
%2719 = bitcast i32* %2718 to <4 x i32>*
%2720 = load <4 x i32>, <4 x i32>* %2719
%2721 = getelementptr inbounds i32, i32* %2718, i64 4
%2722 = bitcast i32* %2721 to <4 x i32>*
%2723 = load <4 x i32>, <4 x i32>* %2722
%2724 = getelementptr inbounds i32, i32* %2696, i64 %2716
%2725 = bitcast i32* %2724 to <4 x i32>*
store <4 x i32> %2720, <4 x i32>* %2725
%2726 = getelementptr inbounds i32, i32* %2724, i64 4
%2727 = bitcast i32* %2726 to <4 x i32>*
store <4 x i32> %2723, <4 x i32>* %2727
%2728 = or i64 %2716, 8
%2729 = getelementptr inbounds i32, i32* %2695, i64 %2728
%2730 = bitcast i32* %2729 to <4 x i32>*
%2731 = load <4 x i32>, <4 x i32>* %2730
%2732 = getelementptr inbounds i32, i32* %2729, i64 4
%2733 = bitcast i32* %2732 to <4 x i32>*
%2734 = load <4 x i32>, <4 x i32>* %2733
%2735 = getelementptr inbounds i32, i32* %2696, i64 %2728
%2736 = bitcast i32* %2735 to <4 x i32>*
store <4 x i32> %2731, <4 x i32>* %2736
%2737 = getelementptr inbounds i32, i32* %2735, i64 4
%2738 = bitcast i32* %2737 to <4 x i32>*
store <4 x i32> %2734, <4 x i32>* %2738
%2739 = or i64 %2716, 16
%2740 = getelementptr inbounds i32, i32* %2695, i64 %2739
%2741 = bitcast i32* %2740 to <4 x i32>*
%2742 = load <4 x i32>, <4 x i32>* %2741
%2743 = getelementptr inbounds i32, i32* %2740, i64 4
%2744 = bitcast i32* %2743 to <4 x i32>*
%2745 = load <4 x i32>, <4 x i32>* %2744
%2746 = getelementptr inbounds i32, i32* %2696, i64 %2739
%2747 = bitcast i32* %2746 to <4 x i32>*
store <4 x i32> %2742, <4 x i32>* %2747
%2748 = getelementptr inbounds i32, i32* %2746, i64 4
%2749 = bitcast i32* %2748 to <4 x i32>*
store <4 x i32> %2745, <4 x i32>* %2749
%2750 = or i64 %2716, 24
%2751 = getelementptr inbounds i32, i32* %2695, i64 %2750
%2752 = bitcast i32* %2751 to <4 x i32>*
%2753 = load <4 x i32>, <4 x i32>* %2752
%2754 = getelementptr inbounds i32, i32* %2751, i64 4
%2755 = bitcast i32* %2754 to <4 x i32>*
%2756 = load <4 x i32>, <4 x i32>* %2755
%2757 = getelementptr inbounds i32, i32* %2696, i64 %2750
%2758 = bitcast i32* %2757 to <4 x i32>*
store <4 x i32> %2753, <4 x i32>* %2758
%2759 = getelementptr inbounds i32, i32* %2757, i64 4
%2760 = bitcast i32* %2759 to <4 x i32>*
store <4 x i32> %2756, <4 x i32>* %2760
%2761 = add nuw i64 %2716, 32
%2762 = add i64 %2717, 4
%2763 = icmp eq i64 %2762, %2714
br i1 %2763, label %2764, label %2715
2764: ; preds = %2715, %2706
%2765 = phi i64 [ 0, %2706 ], [ %2761, %2715 ]
%2766 = icmp eq i64 %2711, 0
br i1 %2766, label %2783, label %2767
2767: ; preds = %2764, %2767
%2768 = phi i64 [ %2780, %2767 ], [ %2765, %2764 ]
%2769 = phi i64 [ %2781, %2767 ], [ 0, %2764 ]
%2770 = getelementptr inbounds i32, i32* %2695, i64 %2768
%2771 = bitcast i32* %2770 to <4 x i32>*
%2772 = load <4 x i32>, <4 x i32>* %2771
%2773 = getelementptr inbounds i32, i32* %2770, i64 4
%2774 = bitcast i32* %2773 to <4 x i32>*
%2775 = load <4 x i32>, <4 x i32>* %2774
%2776 = getelementptr inbounds i32, i32* %2696, i64 %2768
%2777 = bitcast i32* %2776 to <4 x i32>*
store <4 x i32> %2772, <4 x i32>* %2777
%2778 = getelementptr inbounds i32, i32* %2776, i64 4
%2779 = bitcast i32* %2778 to <4 x i32>*
store <4 x i32> %2775, <4 x i32>* %2779
%2780 = add nuw i64 %2768, 8
%2781 = add i64 %2769, 1
%2782 = icmp eq i64 %2781, %2711
br i1 %2782, label %2783, label %2767
2783: ; preds = %2767, %2764
%2784 = icmp eq i64 %2707, %2697
br i1 %2784, label %4771, label %2785
2785: ; preds = %2699, %2694, %2783
%2786 = phi i64 [ 0, %2699 ], [ 0, %2694 ], [ %2707, %2783 ]
%2787 = xor i64 %2786, -1
%2788 = add nsw i64 %2787, %2697
%2789 = and i64 %2697, 3
%2790 = icmp eq i64 %2789, 0
br i1 %2790, label %2800, label %2791
2791: ; preds = %2785, %2791
%2792 = phi i64 [ %2797, %2791 ], [ %2786, %2785 ]
%2793 = phi i64 [ %2798, %2791 ], [ 0, %2785 ]
%2794 = getelementptr inbounds i32, i32* %2695, i64 %2792
%2795 = load i32, i32* %2794
%2796 = getelementptr inbounds i32, i32* %2696, i64 %2792
store i32 %2795, i32* %2796
%2797 = add nuw nsw i64 %2792, 1
%2798 = add i64 %2793, 1
%2799 = icmp eq i64 %2798, %2789
br i1 %2799, label %2800, label %2791
2800: ; preds = %2791, %2785
%2801 = phi i64 [ %2786, %2785 ], [ %2797, %2791 ]
%2802 = icmp ult i64 %2788, 3
br i1 %2802, label %4771, label %2803
2803: ; preds = %2800, %2803
%2804 = phi i64 [ %2820, %2803 ], [ %2801, %2800 ]
%2805 = getelementptr inbounds i32, i32* %2695, i64 %2804
%2806 = load i32, i32* %2805
%2807 = getelementptr inbounds i32, i32* %2696, i64 %2804
store i32 %2806, i32* %2807
%2808 = add nuw nsw i64 %2804, 1
%2809 = getelementptr inbounds i32, i32* %2695, i64 %2808
%2810 = load i32, i32* %2809
%2811 = getelementptr inbounds i32, i32* %2696, i64 %2808
store i32 %2810, i32* %2811
%2812 = add nuw nsw i64 %2804, 2
%2813 = getelementptr inbounds i32, i32* %2695, i64 %2812
%2814 = load i32, i32* %2813
%2815 = getelementptr inbounds i32, i32* %2696, i64 %2812
store i32 %2814, i32* %2815
%2816 = add nuw nsw i64 %2804, 3
%2817 = getelementptr inbounds i32, i32* %2695, i64 %2816
%2818 = load i32, i32* %2817
%2819 = getelementptr inbounds i32, i32* %2696, i64 %2816
store i32 %2818, i32* %2819
%2820 = add nuw nsw i64 %2804, 4
%2821 = icmp eq i64 %2820, %2697
br i1 %2821, label %4771, label %2803
2822: ; preds = %2426, %2822
%2823 = phi i64 [ %2839, %2822 ], [ %2427, %2426 ]
%2824 = getelementptr inbounds i32, i32* %2321, i64 %2823
%2825 = load i32, i32* %2824
%2826 = getelementptr inbounds i32, i32* %2322, i64 %2823
store i32 %2825, i32* %2826
%2827 = add nuw nsw i64 %2823, 1
%2828 = getelementptr inbounds i32, i32* %2321, i64 %2827
%2829 = load i32, i32* %2828
%2830 = getelementptr inbounds i32, i32* %2322, i64 %2827
store i32 %2829, i32* %2830
%2831 = add nuw nsw i64 %2823, 2
%2832 = getelementptr inbounds i32, i32* %2321, i64 %2831
%2833 = load i32, i32* %2832
%2834 = getelementptr inbounds i32, i32* %2322, i64 %2831
store i32 %2833, i32* %2834
%2835 = add nuw nsw i64 %2823, 3
%2836 = getelementptr inbounds i32, i32* %2321, i64 %2835
%2837 = load i32, i32* %2836
%2838 = getelementptr inbounds i32, i32* %2322, i64 %2835
store i32 %2837, i32* %2838
%2839 = add nuw nsw i64 %2823, 4
%2840 = icmp eq i64 %2839, %2323
br i1 %2840, label %4771, label %2822
2841: ; preds = %2316, %2841
%2842 = phi i64 [ %2847, %2841 ], [ %2317, %2316 ]
%2843 = getelementptr inbounds i32, i32* %2254, i64 %2842
%2844 = load i32, i32* %2843
%2845 = sitofp i32 %2844 to float
%2846 = getelementptr inbounds float, float* %2255, i64 %2842
store float %2845, float* %2846
%2847 = add nuw nsw i64 %2842, 1
%2848 = icmp eq i64 %2847, %2256
br i1 %2848, label %4771, label %2841
2849: ; preds = %2249, %2849
%2850 = phi i64 [ %2855, %2849 ], [ %2250, %2249 ]
%2851 = getelementptr inbounds i32, i32* %2187, i64 %2850
%2852 = load i32, i32* %2851
%2853 = sitofp i32 %2852 to double
%2854 = getelementptr inbounds double, double* %2188, i64 %2850
store double %2853, double* %2854
%2855 = add nuw nsw i64 %2850, 1
%2856 = icmp eq i64 %2855, %2189
br i1 %2856, label %4771, label %2849
2857: ; preds = %8
switch i32 %6, label %4771 [
i32 99, label %3237
i32 115, label %3170
i32 117, label %3103
i32 105, label %3366
i32 83, label %3366
i32 85, label %2992
i32 102, label %2925
i32 100, label %2858
]
2858: ; preds = %2857
%2859 = icmp sgt i32 %4, 0
br i1 %2859, label %2860, label %4771
2860: ; preds = %2858
%2861 = bitcast i8* %0 to i32*
%2862 = bitcast i8* %2 to double*
%2863 = zext i32 %4 to i64
%2864 = icmp ult i32 %4, 4
br i1 %2864, label %2923, label %2865
2865: ; preds = %2860
%2866 = and i64 %2863, 4294967292
%2867 = add nsw i64 %2866, -4
%2868 = lshr exact i64 %2867, 2
%2869 = add nuw nsw i64 %2868, 1
%2870 = and i64 %2869, 1
%2871 = icmp eq i64 %2867, 0
br i1 %2871, label %2905, label %2872
2872: ; preds = %2865
%2873 = and i64 %2869, 9223372036854775806
br label %2874
2874: ; preds = %2874, %2872
%2875 = phi i64 [ 0, %2872 ], [ %2902, %2874 ]
%2876 = phi i64 [ 0, %2872 ], [ %2903, %2874 ]
%2877 = getelementptr inbounds i32, i32* %2861, i64 %2875
%2878 = bitcast i32* %2877 to <2 x i32>*
%2879 = load <2 x i32>, <2 x i32>* %2878
%2880 = getelementptr inbounds i32, i32* %2877, i64 2
%2881 = bitcast i32* %2880 to <2 x i32>*
%2882 = load <2 x i32>, <2 x i32>* %2881
%2883 = uitofp <2 x i32> %2879 to <2 x double>
%2884 = uitofp <2 x i32> %2882 to <2 x double>
%2885 = getelementptr inbounds double, double* %2862, i64 %2875
%2886 = bitcast double* %2885 to <2 x double>*
store <2 x double> %2883, <2 x double>* %2886
%2887 = getelementptr inbounds double, double* %2885, i64 2
%2888 = bitcast double* %2887 to <2 x double>*
store <2 x double> %2884, <2 x double>* %2888
%2889 = or i64 %2875, 4
%2890 = getelementptr inbounds i32, i32* %2861, i64 %2889
%2891 = bitcast i32* %2890 to <2 x i32>*
%2892 = load <2 x i32>, <2 x i32>* %2891
%2893 = getelementptr inbounds i32, i32* %2890, i64 2
%2894 = bitcast i32* %2893 to <2 x i32>*
%2895 = load <2 x i32>, <2 x i32>* %2894
%2896 = uitofp <2 x i32> %2892 to <2 x double>
%2897 = uitofp <2 x i32> %2895 to <2 x double>
%2898 = getelementptr inbounds double, double* %2862, i64 %2889
%2899 = bitcast double* %2898 to <2 x double>*
store <2 x double> %2896, <2 x double>* %2899
%2900 = getelementptr inbounds double, double* %2898, i64 2
%2901 = bitcast double* %2900 to <2 x double>*
store <2 x double> %2897, <2 x double>* %2901
%2902 = add nuw i64 %2875, 8
%2903 = add i64 %2876, 2
%2904 = icmp eq i64 %2903, %2873
br i1 %2904, label %2905, label %2874
2905: ; preds = %2874, %2865
%2906 = phi i64 [ 0, %2865 ], [ %2902, %2874 ]
%2907 = icmp eq i64 %2870, 0
br i1 %2907, label %2921, label %2908
2908: ; preds = %2905
%2909 = getelementptr inbounds i32, i32* %2861, i64 %2906
%2910 = bitcast i32* %2909 to <2 x i32>*
%2911 = load <2 x i32>, <2 x i32>* %2910
%2912 = getelementptr inbounds i32, i32* %2909, i64 2
%2913 = bitcast i32* %2912 to <2 x i32>*
%2914 = load <2 x i32>, <2 x i32>* %2913
%2915 = uitofp <2 x i32> %2911 to <2 x double>
%2916 = uitofp <2 x i32> %2914 to <2 x double>
%2917 = getelementptr inbounds double, double* %2862, i64 %2906
%2918 = bitcast double* %2917 to <2 x double>*
store <2 x double> %2915, <2 x double>* %2918
%2919 = getelementptr inbounds double, double* %2917, i64 2
%2920 = bitcast double* %2919 to <2 x double>*
store <2 x double> %2916, <2 x double>* %2920
br label %2921
2921: ; preds = %2905, %2908
%2922 = icmp eq i64 %2866, %2863
br i1 %2922, label %4771, label %2923
2923: ; preds = %2860, %2921
%2924 = phi i64 [ 0, %2860 ], [ %2866, %2921 ]
br label %3523
2925: ; preds = %2857
%2926 = icmp sgt i32 %4, 0
br i1 %2926, label %2927, label %4771
2927: ; preds = %2925
%2928 = bitcast i8* %0 to i32*
%2929 = bitcast i8* %2 to float*
%2930 = zext i32 %4 to i64
%2931 = icmp ult i32 %4, 8
br i1 %2931, label %2990, label %2932
2932: ; preds = %2927
%2933 = and i64 %2930, 4294967288
%2934 = add nsw i64 %2933, -8
%2935 = lshr exact i64 %2934, 3
%2936 = add nuw nsw i64 %2935, 1
%2937 = and i64 %2936, 1
%2938 = icmp eq i64 %2934, 0
br i1 %2938, label %2972, label %2939
2939: ; preds = %2932
%2940 = and i64 %2936, 4611686018427387902
br label %2941
2941: ; preds = %2941, %2939
%2942 = phi i64 [ 0, %2939 ], [ %2969, %2941 ]
%2943 = phi i64 [ 0, %2939 ], [ %2970, %2941 ]
%2944 = getelementptr inbounds i32, i32* %2928, i64 %2942
%2945 = bitcast i32* %2944 to <4 x i32>*
%2946 = load <4 x i32>, <4 x i32>* %2945
%2947 = getelementptr inbounds i32, i32* %2944, i64 4
%2948 = bitcast i32* %2947 to <4 x i32>*
%2949 = load <4 x i32>, <4 x i32>* %2948
%2950 = uitofp <4 x i32> %2946 to <4 x float>
%2951 = uitofp <4 x i32> %2949 to <4 x float>
%2952 = getelementptr inbounds float, float* %2929, i64 %2942
%2953 = bitcast float* %2952 to <4 x float>*
store <4 x float> %2950, <4 x float>* %2953
%2954 = getelementptr inbounds float, float* %2952, i64 4
%2955 = bitcast float* %2954 to <4 x float>*
store <4 x float> %2951, <4 x float>* %2955
%2956 = or i64 %2942, 8
%2957 = getelementptr inbounds i32, i32* %2928, i64 %2956
%2958 = bitcast i32* %2957 to <4 x i32>*
%2959 = load <4 x i32>, <4 x i32>* %2958
%2960 = getelementptr inbounds i32, i32* %2957, i64 4
%2961 = bitcast i32* %2960 to <4 x i32>*
%2962 = load <4 x i32>, <4 x i32>* %2961
%2963 = uitofp <4 x i32> %2959 to <4 x float>
%2964 = uitofp <4 x i32> %2962 to <4 x float>
%2965 = getelementptr inbounds float, float* %2929, i64 %2956
%2966 = bitcast float* %2965 to <4 x float>*
store <4 x float> %2963, <4 x float>* %2966
%2967 = getelementptr inbounds float, float* %2965, i64 4
%2968 = bitcast float* %2967 to <4 x float>*
store <4 x float> %2964, <4 x float>* %2968
%2969 = add nuw i64 %2942, 16
%2970 = add i64 %2943, 2
%2971 = icmp eq i64 %2970, %2940
br i1 %2971, label %2972, label %2941
2972: ; preds = %2941, %2932
%2973 = phi i64 [ 0, %2932 ], [ %2969, %2941 ]
%2974 = icmp eq i64 %2937, 0
br i1 %2974, label %2988, label %2975
2975: ; preds = %2972
%2976 = getelementptr inbounds i32, i32* %2928, i64 %2973
%2977 = bitcast i32* %2976 to <4 x i32>*
%2978 = load <4 x i32>, <4 x i32>* %2977
%2979 = getelementptr inbounds i32, i32* %2976, i64 4
%2980 = bitcast i32* %2979 to <4 x i32>*
%2981 = load <4 x i32>, <4 x i32>* %2980
%2982 = uitofp <4 x i32> %2978 to <4 x float>
%2983 = uitofp <4 x i32> %2981 to <4 x float>
%2984 = getelementptr inbounds float, float* %2929, i64 %2973
%2985 = bitcast float* %2984 to <4 x float>*
store <4 x float> %2982, <4 x float>* %2985
%2986 = getelementptr inbounds float, float* %2984, i64 4
%2987 = bitcast float* %2986 to <4 x float>*
store <4 x float> %2983, <4 x float>* %2987
br label %2988
2988: ; preds = %2972, %2975
%2989 = icmp eq i64 %2933, %2930
br i1 %2989, label %4771, label %2990
2990: ; preds = %2927, %2988
%2991 = phi i64 [ 0, %2927 ], [ %2933, %2988 ]
br label %3515
2992: ; preds = %2857
%2993 = icmp sgt i32 %4, 0
br i1 %2993, label %2994, label %4771
2994: ; preds = %2992
%2995 = bitcast i8* %0 to i32*
%2996 = bitcast i8* %2 to i32*
%2997 = zext i32 %4 to i64
%2998 = icmp ult i32 %4, 8
br i1 %2998, label %3085, label %2999
2999: ; preds = %2994
%3000 = shl nuw nsw i64 %2997, 2
%3001 = getelementptr i8, i8* %2, i64 %3000
%3002 = getelementptr i8, i8* %0, i64 %3000
%3003 = icmp ugt i8* %3002, %2
%3004 = icmp ugt i8* %3001, %0
%3005 = and i1 %3003, %3004
br i1 %3005, label %3085, label %3006
3006: ; preds = %2999
%3007 = and i64 %2997, 4294967288
%3008 = add nsw i64 %3007, -8
%3009 = lshr exact i64 %3008, 3
%3010 = add nuw nsw i64 %3009, 1
%3011 = and i64 %3010, 3
%3012 = icmp ult i64 %3008, 24
br i1 %3012, label %3064, label %3013
3013: ; preds = %3006
%3014 = and i64 %3010, 4611686018427387900
br label %3015
3015: ; preds = %3015, %3013
%3016 = phi i64 [ 0, %3013 ], [ %3061, %3015 ]
%3017 = phi i64 [ 0, %3013 ], [ %3062, %3015 ]
%3018 = getelementptr inbounds i32, i32* %2995, i64 %3016
%3019 = bitcast i32* %3018 to <4 x i32>*
%3020 = load <4 x i32>, <4 x i32>* %3019
%3021 = getelementptr inbounds i32, i32* %3018, i64 4
%3022 = bitcast i32* %3021 to <4 x i32>*
%3023 = load <4 x i32>, <4 x i32>* %3022
%3024 = getelementptr inbounds i32, i32* %2996, i64 %3016
%3025 = bitcast i32* %3024 to <4 x i32>*
store <4 x i32> %3020, <4 x i32>* %3025
%3026 = getelementptr inbounds i32, i32* %3024, i64 4
%3027 = bitcast i32* %3026 to <4 x i32>*
store <4 x i32> %3023, <4 x i32>* %3027
%3028 = or i64 %3016, 8
%3029 = getelementptr inbounds i32, i32* %2995, i64 %3028
%3030 = bitcast i32* %3029 to <4 x i32>*
%3031 = load <4 x i32>, <4 x i32>* %3030
%3032 = getelementptr inbounds i32, i32* %3029, i64 4
%3033 = bitcast i32* %3032 to <4 x i32>*
%3034 = load <4 x i32>, <4 x i32>* %3033
%3035 = getelementptr inbounds i32, i32* %2996, i64 %3028
%3036 = bitcast i32* %3035 to <4 x i32>*
store <4 x i32> %3031, <4 x i32>* %3036
%3037 = getelementptr inbounds i32, i32* %3035, i64 4
%3038 = bitcast i32* %3037 to <4 x i32>*
store <4 x i32> %3034, <4 x i32>* %3038
%3039 = or i64 %3016, 16
%3040 = getelementptr inbounds i32, i32* %2995, i64 %3039
%3041 = bitcast i32* %3040 to <4 x i32>*
%3042 = load <4 x i32>, <4 x i32>* %3041
%3043 = getelementptr inbounds i32, i32* %3040, i64 4
%3044 = bitcast i32* %3043 to <4 x i32>*
%3045 = load <4 x i32>, <4 x i32>* %3044
%3046 = getelementptr inbounds i32, i32* %2996, i64 %3039
%3047 = bitcast i32* %3046 to <4 x i32>*
store <4 x i32> %3042, <4 x i32>* %3047
%3048 = getelementptr inbounds i32, i32* %3046, i64 4
%3049 = bitcast i32* %3048 to <4 x i32>*
store <4 x i32> %3045, <4 x i32>* %3049
%3050 = or i64 %3016, 24
%3051 = getelementptr inbounds i32, i32* %2995, i64 %3050
%3052 = bitcast i32* %3051 to <4 x i32>*
%3053 = load <4 x i32>, <4 x i32>* %3052
%3054 = getelementptr inbounds i32, i32* %3051, i64 4
%3055 = bitcast i32* %3054 to <4 x i32>*
%3056 = load <4 x i32>, <4 x i32>* %3055
%3057 = getelementptr inbounds i32, i32* %2996, i64 %3050
%3058 = bitcast i32* %3057 to <4 x i32>*
store <4 x i32> %3053, <4 x i32>* %3058
%3059 = getelementptr inbounds i32, i32* %3057, i64 4
%3060 = bitcast i32* %3059 to <4 x i32>*
store <4 x i32> %3056, <4 x i32>* %3060
%3061 = add nuw i64 %3016, 32
%3062 = add i64 %3017, 4
%3063 = icmp eq i64 %3062, %3014
br i1 %3063, label %3064, label %3015
3064: ; preds = %3015, %3006
%3065 = phi i64 [ 0, %3006 ], [ %3061, %3015 ]
%3066 = icmp eq i64 %3011, 0
br i1 %3066, label %3083, label %3067
3067: ; preds = %3064, %3067
%3068 = phi i64 [ %3080, %3067 ], [ %3065, %3064 ]
%3069 = phi i64 [ %3081, %3067 ], [ 0, %3064 ]
%3070 = getelementptr inbounds i32, i32* %2995, i64 %3068
%3071 = bitcast i32* %3070 to <4 x i32>*
%3072 = load <4 x i32>, <4 x i32>* %3071
%3073 = getelementptr inbounds i32, i32* %3070, i64 4
%3074 = bitcast i32* %3073 to <4 x i32>*
%3075 = load <4 x i32>, <4 x i32>* %3074
%3076 = getelementptr inbounds i32, i32* %2996, i64 %3068
%3077 = bitcast i32* %3076 to <4 x i32>*
store <4 x i32> %3072, <4 x i32>* %3077
%3078 = getelementptr inbounds i32, i32* %3076, i64 4
%3079 = bitcast i32* %3078 to <4 x i32>*
store <4 x i32> %3075, <4 x i32>* %3079
%3080 = add nuw i64 %3068, 8
%3081 = add i64 %3069, 1
%3082 = icmp eq i64 %3081, %3011
br i1 %3082, label %3083, label %3067
3083: ; preds = %3067, %3064
%3084 = icmp eq i64 %3007, %2997
br i1 %3084, label %4771, label %3085
3085: ; preds = %2999, %2994, %3083
%3086 = phi i64 [ 0, %2999 ], [ 0, %2994 ], [ %3007, %3083 ]
%3087 = xor i64 %3086, -1
%3088 = add nsw i64 %3087, %2997
%3089 = and i64 %2997, 3
%3090 = icmp eq i64 %3089, 0
br i1 %3090, label %3100, label %3091
3091: ; preds = %3085, %3091
%3092 = phi i64 [ %3097, %3091 ], [ %3086, %3085 ]
%3093 = phi i64 [ %3098, %3091 ], [ 0, %3085 ]
%3094 = getelementptr inbounds i32, i32* %2995, i64 %3092
%3095 = load i32, i32* %3094
%3096 = getelementptr inbounds i32, i32* %2996, i64 %3092
store i32 %3095, i32* %3096
%3097 = add nuw nsw i64 %3092, 1
%3098 = add i64 %3093, 1
%3099 = icmp eq i64 %3098, %3089
br i1 %3099, label %3100, label %3091
3100: ; preds = %3091, %3085
%3101 = phi i64 [ %3086, %3085 ], [ %3097, %3091 ]
%3102 = icmp ult i64 %3088, 3
br i1 %3102, label %4771, label %3496
3103: ; preds = %2857
%3104 = icmp sgt i32 %4, 0
br i1 %3104, label %3105, label %4771
3105: ; preds = %3103
%3106 = bitcast i8* %0 to i32*
%3107 = bitcast i8* %2 to i16*
%3108 = zext i32 %4 to i64
%3109 = icmp ult i32 %4, 8
br i1 %3109, label %3168, label %3110
3110: ; preds = %3105
%3111 = and i64 %3108, 4294967288
%3112 = add nsw i64 %3111, -8
%3113 = lshr exact i64 %3112, 3
%3114 = add nuw nsw i64 %3113, 1
%3115 = and i64 %3114, 1
%3116 = icmp eq i64 %3112, 0
br i1 %3116, label %3150, label %3117
3117: ; preds = %3110
%3118 = and i64 %3114, 4611686018427387902
br label %3119
3119: ; preds = %3119, %3117
%3120 = phi i64 [ 0, %3117 ], [ %3147, %3119 ]
%3121 = phi i64 [ 0, %3117 ], [ %3148, %3119 ]
%3122 = getelementptr inbounds i32, i32* %3106, i64 %3120
%3123 = bitcast i32* %3122 to <4 x i32>*
%3124 = load <4 x i32>, <4 x i32>* %3123
%3125 = getelementptr inbounds i32, i32* %3122, i64 4
%3126 = bitcast i32* %3125 to <4 x i32>*
%3127 = load <4 x i32>, <4 x i32>* %3126
%3128 = trunc <4 x i32> %3124 to <4 x i16>
%3129 = trunc <4 x i32> %3127 to <4 x i16>
%3130 = getelementptr inbounds i16, i16* %3107, i64 %3120
%3131 = bitcast i16* %3130 to <4 x i16>*
store <4 x i16> %3128, <4 x i16>* %3131
%3132 = getelementptr inbounds i16, i16* %3130, i64 4
%3133 = bitcast i16* %3132 to <4 x i16>*
store <4 x i16> %3129, <4 x i16>* %3133
%3134 = or i64 %3120, 8
%3135 = getelementptr inbounds i32, i32* %3106, i64 %3134
%3136 = bitcast i32* %3135 to <4 x i32>*
%3137 = load <4 x i32>, <4 x i32>* %3136
%3138 = getelementptr inbounds i32, i32* %3135, i64 4
%3139 = bitcast i32* %3138 to <4 x i32>*
%3140 = load <4 x i32>, <4 x i32>* %3139
%3141 = trunc <4 x i32> %3137 to <4 x i16>
%3142 = trunc <4 x i32> %3140 to <4 x i16>
%3143 = getelementptr inbounds i16, i16* %3107, i64 %3134
%3144 = bitcast i16* %3143 to <4 x i16>*
store <4 x i16> %3141, <4 x i16>* %3144
%3145 = getelementptr inbounds i16, i16* %3143, i64 4
%3146 = bitcast i16* %3145 to <4 x i16>*
store <4 x i16> %3142, <4 x i16>* %3146
%3147 = add nuw i64 %3120, 16
%3148 = add i64 %3121, 2
%3149 = icmp eq i64 %3148, %3118
br i1 %3149, label %3150, label %3119
3150: ; preds = %3119, %3110
%3151 = phi i64 [ 0, %3110 ], [ %3147, %3119 ]
%3152 = icmp eq i64 %3115, 0
br i1 %3152, label %3166, label %3153
3153: ; preds = %3150
%3154 = getelementptr inbounds i32, i32* %3106, i64 %3151
%3155 = bitcast i32* %3154 to <4 x i32>*
%3156 = load <4 x i32>, <4 x i32>* %3155
%3157 = getelementptr inbounds i32, i32* %3154, i64 4
%3158 = bitcast i32* %3157 to <4 x i32>*
%3159 = load <4 x i32>, <4 x i32>* %3158
%3160 = trunc <4 x i32> %3156 to <4 x i16>
%3161 = trunc <4 x i32> %3159 to <4 x i16>
%3162 = getelementptr inbounds i16, i16* %3107, i64 %3151
%3163 = bitcast i16* %3162 to <4 x i16>*
store <4 x i16> %3160, <4 x i16>* %3163
%3164 = getelementptr inbounds i16, i16* %3162, i64 4
%3165 = bitcast i16* %3164 to <4 x i16>*
store <4 x i16> %3161, <4 x i16>* %3165
br label %3166
3166: ; preds = %3150, %3153
%3167 = icmp eq i64 %3111, %3108
br i1 %3167, label %4771, label %3168
3168: ; preds = %3105, %3166
%3169 = phi i64 [ 0, %3105 ], [ %3111, %3166 ]
br label %3358
3170: ; preds = %2857
%3171 = icmp sgt i32 %4, 0
br i1 %3171, label %3172, label %4771
3172: ; preds = %3170
%3173 = bitcast i8* %0 to i32*
%3174 = bitcast i8* %2 to i16*
%3175 = zext i32 %4 to i64
%3176 = icmp ult i32 %4, 8
br i1 %3176, label %3235, label %3177
3177: ; preds = %3172
%3178 = and i64 %3175, 4294967288
%3179 = add nsw i64 %3178, -8
%3180 = lshr exact i64 %3179, 3
%3181 = add nuw nsw i64 %3180, 1
%3182 = and i64 %3181, 1
%3183 = icmp eq i64 %3179, 0
br i1 %3183, label %3217, label %3184
3184: ; preds = %3177
%3185 = and i64 %3181, 4611686018427387902
br label %3186
3186: ; preds = %3186, %3184
%3187 = phi i64 [ 0, %3184 ], [ %3214, %3186 ]
%3188 = phi i64 [ 0, %3184 ], [ %3215, %3186 ]
%3189 = getelementptr inbounds i32, i32* %3173, i64 %3187
%3190 = bitcast i32* %3189 to <4 x i32>*
%3191 = load <4 x i32>, <4 x i32>* %3190
%3192 = getelementptr inbounds i32, i32* %3189, i64 4
%3193 = bitcast i32* %3192 to <4 x i32>*
%3194 = load <4 x i32>, <4 x i32>* %3193
%3195 = trunc <4 x i32> %3191 to <4 x i16>
%3196 = trunc <4 x i32> %3194 to <4 x i16>
%3197 = getelementptr inbounds i16, i16* %3174, i64 %3187
%3198 = bitcast i16* %3197 to <4 x i16>*
store <4 x i16> %3195, <4 x i16>* %3198
%3199 = getelementptr inbounds i16, i16* %3197, i64 4
%3200 = bitcast i16* %3199 to <4 x i16>*
store <4 x i16> %3196, <4 x i16>* %3200
%3201 = or i64 %3187, 8
%3202 = getelementptr inbounds i32, i32* %3173, i64 %3201
%3203 = bitcast i32* %3202 to <4 x i32>*
%3204 = load <4 x i32>, <4 x i32>* %3203
%3205 = getelementptr inbounds i32, i32* %3202, i64 4
%3206 = bitcast i32* %3205 to <4 x i32>*
%3207 = load <4 x i32>, <4 x i32>* %3206
%3208 = trunc <4 x i32> %3204 to <4 x i16>
%3209 = trunc <4 x i32> %3207 to <4 x i16>
%3210 = getelementptr inbounds i16, i16* %3174, i64 %3201
%3211 = bitcast i16* %3210 to <4 x i16>*
store <4 x i16> %3208, <4 x i16>* %3211
%3212 = getelementptr inbounds i16, i16* %3210, i64 4
%3213 = bitcast i16* %3212 to <4 x i16>*
store <4 x i16> %3209, <4 x i16>* %3213
%3214 = add nuw i64 %3187, 16
%3215 = add i64 %3188, 2
%3216 = icmp eq i64 %3215, %3185
br i1 %3216, label %3217, label %3186
3217: ; preds = %3186, %3177
%3218 = phi i64 [ 0, %3177 ], [ %3214, %3186 ]
%3219 = icmp eq i64 %3182, 0
br i1 %3219, label %3233, label %3220
3220: ; preds = %3217
%3221 = getelementptr inbounds i32, i32* %3173, i64 %3218
%3222 = bitcast i32* %3221 to <4 x i32>*
%3223 = load <4 x i32>, <4 x i32>* %3222
%3224 = getelementptr inbounds i32, i32* %3221, i64 4
%3225 = bitcast i32* %3224 to <4 x i32>*
%3226 = load <4 x i32>, <4 x i32>* %3225
%3227 = trunc <4 x i32> %3223 to <4 x i16>
%3228 = trunc <4 x i32> %3226 to <4 x i16>
%3229 = getelementptr inbounds i16, i16* %3174, i64 %3218
%3230 = bitcast i16* %3229 to <4 x i16>*
store <4 x i16> %3227, <4 x i16>* %3230
%3231 = getelementptr inbounds i16, i16* %3229, i64 4
%3232 = bitcast i16* %3231 to <4 x i16>*
store <4 x i16> %3228, <4 x i16>* %3232
br label %3233
3233: ; preds = %3217, %3220
%3234 = icmp eq i64 %3178, %3175
br i1 %3234, label %4771, label %3235
3235: ; preds = %3172, %3233
%3236 = phi i64 [ 0, %3172 ], [ %3178, %3233 ]
br label %3350
3237: ; preds = %2857
%3238 = icmp sgt i32 %4, 0
br i1 %3238, label %3239, label %4771
3239: ; preds = %3237
%3240 = bitcast i8* %0 to i32*
%3241 = zext i32 %4 to i64
%3242 = icmp ult i32 %4, 8
br i1 %3242, label %3308, label %3243
3243: ; preds = %3239
%3244 = getelementptr i8, i8* %2, i64 %3241
%3245 = shl nuw nsw i64 %3241, 2
%3246 = getelementptr i8, i8* %0, i64 %3245
%3247 = icmp ugt i8* %3246, %2
%3248 = icmp ugt i8* %3244, %0
%3249 = and i1 %3247, %3248
br i1 %3249, label %3308, label %3250
3250: ; preds = %3243
%3251 = and i64 %3241, 4294967288
%3252 = add nsw i64 %3251, -8
%3253 = lshr exact i64 %3252, 3
%3254 = add nuw nsw i64 %3253, 1
%3255 = and i64 %3254, 1
%3256 = icmp eq i64 %3252, 0
br i1 %3256, label %3290, label %3257
3257: ; preds = %3250
%3258 = and i64 %3254, 4611686018427387902
br label %3259
3259: ; preds = %3259, %3257
%3260 = phi i64 [ 0, %3257 ], [ %3287, %3259 ]
%3261 = phi i64 [ 0, %3257 ], [ %3288, %3259 ]
%3262 = getelementptr inbounds i32, i32* %3240, i64 %3260
%3263 = bitcast i32* %3262 to <4 x i32>*
%3264 = load <4 x i32>, <4 x i32>* %3263
%3265 = getelementptr inbounds i32, i32* %3262, i64 4
%3266 = bitcast i32* %3265 to <4 x i32>*
%3267 = load <4 x i32>, <4 x i32>* %3266
%3268 = trunc <4 x i32> %3264 to <4 x i8>
%3269 = trunc <4 x i32> %3267 to <4 x i8>
%3270 = getelementptr inbounds i8, i8* %2, i64 %3260
%3271 = bitcast i8* %3270 to <4 x i8>*
store <4 x i8> %3268, <4 x i8>* %3271
%3272 = getelementptr inbounds i8, i8* %3270, i64 4
%3273 = bitcast i8* %3272 to <4 x i8>*
store <4 x i8> %3269, <4 x i8>* %3273
%3274 = or i64 %3260, 8
%3275 = getelementptr inbounds i32, i32* %3240, i64 %3274
%3276 = bitcast i32* %3275 to <4 x i32>*
%3277 = load <4 x i32>, <4 x i32>* %3276
%3278 = getelementptr inbounds i32, i32* %3275, i64 4
%3279 = bitcast i32* %3278 to <4 x i32>*
%3280 = load <4 x i32>, <4 x i32>* %3279
%3281 = trunc <4 x i32> %3277 to <4 x i8>
%3282 = trunc <4 x i32> %3280 to <4 x i8>
%3283 = getelementptr inbounds i8, i8* %2, i64 %3274
%3284 = bitcast i8* %3283 to <4 x i8>*
store <4 x i8> %3281, <4 x i8>* %3284
%3285 = getelementptr inbounds i8, i8* %3283, i64 4
%3286 = bitcast i8* %3285 to <4 x i8>*
store <4 x i8> %3282, <4 x i8>* %3286
%3287 = add nuw i64 %3260, 16
%3288 = add i64 %3261, 2
%3289 = icmp eq i64 %3288, %3258
br i1 %3289, label %3290, label %3259
3290: ; preds = %3259, %3250
%3291 = phi i64 [ 0, %3250 ], [ %3287, %3259 ]
%3292 = icmp eq i64 %3255, 0
br i1 %3292, label %3306, label %3293
3293: ; preds = %3290
%3294 = getelementptr inbounds i32, i32* %3240, i64 %3291
%3295 = bitcast i32* %3294 to <4 x i32>*
%3296 = load <4 x i32>, <4 x i32>* %3295
%3297 = getelementptr inbounds i32, i32* %3294, i64 4
%3298 = bitcast i32* %3297 to <4 x i32>*
%3299 = load <4 x i32>, <4 x i32>* %3298
%3300 = trunc <4 x i32> %3296 to <4 x i8>
%3301 = trunc <4 x i32> %3299 to <4 x i8>
%3302 = getelementptr inbounds i8, i8* %2, i64 %3291
%3303 = bitcast i8* %3302 to <4 x i8>*
store <4 x i8> %3300, <4 x i8>* %3303
%3304 = getelementptr inbounds i8, i8* %3302, i64 4
%3305 = bitcast i8* %3304 to <4 x i8>*
store <4 x i8> %3301, <4 x i8>* %3305
br label %3306
3306: ; preds = %3290, %3293
%3307 = icmp eq i64 %3251, %3241
br i1 %3307, label %4771, label %3308
3308: ; preds = %3243, %3239, %3306
%3309 = phi i64 [ 0, %3243 ], [ 0, %3239 ], [ %3251, %3306 ]
%3310 = xor i64 %3309, -1
%3311 = add nsw i64 %3310, %3241
%3312 = and i64 %3241, 3
%3313 = icmp eq i64 %3312, 0
br i1 %3313, label %3324, label %3314
3314: ; preds = %3308, %3314
%3315 = phi i64 [ %3321, %3314 ], [ %3309, %3308 ]
%3316 = phi i64 [ %3322, %3314 ], [ 0, %3308 ]
%3317 = getelementptr inbounds i32, i32* %3240, i64 %3315
%3318 = load i32, i32* %3317
%3319 = trunc i32 %3318 to i8
%3320 = getelementptr inbounds i8, i8* %2, i64 %3315
store i8 %3319, i8* %3320
%3321 = add nuw nsw i64 %3315, 1
%3322 = add i64 %3316, 1
%3323 = icmp eq i64 %3322, %3312
br i1 %3323, label %3324, label %3314
3324: ; preds = %3314, %3308
%3325 = phi i64 [ %3309, %3308 ], [ %3321, %3314 ]
%3326 = icmp ult i64 %3311, 3
br i1 %3326, label %4771, label %3327
3327: ; preds = %3324, %3327
%3328 = phi i64 [ %3348, %3327 ], [ %3325, %3324 ]
%3329 = getelementptr inbounds i32, i32* %3240, i64 %3328
%3330 = load i32, i32* %3329
%3331 = trunc i32 %3330 to i8
%3332 = getelementptr inbounds i8, i8* %2, i64 %3328
store i8 %3331, i8* %3332
%3333 = add nuw nsw i64 %3328, 1
%3334 = getelementptr inbounds i32, i32* %3240, i64 %3333
%3335 = load i32, i32* %3334
%3336 = trunc i32 %3335 to i8
%3337 = getelementptr inbounds i8, i8* %2, i64 %3333
store i8 %3336, i8* %3337
%3338 = add nuw nsw i64 %3328, 2
%3339 = getelementptr inbounds i32, i32* %3240, i64 %3338
%3340 = load i32, i32* %3339
%3341 = trunc i32 %3340 to i8
%3342 = getelementptr inbounds i8, i8* %2, i64 %3338
store i8 %3341, i8* %3342
%3343 = add nuw nsw i64 %3328, 3
%3344 = getelementptr inbounds i32, i32* %3240, i64 %3343
%3345 = load i32, i32* %3344
%3346 = trunc i32 %3345 to i8
%3347 = getelementptr inbounds i8, i8* %2, i64 %3343
store i8 %3346, i8* %3347
%3348 = add nuw nsw i64 %3328, 4
%3349 = icmp eq i64 %3348, %3241
br i1 %3349, label %4771, label %3327
3350: ; preds = %3235, %3350
%3351 = phi i64 [ %3356, %3350 ], [ %3236, %3235 ]
%3352 = getelementptr inbounds i32, i32* %3173, i64 %3351
%3353 = load i32, i32* %3352
%3354 = trunc i32 %3353 to i16
%3355 = getelementptr inbounds i16, i16* %3174, i64 %3351
store i16 %3354, i16* %3355
%3356 = add nuw nsw i64 %3351, 1
%3357 = icmp eq i64 %3356, %3175
br i1 %3357, label %4771, label %3350
3358: ; preds = %3168, %3358
%3359 = phi i64 [ %3364, %3358 ], [ %3169, %3168 ]
%3360 = getelementptr inbounds i32, i32* %3106, i64 %3359
%3361 = load i32, i32* %3360
%3362 = trunc i32 %3361 to i16
%3363 = getelementptr inbounds i16, i16* %3107, i64 %3359
store i16 %3362, i16* %3363
%3364 = add nuw nsw i64 %3359, 1
%3365 = icmp eq i64 %3364, %3108
br i1 %3365, label %4771, label %3358
3366: ; preds = %2857, %2857
%3367 = icmp sgt i32 %4, 0
br i1 %3367, label %3368, label %4771
3368: ; preds = %3366
%3369 = bitcast i8* %0 to i32*
%3370 = bitcast i8* %2 to i32*
%3371 = zext i32 %4 to i64
%3372 = icmp ult i32 %4, 8
br i1 %3372, label %3459, label %3373
3373: ; preds = %3368
%3374 = shl nuw nsw i64 %3371, 2
%3375 = getelementptr i8, i8* %2, i64 %3374
%3376 = getelementptr i8, i8* %0, i64 %3374
%3377 = icmp ugt i8* %3376, %2
%3378 = icmp ugt i8* %3375, %0
%3379 = and i1 %3377, %3378
br i1 %3379, label %3459, label %3380
3380: ; preds = %3373
%3381 = and i64 %3371, 4294967288
%3382 = add nsw i64 %3381, -8
%3383 = lshr exact i64 %3382, 3
%3384 = add nuw nsw i64 %3383, 1
%3385 = and i64 %3384, 3
%3386 = icmp ult i64 %3382, 24
br i1 %3386, label %3438, label %3387
3387: ; preds = %3380
%3388 = and i64 %3384, 4611686018427387900
br label %3389
3389: ; preds = %3389, %3387
%3390 = phi i64 [ 0, %3387 ], [ %3435, %3389 ]
%3391 = phi i64 [ 0, %3387 ], [ %3436, %3389 ]
%3392 = getelementptr inbounds i32, i32* %3369, i64 %3390
%3393 = bitcast i32* %3392 to <4 x i32>*
%3394 = load <4 x i32>, <4 x i32>* %3393
%3395 = getelementptr inbounds i32, i32* %3392, i64 4
%3396 = bitcast i32* %3395 to <4 x i32>*
%3397 = load <4 x i32>, <4 x i32>* %3396
%3398 = getelementptr inbounds i32, i32* %3370, i64 %3390
%3399 = bitcast i32* %3398 to <4 x i32>*
store <4 x i32> %3394, <4 x i32>* %3399
%3400 = getelementptr inbounds i32, i32* %3398, i64 4
%3401 = bitcast i32* %3400 to <4 x i32>*
store <4 x i32> %3397, <4 x i32>* %3401
%3402 = or i64 %3390, 8
%3403 = getelementptr inbounds i32, i32* %3369, i64 %3402
%3404 = bitcast i32* %3403 to <4 x i32>*
%3405 = load <4 x i32>, <4 x i32>* %3404
%3406 = getelementptr inbounds i32, i32* %3403, i64 4
%3407 = bitcast i32* %3406 to <4 x i32>*
%3408 = load <4 x i32>, <4 x i32>* %3407
%3409 = getelementptr inbounds i32, i32* %3370, i64 %3402
%3410 = bitcast i32* %3409 to <4 x i32>*
store <4 x i32> %3405, <4 x i32>* %3410
%3411 = getelementptr inbounds i32, i32* %3409, i64 4
%3412 = bitcast i32* %3411 to <4 x i32>*
store <4 x i32> %3408, <4 x i32>* %3412
%3413 = or i64 %3390, 16
%3414 = getelementptr inbounds i32, i32* %3369, i64 %3413
%3415 = bitcast i32* %3414 to <4 x i32>*
%3416 = load <4 x i32>, <4 x i32>* %3415
%3417 = getelementptr inbounds i32, i32* %3414, i64 4
%3418 = bitcast i32* %3417 to <4 x i32>*
%3419 = load <4 x i32>, <4 x i32>* %3418
%3420 = getelementptr inbounds i32, i32* %3370, i64 %3413
%3421 = bitcast i32* %3420 to <4 x i32>*
store <4 x i32> %3416, <4 x i32>* %3421
%3422 = getelementptr inbounds i32, i32* %3420, i64 4
%3423 = bitcast i32* %3422 to <4 x i32>*
store <4 x i32> %3419, <4 x i32>* %3423
%3424 = or i64 %3390, 24
%3425 = getelementptr inbounds i32, i32* %3369, i64 %3424
%3426 = bitcast i32* %3425 to <4 x i32>*
%3427 = load <4 x i32>, <4 x i32>* %3426
%3428 = getelementptr inbounds i32, i32* %3425, i64 4
%3429 = bitcast i32* %3428 to <4 x i32>*
%3430 = load <4 x i32>, <4 x i32>* %3429
%3431 = getelementptr inbounds i32, i32* %3370, i64 %3424
%3432 = bitcast i32* %3431 to <4 x i32>*
store <4 x i32> %3427, <4 x i32>* %3432
%3433 = getelementptr inbounds i32, i32* %3431, i64 4
%3434 = bitcast i32* %3433 to <4 x i32>*
store <4 x i32> %3430, <4 x i32>* %3434
%3435 = add nuw i64 %3390, 32
%3436 = add i64 %3391, 4
%3437 = icmp eq i64 %3436, %3388
br i1 %3437, label %3438, label %3389
3438: ; preds = %3389, %3380
%3439 = phi i64 [ 0, %3380 ], [ %3435, %3389 ]
%3440 = icmp eq i64 %3385, 0
br i1 %3440, label %3457, label %3441
3441: ; preds = %3438, %3441
%3442 = phi i64 [ %3454, %3441 ], [ %3439, %3438 ]
%3443 = phi i64 [ %3455, %3441 ], [ 0, %3438 ]
%3444 = getelementptr inbounds i32, i32* %3369, i64 %3442
%3445 = bitcast i32* %3444 to <4 x i32>*
%3446 = load <4 x i32>, <4 x i32>* %3445
%3447 = getelementptr inbounds i32, i32* %3444, i64 4
%3448 = bitcast i32* %3447 to <4 x i32>*
%3449 = load <4 x i32>, <4 x i32>* %3448
%3450 = getelementptr inbounds i32, i32* %3370, i64 %3442
%3451 = bitcast i32* %3450 to <4 x i32>*
store <4 x i32> %3446, <4 x i32>* %3451
%3452 = getelementptr inbounds i32, i32* %3450, i64 4
%3453 = bitcast i32* %3452 to <4 x i32>*
store <4 x i32> %3449, <4 x i32>* %3453
%3454 = add nuw i64 %3442, 8
%3455 = add i64 %3443, 1
%3456 = icmp eq i64 %3455, %3385
br i1 %3456, label %3457, label %3441
3457: ; preds = %3441, %3438
%3458 = icmp eq i64 %3381, %3371
br i1 %3458, label %4771, label %3459
3459: ; preds = %3373, %3368, %3457
%3460 = phi i64 [ 0, %3373 ], [ 0, %3368 ], [ %3381, %3457 ]
%3461 = xor i64 %3460, -1
%3462 = add nsw i64 %3461, %3371
%3463 = and i64 %3371, 3
%3464 = icmp eq i64 %3463, 0
br i1 %3464, label %3474, label %3465
3465: ; preds = %3459, %3465
%3466 = phi i64 [ %3471, %3465 ], [ %3460, %3459 ]
%3467 = phi i64 [ %3472, %3465 ], [ 0, %3459 ]
%3468 = getelementptr inbounds i32, i32* %3369, i64 %3466
%3469 = load i32, i32* %3468
%3470 = getelementptr inbounds i32, i32* %3370, i64 %3466
store i32 %3469, i32* %3470
%3471 = add nuw nsw i64 %3466, 1
%3472 = add i64 %3467, 1
%3473 = icmp eq i64 %3472, %3463
br i1 %3473, label %3474, label %3465
3474: ; preds = %3465, %3459
%3475 = phi i64 [ %3460, %3459 ], [ %3471, %3465 ]
%3476 = icmp ult i64 %3462, 3
br i1 %3476, label %4771, label %3477
3477: ; preds = %3474, %3477
%3478 = phi i64 [ %3494, %3477 ], [ %3475, %3474 ]
%3479 = getelementptr inbounds i32, i32* %3369, i64 %3478
%3480 = load i32, i32* %3479
%3481 = getelementptr inbounds i32, i32* %3370, i64 %3478
store i32 %3480, i32* %3481
%3482 = add nuw nsw i64 %3478, 1
%3483 = getelementptr inbounds i32, i32* %3369, i64 %3482
%3484 = load i32, i32* %3483
%3485 = getelementptr inbounds i32, i32* %3370, i64 %3482
store i32 %3484, i32* %3485
%3486 = add nuw nsw i64 %3478, 2
%3487 = getelementptr inbounds i32, i32* %3369, i64 %3486
%3488 = load i32, i32* %3487
%3489 = getelementptr inbounds i32, i32* %3370, i64 %3486
store i32 %3488, i32* %3489
%3490 = add nuw nsw i64 %3478, 3
%3491 = getelementptr inbounds i32, i32* %3369, i64 %3490
%3492 = load i32, i32* %3491
%3493 = getelementptr inbounds i32, i32* %3370, i64 %3490
store i32 %3492, i32* %3493
%3494 = add nuw nsw i64 %3478, 4
%3495 = icmp eq i64 %3494, %3371
br i1 %3495, label %4771, label %3477
3496: ; preds = %3100, %3496
%3497 = phi i64 [ %3513, %3496 ], [ %3101, %3100 ]
%3498 = getelementptr inbounds i32, i32* %2995, i64 %3497
%3499 = load i32, i32* %3498
%3500 = getelementptr inbounds i32, i32* %2996, i64 %3497
store i32 %3499, i32* %3500
%3501 = add nuw nsw i64 %3497, 1
%3502 = getelementptr inbounds i32, i32* %2995, i64 %3501
%3503 = load i32, i32* %3502
%3504 = getelementptr inbounds i32, i32* %2996, i64 %3501
store i32 %3503, i32* %3504
%3505 = add nuw nsw i64 %3497, 2
%3506 = getelementptr inbounds i32, i32* %2995, i64 %3505
%3507 = load i32, i32* %3506
%3508 = getelementptr inbounds i32, i32* %2996, i64 %3505
store i32 %3507, i32* %3508
%3509 = add nuw nsw i64 %3497, 3
%3510 = getelementptr inbounds i32, i32* %2995, i64 %3509
%3511 = load i32, i32* %3510
%3512 = getelementptr inbounds i32, i32* %2996, i64 %3509
store i32 %3511, i32* %3512
%3513 = add nuw nsw i64 %3497, 4
%3514 = icmp eq i64 %3513, %2997
br i1 %3514, label %4771, label %3496
3515: ; preds = %2990, %3515
%3516 = phi i64 [ %3521, %3515 ], [ %2991, %2990 ]
%3517 = getelementptr inbounds i32, i32* %2928, i64 %3516
%3518 = load i32, i32* %3517
%3519 = uitofp i32 %3518 to float
%3520 = getelementptr inbounds float, float* %2929, i64 %3516
store float %3519, float* %3520
%3521 = add nuw nsw i64 %3516, 1
%3522 = icmp eq i64 %3521, %2930
br i1 %3522, label %4771, label %3515
3523: ; preds = %2923, %3523
%3524 = phi i64 [ %3529, %3523 ], [ %2924, %2923 ]
%3525 = getelementptr inbounds i32, i32* %2861, i64 %3524
%3526 = load i32, i32* %3525
%3527 = uitofp i32 %3526 to double
%3528 = getelementptr inbounds double, double* %2862, i64 %3524
store double %3527, double* %3528
%3529 = add nuw nsw i64 %3524, 1
%3530 = icmp eq i64 %3529, %2863
br i1 %3530, label %4771, label %3523
3531: ; preds = %8
switch i32 %6, label %4771 [
i32 99, label %3911
i32 115, label %3844
i32 117, label %3777
i32 105, label %4040
i32 83, label %4040
i32 85, label %3710
i32 102, label %3599
i32 100, label %3532
]
3532: ; preds = %3531
%3533 = icmp sgt i32 %4, 0
br i1 %3533, label %3534, label %4771
3534: ; preds = %3532
%3535 = bitcast i8* %0 to float*
%3536 = bitcast i8* %2 to double*
%3537 = zext i32 %4 to i64
%3538 = icmp ult i32 %4, 4
br i1 %3538, label %3597, label %3539
3539: ; preds = %3534
%3540 = and i64 %3537, 4294967292
%3541 = add nsw i64 %3540, -4
%3542 = lshr exact i64 %3541, 2
%3543 = add nuw nsw i64 %3542, 1
%3544 = and i64 %3543, 1
%3545 = icmp eq i64 %3541, 0
br i1 %3545, label %3579, label %3546
3546: ; preds = %3539
%3547 = and i64 %3543, 9223372036854775806
br label %3548
3548: ; preds = %3548, %3546
%3549 = phi i64 [ 0, %3546 ], [ %3576, %3548 ]
%3550 = phi i64 [ 0, %3546 ], [ %3577, %3548 ]
%3551 = getelementptr inbounds float, float* %3535, i64 %3549
%3552 = bitcast float* %3551 to <2 x float>*
%3553 = load <2 x float>, <2 x float>* %3552
%3554 = getelementptr inbounds float, float* %3551, i64 2
%3555 = bitcast float* %3554 to <2 x float>*
%3556 = load <2 x float>, <2 x float>* %3555
%3557 = fpext <2 x float> %3553 to <2 x double>
%3558 = fpext <2 x float> %3556 to <2 x double>
%3559 = getelementptr inbounds double, double* %3536, i64 %3549
%3560 = bitcast double* %3559 to <2 x double>*
store <2 x double> %3557, <2 x double>* %3560
%3561 = getelementptr inbounds double, double* %3559, i64 2
%3562 = bitcast double* %3561 to <2 x double>*
store <2 x double> %3558, <2 x double>* %3562
%3563 = or i64 %3549, 4
%3564 = getelementptr inbounds float, float* %3535, i64 %3563
%3565 = bitcast float* %3564 to <2 x float>*
%3566 = load <2 x float>, <2 x float>* %3565
%3567 = getelementptr inbounds float, float* %3564, i64 2
%3568 = bitcast float* %3567 to <2 x float>*
%3569 = load <2 x float>, <2 x float>* %3568
%3570 = fpext <2 x float> %3566 to <2 x double>
%3571 = fpext <2 x float> %3569 to <2 x double>
%3572 = getelementptr inbounds double, double* %3536, i64 %3563
%3573 = bitcast double* %3572 to <2 x double>*
store <2 x double> %3570, <2 x double>* %3573
%3574 = getelementptr inbounds double, double* %3572, i64 2
%3575 = bitcast double* %3574 to <2 x double>*
store <2 x double> %3571, <2 x double>* %3575
%3576 = add nuw i64 %3549, 8
%3577 = add i64 %3550, 2
%3578 = icmp eq i64 %3577, %3547
br i1 %3578, label %3579, label %3548
3579: ; preds = %3548, %3539
%3580 = phi i64 [ 0, %3539 ], [ %3576, %3548 ]
%3581 = icmp eq i64 %3544, 0
br i1 %3581, label %3595, label %3582
3582: ; preds = %3579
%3583 = getelementptr inbounds float, float* %3535, i64 %3580
%3584 = bitcast float* %3583 to <2 x float>*
%3585 = load <2 x float>, <2 x float>* %3584
%3586 = getelementptr inbounds float, float* %3583, i64 2
%3587 = bitcast float* %3586 to <2 x float>*
%3588 = load <2 x float>, <2 x float>* %3587
%3589 = fpext <2 x float> %3585 to <2 x double>
%3590 = fpext <2 x float> %3588 to <2 x double>
%3591 = getelementptr inbounds double, double* %3536, i64 %3580
%3592 = bitcast double* %3591 to <2 x double>*
store <2 x double> %3589, <2 x double>* %3592
%3593 = getelementptr inbounds double, double* %3591, i64 2
%3594 = bitcast double* %3593 to <2 x double>*
store <2 x double> %3590, <2 x double>* %3594
br label %3595
3595: ; preds = %3579, %3582
%3596 = icmp eq i64 %3540, %3537
br i1 %3596, label %4771, label %3597
3597: ; preds = %3534, %3595
%3598 = phi i64 [ 0, %3534 ], [ %3540, %3595 ]
br label %4142
3599: ; preds = %3531
%3600 = icmp sgt i32 %4, 0
br i1 %3600, label %3601, label %4771
3601: ; preds = %3599
%3602 = bitcast i8* %0 to float*
%3603 = bitcast i8* %2 to float*
%3604 = zext i32 %4 to i64
%3605 = icmp ult i32 %4, 8
br i1 %3605, label %3692, label %3606
3606: ; preds = %3601
%3607 = shl nuw nsw i64 %3604, 2
%3608 = getelementptr i8, i8* %2, i64 %3607
%3609 = getelementptr i8, i8* %0, i64 %3607
%3610 = icmp ugt i8* %3609, %2
%3611 = icmp ugt i8* %3608, %0
%3612 = and i1 %3610, %3611
br i1 %3612, label %3692, label %3613
3613: ; preds = %3606
%3614 = and i64 %3604, 4294967288
%3615 = add nsw i64 %3614, -8
%3616 = lshr exact i64 %3615, 3
%3617 = add nuw nsw i64 %3616, 1
%3618 = and i64 %3617, 3
%3619 = icmp ult i64 %3615, 24
br i1 %3619, label %3671, label %3620
3620: ; preds = %3613
%3621 = and i64 %3617, 4611686018427387900
br label %3622
3622: ; preds = %3622, %3620
%3623 = phi i64 [ 0, %3620 ], [ %3668, %3622 ]
%3624 = phi i64 [ 0, %3620 ], [ %3669, %3622 ]
%3625 = getelementptr inbounds float, float* %3602, i64 %3623
%3626 = bitcast float* %3625 to <4 x float>*
%3627 = load <4 x float>, <4 x float>* %3626
%3628 = getelementptr inbounds float, float* %3625, i64 4
%3629 = bitcast float* %3628 to <4 x float>*
%3630 = load <4 x float>, <4 x float>* %3629
%3631 = getelementptr inbounds float, float* %3603, i64 %3623
%3632 = bitcast float* %3631 to <4 x float>*
store <4 x float> %3627, <4 x float>* %3632
%3633 = getelementptr inbounds float, float* %3631, i64 4
%3634 = bitcast float* %3633 to <4 x float>*
store <4 x float> %3630, <4 x float>* %3634
%3635 = or i64 %3623, 8
%3636 = getelementptr inbounds float, float* %3602, i64 %3635
%3637 = bitcast float* %3636 to <4 x float>*
%3638 = load <4 x float>, <4 x float>* %3637
%3639 = getelementptr inbounds float, float* %3636, i64 4
%3640 = bitcast float* %3639 to <4 x float>*
%3641 = load <4 x float>, <4 x float>* %3640
%3642 = getelementptr inbounds float, float* %3603, i64 %3635
%3643 = bitcast float* %3642 to <4 x float>*
store <4 x float> %3638, <4 x float>* %3643
%3644 = getelementptr inbounds float, float* %3642, i64 4
%3645 = bitcast float* %3644 to <4 x float>*
store <4 x float> %3641, <4 x float>* %3645
%3646 = or i64 %3623, 16
%3647 = getelementptr inbounds float, float* %3602, i64 %3646
%3648 = bitcast float* %3647 to <4 x float>*
%3649 = load <4 x float>, <4 x float>* %3648
%3650 = getelementptr inbounds float, float* %3647, i64 4
%3651 = bitcast float* %3650 to <4 x float>*
%3652 = load <4 x float>, <4 x float>* %3651
%3653 = getelementptr inbounds float, float* %3603, i64 %3646
%3654 = bitcast float* %3653 to <4 x float>*
store <4 x float> %3649, <4 x float>* %3654
%3655 = getelementptr inbounds float, float* %3653, i64 4
%3656 = bitcast float* %3655 to <4 x float>*
store <4 x float> %3652, <4 x float>* %3656
%3657 = or i64 %3623, 24
%3658 = getelementptr inbounds float, float* %3602, i64 %3657
%3659 = bitcast float* %3658 to <4 x float>*
%3660 = load <4 x float>, <4 x float>* %3659
%3661 = getelementptr inbounds float, float* %3658, i64 4
%3662 = bitcast float* %3661 to <4 x float>*
%3663 = load <4 x float>, <4 x float>* %3662
%3664 = getelementptr inbounds float, float* %3603, i64 %3657
%3665 = bitcast float* %3664 to <4 x float>*
store <4 x float> %3660, <4 x float>* %3665
%3666 = getelementptr inbounds float, float* %3664, i64 4
%3667 = bitcast float* %3666 to <4 x float>*
store <4 x float> %3663, <4 x float>* %3667
%3668 = add nuw i64 %3623, 32
%3669 = add i64 %3624, 4
%3670 = icmp eq i64 %3669, %3621
br i1 %3670, label %3671, label %3622
3671: ; preds = %3622, %3613
%3672 = phi i64 [ 0, %3613 ], [ %3668, %3622 ]
%3673 = icmp eq i64 %3618, 0
br i1 %3673, label %3690, label %3674
3674: ; preds = %3671, %3674
%3675 = phi i64 [ %3687, %3674 ], [ %3672, %3671 ]
%3676 = phi i64 [ %3688, %3674 ], [ 0, %3671 ]
%3677 = getelementptr inbounds float, float* %3602, i64 %3675
%3678 = bitcast float* %3677 to <4 x float>*
%3679 = load <4 x float>, <4 x float>* %3678
%3680 = getelementptr inbounds float, float* %3677, i64 4
%3681 = bitcast float* %3680 to <4 x float>*
%3682 = load <4 x float>, <4 x float>* %3681
%3683 = getelementptr inbounds float, float* %3603, i64 %3675
%3684 = bitcast float* %3683 to <4 x float>*
store <4 x float> %3679, <4 x float>* %3684
%3685 = getelementptr inbounds float, float* %3683, i64 4
%3686 = bitcast float* %3685 to <4 x float>*
store <4 x float> %3682, <4 x float>* %3686
%3687 = add nuw i64 %3675, 8
%3688 = add i64 %3676, 1
%3689 = icmp eq i64 %3688, %3618
br i1 %3689, label %3690, label %3674
3690: ; preds = %3674, %3671
%3691 = icmp eq i64 %3614, %3604
br i1 %3691, label %4771, label %3692
3692: ; preds = %3606, %3601, %3690
%3693 = phi i64 [ 0, %3606 ], [ 0, %3601 ], [ %3614, %3690 ]
%3694 = xor i64 %3693, -1
%3695 = add nsw i64 %3694, %3604
%3696 = and i64 %3604, 3
%3697 = icmp eq i64 %3696, 0
br i1 %3697, label %3707, label %3698
3698: ; preds = %3692, %3698
%3699 = phi i64 [ %3704, %3698 ], [ %3693, %3692 ]
%3700 = phi i64 [ %3705, %3698 ], [ 0, %3692 ]
%3701 = getelementptr inbounds float, float* %3602, i64 %3699
%3702 = load float, float* %3701
%3703 = getelementptr inbounds float, float* %3603, i64 %3699
store float %3702, float* %3703
%3704 = add nuw nsw i64 %3699, 1
%3705 = add i64 %3700, 1
%3706 = icmp eq i64 %3705, %3696
br i1 %3706, label %3707, label %3698
3707: ; preds = %3698, %3692
%3708 = phi i64 [ %3693, %3692 ], [ %3704, %3698 ]
%3709 = icmp ult i64 %3695, 3
br i1 %3709, label %4771, label %4123
3710: ; preds = %3531
%3711 = icmp sgt i32 %4, 0
br i1 %3711, label %3712, label %4771
3712: ; preds = %3710
%3713 = bitcast i8* %0 to float*
%3714 = bitcast i8* %2 to i32*
%3715 = zext i32 %4 to i64
%3716 = icmp ult i32 %4, 8
br i1 %3716, label %3775, label %3717
3717: ; preds = %3712
%3718 = and i64 %3715, 4294967288
%3719 = add nsw i64 %3718, -8
%3720 = lshr exact i64 %3719, 3
%3721 = add nuw nsw i64 %3720, 1
%3722 = and i64 %3721, 1
%3723 = icmp eq i64 %3719, 0
br i1 %3723, label %3757, label %3724
3724: ; preds = %3717
%3725 = and i64 %3721, 4611686018427387902
br label %3726
3726: ; preds = %3726, %3724
%3727 = phi i64 [ 0, %3724 ], [ %3754, %3726 ]
%3728 = phi i64 [ 0, %3724 ], [ %3755, %3726 ]
%3729 = getelementptr inbounds float, float* %3713, i64 %3727
%3730 = bitcast float* %3729 to <4 x float>*
%3731 = load <4 x float>, <4 x float>* %3730
%3732 = getelementptr inbounds float, float* %3729, i64 4
%3733 = bitcast float* %3732 to <4 x float>*
%3734 = load <4 x float>, <4 x float>* %3733
%3735 = fptoui <4 x float> %3731 to <4 x i32>
%3736 = fptoui <4 x float> %3734 to <4 x i32>
%3737 = getelementptr inbounds i32, i32* %3714, i64 %3727
%3738 = bitcast i32* %3737 to <4 x i32>*
store <4 x i32> %3735, <4 x i32>* %3738
%3739 = getelementptr inbounds i32, i32* %3737, i64 4
%3740 = bitcast i32* %3739 to <4 x i32>*
store <4 x i32> %3736, <4 x i32>* %3740
%3741 = or i64 %3727, 8
%3742 = getelementptr inbounds float, float* %3713, i64 %3741
%3743 = bitcast float* %3742 to <4 x float>*
%3744 = load <4 x float>, <4 x float>* %3743
%3745 = getelementptr inbounds float, float* %3742, i64 4
%3746 = bitcast float* %3745 to <4 x float>*
%3747 = load <4 x float>, <4 x float>* %3746
%3748 = fptoui <4 x float> %3744 to <4 x i32>
%3749 = fptoui <4 x float> %3747 to <4 x i32>
%3750 = getelementptr inbounds i32, i32* %3714, i64 %3741
%3751 = bitcast i32* %3750 to <4 x i32>*
store <4 x i32> %3748, <4 x i32>* %3751
%3752 = getelementptr inbounds i32, i32* %3750, i64 4
%3753 = bitcast i32* %3752 to <4 x i32>*
store <4 x i32> %3749, <4 x i32>* %3753
%3754 = add nuw i64 %3727, 16
%3755 = add i64 %3728, 2
%3756 = icmp eq i64 %3755, %3725
br i1 %3756, label %3757, label %3726
3757: ; preds = %3726, %3717
%3758 = phi i64 [ 0, %3717 ], [ %3754, %3726 ]
%3759 = icmp eq i64 %3722, 0
br i1 %3759, label %3773, label %3760
3760: ; preds = %3757
%3761 = getelementptr inbounds float, float* %3713, i64 %3758
%3762 = bitcast float* %3761 to <4 x float>*
%3763 = load <4 x float>, <4 x float>* %3762
%3764 = getelementptr inbounds float, float* %3761, i64 4
%3765 = bitcast float* %3764 to <4 x float>*
%3766 = load <4 x float>, <4 x float>* %3765
%3767 = fptoui <4 x float> %3763 to <4 x i32>
%3768 = fptoui <4 x float> %3766 to <4 x i32>
%3769 = getelementptr inbounds i32, i32* %3714, i64 %3758
%3770 = bitcast i32* %3769 to <4 x i32>*
store <4 x i32> %3767, <4 x i32>* %3770
%3771 = getelementptr inbounds i32, i32* %3769, i64 4
%3772 = bitcast i32* %3771 to <4 x i32>*
store <4 x i32> %3768, <4 x i32>* %3772
br label %3773
3773: ; preds = %3757, %3760
%3774 = icmp eq i64 %3718, %3715
br i1 %3774, label %4771, label %3775
3775: ; preds = %3712, %3773
%3776 = phi i64 [ 0, %3712 ], [ %3718, %3773 ]
br label %4115
3777: ; preds = %3531
%3778 = icmp sgt i32 %4, 0
br i1 %3778, label %3779, label %4771
3779: ; preds = %3777
%3780 = bitcast i8* %0 to float*
%3781 = bitcast i8* %2 to i16*
%3782 = zext i32 %4 to i64
%3783 = icmp ult i32 %4, 8
br i1 %3783, label %3842, label %3784
3784: ; preds = %3779
%3785 = and i64 %3782, 4294967288
%3786 = add nsw i64 %3785, -8
%3787 = lshr exact i64 %3786, 3
%3788 = add nuw nsw i64 %3787, 1
%3789 = and i64 %3788, 1
%3790 = icmp eq i64 %3786, 0
br i1 %3790, label %3824, label %3791
3791: ; preds = %3784
%3792 = and i64 %3788, 4611686018427387902
br label %3793
3793: ; preds = %3793, %3791
%3794 = phi i64 [ 0, %3791 ], [ %3821, %3793 ]
%3795 = phi i64 [ 0, %3791 ], [ %3822, %3793 ]
%3796 = getelementptr inbounds float, float* %3780, i64 %3794
%3797 = bitcast float* %3796 to <4 x float>*
%3798 = load <4 x float>, <4 x float>* %3797
%3799 = getelementptr inbounds float, float* %3796, i64 4
%3800 = bitcast float* %3799 to <4 x float>*
%3801 = load <4 x float>, <4 x float>* %3800
%3802 = fptoui <4 x float> %3798 to <4 x i16>
%3803 = fptoui <4 x float> %3801 to <4 x i16>
%3804 = getelementptr inbounds i16, i16* %3781, i64 %3794
%3805 = bitcast i16* %3804 to <4 x i16>*
store <4 x i16> %3802, <4 x i16>* %3805
%3806 = getelementptr inbounds i16, i16* %3804, i64 4
%3807 = bitcast i16* %3806 to <4 x i16>*
store <4 x i16> %3803, <4 x i16>* %3807
%3808 = or i64 %3794, 8
%3809 = getelementptr inbounds float, float* %3780, i64 %3808
%3810 = bitcast float* %3809 to <4 x float>*
%3811 = load <4 x float>, <4 x float>* %3810
%3812 = getelementptr inbounds float, float* %3809, i64 4
%3813 = bitcast float* %3812 to <4 x float>*
%3814 = load <4 x float>, <4 x float>* %3813
%3815 = fptoui <4 x float> %3811 to <4 x i16>
%3816 = fptoui <4 x float> %3814 to <4 x i16>
%3817 = getelementptr inbounds i16, i16* %3781, i64 %3808
%3818 = bitcast i16* %3817 to <4 x i16>*
store <4 x i16> %3815, <4 x i16>* %3818
%3819 = getelementptr inbounds i16, i16* %3817, i64 4
%3820 = bitcast i16* %3819 to <4 x i16>*
store <4 x i16> %3816, <4 x i16>* %3820
%3821 = add nuw i64 %3794, 16
%3822 = add i64 %3795, 2
%3823 = icmp eq i64 %3822, %3792
br i1 %3823, label %3824, label %3793
3824: ; preds = %3793, %3784
%3825 = phi i64 [ 0, %3784 ], [ %3821, %3793 ]
%3826 = icmp eq i64 %3789, 0
br i1 %3826, label %3840, label %3827
3827: ; preds = %3824
%3828 = getelementptr inbounds float, float* %3780, i64 %3825
%3829 = bitcast float* %3828 to <4 x float>*
%3830 = load <4 x float>, <4 x float>* %3829
%3831 = getelementptr inbounds float, float* %3828, i64 4
%3832 = bitcast float* %3831 to <4 x float>*
%3833 = load <4 x float>, <4 x float>* %3832
%3834 = fptoui <4 x float> %3830 to <4 x i16>
%3835 = fptoui <4 x float> %3833 to <4 x i16>
%3836 = getelementptr inbounds i16, i16* %3781, i64 %3825
%3837 = bitcast i16* %3836 to <4 x i16>*
store <4 x i16> %3834, <4 x i16>* %3837
%3838 = getelementptr inbounds i16, i16* %3836, i64 4
%3839 = bitcast i16* %3838 to <4 x i16>*
store <4 x i16> %3835, <4 x i16>* %3839
br label %3840
3840: ; preds = %3824, %3827
%3841 = icmp eq i64 %3785, %3782
br i1 %3841, label %4771, label %3842
3842: ; preds = %3779, %3840
%3843 = phi i64 [ 0, %3779 ], [ %3785, %3840 ]
br label %4032
3844: ; preds = %3531
%3845 = icmp sgt i32 %4, 0
br i1 %3845, label %3846, label %4771
3846: ; preds = %3844
%3847 = bitcast i8* %0 to float*
%3848 = bitcast i8* %2 to i16*
%3849 = zext i32 %4 to i64
%3850 = icmp ult i32 %4, 8
br i1 %3850, label %3909, label %3851
3851: ; preds = %3846
%3852 = and i64 %3849, 4294967288
%3853 = add nsw i64 %3852, -8
%3854 = lshr exact i64 %3853, 3
%3855 = add nuw nsw i64 %3854, 1
%3856 = and i64 %3855, 1
%3857 = icmp eq i64 %3853, 0
br i1 %3857, label %3891, label %3858
3858: ; preds = %3851
%3859 = and i64 %3855, 4611686018427387902
br label %3860
3860: ; preds = %3860, %3858
%3861 = phi i64 [ 0, %3858 ], [ %3888, %3860 ]
%3862 = phi i64 [ 0, %3858 ], [ %3889, %3860 ]
%3863 = getelementptr inbounds float, float* %3847, i64 %3861
%3864 = bitcast float* %3863 to <4 x float>*
%3865 = load <4 x float>, <4 x float>* %3864
%3866 = getelementptr inbounds float, float* %3863, i64 4
%3867 = bitcast float* %3866 to <4 x float>*
%3868 = load <4 x float>, <4 x float>* %3867
%3869 = fptosi <4 x float> %3865 to <4 x i16>
%3870 = fptosi <4 x float> %3868 to <4 x i16>
%3871 = getelementptr inbounds i16, i16* %3848, i64 %3861
%3872 = bitcast i16* %3871 to <4 x i16>*
store <4 x i16> %3869, <4 x i16>* %3872
%3873 = getelementptr inbounds i16, i16* %3871, i64 4
%3874 = bitcast i16* %3873 to <4 x i16>*
store <4 x i16> %3870, <4 x i16>* %3874
%3875 = or i64 %3861, 8
%3876 = getelementptr inbounds float, float* %3847, i64 %3875
%3877 = bitcast float* %3876 to <4 x float>*
%3878 = load <4 x float>, <4 x float>* %3877
%3879 = getelementptr inbounds float, float* %3876, i64 4
%3880 = bitcast float* %3879 to <4 x float>*
%3881 = load <4 x float>, <4 x float>* %3880
%3882 = fptosi <4 x float> %3878 to <4 x i16>
%3883 = fptosi <4 x float> %3881 to <4 x i16>
%3884 = getelementptr inbounds i16, i16* %3848, i64 %3875
%3885 = bitcast i16* %3884 to <4 x i16>*
store <4 x i16> %3882, <4 x i16>* %3885
%3886 = getelementptr inbounds i16, i16* %3884, i64 4
%3887 = bitcast i16* %3886 to <4 x i16>*
store <4 x i16> %3883, <4 x i16>* %3887
%3888 = add nuw i64 %3861, 16
%3889 = add i64 %3862, 2
%3890 = icmp eq i64 %3889, %3859
br i1 %3890, label %3891, label %3860
3891: ; preds = %3860, %3851
%3892 = phi i64 [ 0, %3851 ], [ %3888, %3860 ]
%3893 = icmp eq i64 %3856, 0
br i1 %3893, label %3907, label %3894
3894: ; preds = %3891
%3895 = getelementptr inbounds float, float* %3847, i64 %3892
%3896 = bitcast float* %3895 to <4 x float>*
%3897 = load <4 x float>, <4 x float>* %3896
%3898 = getelementptr inbounds float, float* %3895, i64 4
%3899 = bitcast float* %3898 to <4 x float>*
%3900 = load <4 x float>, <4 x float>* %3899
%3901 = fptosi <4 x float> %3897 to <4 x i16>
%3902 = fptosi <4 x float> %3900 to <4 x i16>
%3903 = getelementptr inbounds i16, i16* %3848, i64 %3892
%3904 = bitcast i16* %3903 to <4 x i16>*
store <4 x i16> %3901, <4 x i16>* %3904
%3905 = getelementptr inbounds i16, i16* %3903, i64 4
%3906 = bitcast i16* %3905 to <4 x i16>*
store <4 x i16> %3902, <4 x i16>* %3906
br label %3907
3907: ; preds = %3891, %3894
%3908 = icmp eq i64 %3852, %3849
br i1 %3908, label %4771, label %3909
3909: ; preds = %3846, %3907
%3910 = phi i64 [ 0, %3846 ], [ %3852, %3907 ]
br label %4024
3911: ; preds = %3531
%3912 = icmp sgt i32 %4, 0
br i1 %3912, label %3913, label %4771
3913: ; preds = %3911
%3914 = bitcast i8* %0 to float*
%3915 = zext i32 %4 to i64
%3916 = icmp ult i32 %4, 8
br i1 %3916, label %3982, label %3917
3917: ; preds = %3913
%3918 = getelementptr i8, i8* %2, i64 %3915
%3919 = shl nuw nsw i64 %3915, 2
%3920 = getelementptr i8, i8* %0, i64 %3919
%3921 = icmp ugt i8* %3920, %2
%3922 = icmp ugt i8* %3918, %0
%3923 = and i1 %3921, %3922
br i1 %3923, label %3982, label %3924
3924: ; preds = %3917
%3925 = and i64 %3915, 4294967288
%3926 = add nsw i64 %3925, -8
%3927 = lshr exact i64 %3926, 3
%3928 = add nuw nsw i64 %3927, 1
%3929 = and i64 %3928, 1
%3930 = icmp eq i64 %3926, 0
br i1 %3930, label %3964, label %3931
3931: ; preds = %3924
%3932 = and i64 %3928, 4611686018427387902
br label %3933
3933: ; preds = %3933, %3931
%3934 = phi i64 [ 0, %3931 ], [ %3961, %3933 ]
%3935 = phi i64 [ 0, %3931 ], [ %3962, %3933 ]
%3936 = getelementptr inbounds float, float* %3914, i64 %3934
%3937 = bitcast float* %3936 to <4 x float>*
%3938 = load <4 x float>, <4 x float>* %3937
%3939 = getelementptr inbounds float, float* %3936, i64 4
%3940 = bitcast float* %3939 to <4 x float>*
%3941 = load <4 x float>, <4 x float>* %3940
%3942 = fptoui <4 x float> %3938 to <4 x i8>
%3943 = fptoui <4 x float> %3941 to <4 x i8>
%3944 = getelementptr inbounds i8, i8* %2, i64 %3934
%3945 = bitcast i8* %3944 to <4 x i8>*
store <4 x i8> %3942, <4 x i8>* %3945
%3946 = getelementptr inbounds i8, i8* %3944, i64 4
%3947 = bitcast i8* %3946 to <4 x i8>*
store <4 x i8> %3943, <4 x i8>* %3947
%3948 = or i64 %3934, 8
%3949 = getelementptr inbounds float, float* %3914, i64 %3948
%3950 = bitcast float* %3949 to <4 x float>*
%3951 = load <4 x float>, <4 x float>* %3950
%3952 = getelementptr inbounds float, float* %3949, i64 4
%3953 = bitcast float* %3952 to <4 x float>*
%3954 = load <4 x float>, <4 x float>* %3953
%3955 = fptoui <4 x float> %3951 to <4 x i8>
%3956 = fptoui <4 x float> %3954 to <4 x i8>
%3957 = getelementptr inbounds i8, i8* %2, i64 %3948
%3958 = bitcast i8* %3957 to <4 x i8>*
store <4 x i8> %3955, <4 x i8>* %3958
%3959 = getelementptr inbounds i8, i8* %3957, i64 4
%3960 = bitcast i8* %3959 to <4 x i8>*
store <4 x i8> %3956, <4 x i8>* %3960
%3961 = add nuw i64 %3934, 16
%3962 = add i64 %3935, 2
%3963 = icmp eq i64 %3962, %3932
br i1 %3963, label %3964, label %3933
3964: ; preds = %3933, %3924
%3965 = phi i64 [ 0, %3924 ], [ %3961, %3933 ]
%3966 = icmp eq i64 %3929, 0
br i1 %3966, label %3980, label %3967
3967: ; preds = %3964
%3968 = getelementptr inbounds float, float* %3914, i64 %3965
%3969 = bitcast float* %3968 to <4 x float>*
%3970 = load <4 x float>, <4 x float>* %3969
%3971 = getelementptr inbounds float, float* %3968, i64 4
%3972 = bitcast float* %3971 to <4 x float>*
%3973 = load <4 x float>, <4 x float>* %3972
%3974 = fptoui <4 x float> %3970 to <4 x i8>
%3975 = fptoui <4 x float> %3973 to <4 x i8>
%3976 = getelementptr inbounds i8, i8* %2, i64 %3965
%3977 = bitcast i8* %3976 to <4 x i8>*
store <4 x i8> %3974, <4 x i8>* %3977
%3978 = getelementptr inbounds i8, i8* %3976, i64 4
%3979 = bitcast i8* %3978 to <4 x i8>*
store <4 x i8> %3975, <4 x i8>* %3979
br label %3980
3980: ; preds = %3964, %3967
%3981 = icmp eq i64 %3925, %3915
br i1 %3981, label %4771, label %3982
3982: ; preds = %3917, %3913, %3980
%3983 = phi i64 [ 0, %3917 ], [ 0, %3913 ], [ %3925, %3980 ]
%3984 = xor i64 %3983, -1
%3985 = add nsw i64 %3984, %3915
%3986 = and i64 %3915, 3
%3987 = icmp eq i64 %3986, 0
br i1 %3987, label %3998, label %3988
3988: ; preds = %3982, %3988
%3989 = phi i64 [ %3995, %3988 ], [ %3983, %3982 ]
%3990 = phi i64 [ %3996, %3988 ], [ 0, %3982 ]
%3991 = getelementptr inbounds float, float* %3914, i64 %3989
%3992 = load float, float* %3991
%3993 = fptoui float %3992 to i8
%3994 = getelementptr inbounds i8, i8* %2, i64 %3989
store i8 %3993, i8* %3994
%3995 = add nuw nsw i64 %3989, 1
%3996 = add i64 %3990, 1
%3997 = icmp eq i64 %3996, %3986
br i1 %3997, label %3998, label %3988
3998: ; preds = %3988, %3982
%3999 = phi i64 [ %3983, %3982 ], [ %3995, %3988 ]
%4000 = icmp ult i64 %3985, 3
br i1 %4000, label %4771, label %4001
4001: ; preds = %3998, %4001
%4002 = phi i64 [ %4022, %4001 ], [ %3999, %3998 ]
%4003 = getelementptr inbounds float, float* %3914, i64 %4002
%4004 = load float, float* %4003
%4005 = fptoui float %4004 to i8
%4006 = getelementptr inbounds i8, i8* %2, i64 %4002
store i8 %4005, i8* %4006
%4007 = add nuw nsw i64 %4002, 1
%4008 = getelementptr inbounds float, float* %3914, i64 %4007
%4009 = load float, float* %4008
%4010 = fptoui float %4009 to i8
%4011 = getelementptr inbounds i8, i8* %2, i64 %4007
store i8 %4010, i8* %4011
%4012 = add nuw nsw i64 %4002, 2
%4013 = getelementptr inbounds float, float* %3914, i64 %4012
%4014 = load float, float* %4013
%4015 = fptoui float %4014 to i8
%4016 = getelementptr inbounds i8, i8* %2, i64 %4012
store i8 %4015, i8* %4016
%4017 = add nuw nsw i64 %4002, 3
%4018 = getelementptr inbounds float, float* %3914, i64 %4017
%4019 = load float, float* %4018
%4020 = fptoui float %4019 to i8
%4021 = getelementptr inbounds i8, i8* %2, i64 %4017
store i8 %4020, i8* %4021
%4022 = add nuw nsw i64 %4002, 4
%4023 = icmp eq i64 %4022, %3915
br i1 %4023, label %4771, label %4001
4024: ; preds = %3909, %4024
%4025 = phi i64 [ %4030, %4024 ], [ %3910, %3909 ]
%4026 = getelementptr inbounds float, float* %3847, i64 %4025
%4027 = load float, float* %4026
%4028 = fptosi float %4027 to i16
%4029 = getelementptr inbounds i16, i16* %3848, i64 %4025
store i16 %4028, i16* %4029
%4030 = add nuw nsw i64 %4025, 1
%4031 = icmp eq i64 %4030, %3849
br i1 %4031, label %4771, label %4024
4032: ; preds = %3842, %4032
%4033 = phi i64 [ %4038, %4032 ], [ %3843, %3842 ]
%4034 = getelementptr inbounds float, float* %3780, i64 %4033
%4035 = load float, float* %4034
%4036 = fptoui float %4035 to i16
%4037 = getelementptr inbounds i16, i16* %3781, i64 %4033
store i16 %4036, i16* %4037
%4038 = add nuw nsw i64 %4033, 1
%4039 = icmp eq i64 %4038, %3782
br i1 %4039, label %4771, label %4032
4040: ; preds = %3531, %3531
%4041 = icmp sgt i32 %4, 0
br i1 %4041, label %4042, label %4771
4042: ; preds = %4040
%4043 = bitcast i8* %0 to float*
%4044 = bitcast i8* %2 to i32*
%4045 = zext i32 %4 to i64
%4046 = icmp ult i32 %4, 8
br i1 %4046, label %4105, label %4047
4047: ; preds = %4042
%4048 = and i64 %4045, 4294967288
%4049 = add nsw i64 %4048, -8
%4050 = lshr exact i64 %4049, 3
%4051 = add nuw nsw i64 %4050, 1
%4052 = and i64 %4051, 1
%4053 = icmp eq i64 %4049, 0
br i1 %4053, label %4087, label %4054
4054: ; preds = %4047
%4055 = and i64 %4051, 4611686018427387902
br label %4056
4056: ; preds = %4056, %4054
%4057 = phi i64 [ 0, %4054 ], [ %4084, %4056 ]
%4058 = phi i64 [ 0, %4054 ], [ %4085, %4056 ]
%4059 = getelementptr inbounds float, float* %4043, i64 %4057
%4060 = bitcast float* %4059 to <4 x float>*
%4061 = load <4 x float>, <4 x float>* %4060
%4062 = getelementptr inbounds float, float* %4059, i64 4
%4063 = bitcast float* %4062 to <4 x float>*
%4064 = load <4 x float>, <4 x float>* %4063
%4065 = fptosi <4 x float> %4061 to <4 x i32>
%4066 = fptosi <4 x float> %4064 to <4 x i32>
%4067 = getelementptr inbounds i32, i32* %4044, i64 %4057
%4068 = bitcast i32* %4067 to <4 x i32>*
store <4 x i32> %4065, <4 x i32>* %4068
%4069 = getelementptr inbounds i32, i32* %4067, i64 4
%4070 = bitcast i32* %4069 to <4 x i32>*
store <4 x i32> %4066, <4 x i32>* %4070
%4071 = or i64 %4057, 8
%4072 = getelementptr inbounds float, float* %4043, i64 %4071
%4073 = bitcast float* %4072 to <4 x float>*
%4074 = load <4 x float>, <4 x float>* %4073
%4075 = getelementptr inbounds float, float* %4072, i64 4
%4076 = bitcast float* %4075 to <4 x float>*
%4077 = load <4 x float>, <4 x float>* %4076
%4078 = fptosi <4 x float> %4074 to <4 x i32>
%4079 = fptosi <4 x float> %4077 to <4 x i32>
%4080 = getelementptr inbounds i32, i32* %4044, i64 %4071
%4081 = bitcast i32* %4080 to <4 x i32>*
store <4 x i32> %4078, <4 x i32>* %4081
%4082 = getelementptr inbounds i32, i32* %4080, i64 4
%4083 = bitcast i32* %4082 to <4 x i32>*
store <4 x i32> %4079, <4 x i32>* %4083
%4084 = add nuw i64 %4057, 16
%4085 = add i64 %4058, 2
%4086 = icmp eq i64 %4085, %4055
br i1 %4086, label %4087, label %4056
4087: ; preds = %4056, %4047
%4088 = phi i64 [ 0, %4047 ], [ %4084, %4056 ]
%4089 = icmp eq i64 %4052, 0
br i1 %4089, label %4103, label %4090
4090: ; preds = %4087
%4091 = getelementptr inbounds float, float* %4043, i64 %4088
%4092 = bitcast float* %4091 to <4 x float>*
%4093 = load <4 x float>, <4 x float>* %4092
%4094 = getelementptr inbounds float, float* %4091, i64 4
%4095 = bitcast float* %4094 to <4 x float>*
%4096 = load <4 x float>, <4 x float>* %4095
%4097 = fptosi <4 x float> %4093 to <4 x i32>
%4098 = fptosi <4 x float> %4096 to <4 x i32>
%4099 = getelementptr inbounds i32, i32* %4044, i64 %4088
%4100 = bitcast i32* %4099 to <4 x i32>*
store <4 x i32> %4097, <4 x i32>* %4100
%4101 = getelementptr inbounds i32, i32* %4099, i64 4
%4102 = bitcast i32* %4101 to <4 x i32>*
store <4 x i32> %4098, <4 x i32>* %4102
br label %4103
4103: ; preds = %4087, %4090
%4104 = icmp eq i64 %4048, %4045
br i1 %4104, label %4771, label %4105
4105: ; preds = %4042, %4103
%4106 = phi i64 [ 0, %4042 ], [ %4048, %4103 ]
br label %4107
4107: ; preds = %4105, %4107
%4108 = phi i64 [ %4113, %4107 ], [ %4106, %4105 ]
%4109 = getelementptr inbounds float, float* %4043, i64 %4108
%4110 = load float, float* %4109
%4111 = fptosi float %4110 to i32
%4112 = getelementptr inbounds i32, i32* %4044, i64 %4108
store i32 %4111, i32* %4112
%4113 = add nuw nsw i64 %4108, 1
%4114 = icmp eq i64 %4113, %4045
br i1 %4114, label %4771, label %4107
4115: ; preds = %3775, %4115
%4116 = phi i64 [ %4121, %4115 ], [ %3776, %3775 ]
%4117 = getelementptr inbounds float, float* %3713, i64 %4116
%4118 = load float, float* %4117
%4119 = fptoui float %4118 to i32
%4120 = getelementptr inbounds i32, i32* %3714, i64 %4116
store i32 %4119, i32* %4120
%4121 = add nuw nsw i64 %4116, 1
%4122 = icmp eq i64 %4121, %3715
br i1 %4122, label %4771, label %4115
4123: ; preds = %3707, %4123
%4124 = phi i64 [ %4140, %4123 ], [ %3708, %3707 ]
%4125 = getelementptr inbounds float, float* %3602, i64 %4124
%4126 = load float, float* %4125
%4127 = getelementptr inbounds float, float* %3603, i64 %4124
store float %4126, float* %4127
%4128 = add nuw nsw i64 %4124, 1
%4129 = getelementptr inbounds float, float* %3602, i64 %4128
%4130 = load float, float* %4129
%4131 = getelementptr inbounds float, float* %3603, i64 %4128
store float %4130, float* %4131
%4132 = add nuw nsw i64 %4124, 2
%4133 = getelementptr inbounds float, float* %3602, i64 %4132
%4134 = load float, float* %4133
%4135 = getelementptr inbounds float, float* %3603, i64 %4132
store float %4134, float* %4135
%4136 = add nuw nsw i64 %4124, 3
%4137 = getelementptr inbounds float, float* %3602, i64 %4136
%4138 = load float, float* %4137
%4139 = getelementptr inbounds float, float* %3603, i64 %4136
store float %4138, float* %4139
%4140 = add nuw nsw i64 %4124, 4
%4141 = icmp eq i64 %4140, %3604
br i1 %4141, label %4771, label %4123
4142: ; preds = %3597, %4142
%4143 = phi i64 [ %4148, %4142 ], [ %3598, %3597 ]
%4144 = getelementptr inbounds float, float* %3535, i64 %4143
%4145 = load float, float* %4144
%4146 = fpext float %4145 to double
%4147 = getelementptr inbounds double, double* %3536, i64 %4143
store double %4146, double* %4147
%4148 = add nuw nsw i64 %4143, 1
%4149 = icmp eq i64 %4148, %3537
br i1 %4149, label %4771, label %4142
4150: ; preds = %8
switch i32 %6, label %4771 [
i32 99, label %4530
i32 115, label %4463
i32 117, label %4396
i32 105, label %4659
i32 83, label %4659
i32 85, label %4329
i32 102, label %4262
i32 100, label %4151
]
4151: ; preds = %4150
%4152 = icmp sgt i32 %4, 0
br i1 %4152, label %4153, label %4771
4153: ; preds = %4151
%4154 = bitcast i8* %0 to double*
%4155 = bitcast i8* %2 to double*
%4156 = zext i32 %4 to i64
%4157 = icmp ult i32 %4, 4
br i1 %4157, label %4244, label %4158
4158: ; preds = %4153
%4159 = shl nuw nsw i64 %4156, 3
%4160 = getelementptr i8, i8* %2, i64 %4159
%4161 = getelementptr i8, i8* %0, i64 %4159
%4162 = icmp ugt i8* %4161, %2
%4163 = icmp ugt i8* %4160, %0
%4164 = and i1 %4162, %4163
br i1 %4164, label %4244, label %4165
4165: ; preds = %4158
%4166 = and i64 %4156, 4294967292
%4167 = add nsw i64 %4166, -4
%4168 = lshr exact i64 %4167, 2
%4169 = add nuw nsw i64 %4168, 1
%4170 = and i64 %4169, 3
%4171 = icmp ult i64 %4167, 12
br i1 %4171, label %4223, label %4172
4172: ; preds = %4165
%4173 = and i64 %4169, 9223372036854775804
br label %4174
4174: ; preds = %4174, %4172
%4175 = phi i64 [ 0, %4172 ], [ %4220, %4174 ]
%4176 = phi i64 [ 0, %4172 ], [ %4221, %4174 ]
%4177 = getelementptr inbounds double, double* %4154, i64 %4175
%4178 = bitcast double* %4177 to <2 x double>*
%4179 = load <2 x double>, <2 x double>* %4178
%4180 = getelementptr inbounds double, double* %4177, i64 2
%4181 = bitcast double* %4180 to <2 x double>*
%4182 = load <2 x double>, <2 x double>* %4181
%4183 = getelementptr inbounds double, double* %4155, i64 %4175
%4184 = bitcast double* %4183 to <2 x double>*
store <2 x double> %4179, <2 x double>* %4184
%4185 = getelementptr inbounds double, double* %4183, i64 2
%4186 = bitcast double* %4185 to <2 x double>*
store <2 x double> %4182, <2 x double>* %4186
%4187 = or i64 %4175, 4
%4188 = getelementptr inbounds double, double* %4154, i64 %4187
%4189 = bitcast double* %4188 to <2 x double>*
%4190 = load <2 x double>, <2 x double>* %4189
%4191 = getelementptr inbounds double, double* %4188, i64 2
%4192 = bitcast double* %4191 to <2 x double>*
%4193 = load <2 x double>, <2 x double>* %4192
%4194 = getelementptr inbounds double, double* %4155, i64 %4187
%4195 = bitcast double* %4194 to <2 x double>*
store <2 x double> %4190, <2 x double>* %4195
%4196 = getelementptr inbounds double, double* %4194, i64 2
%4197 = bitcast double* %4196 to <2 x double>*
store <2 x double> %4193, <2 x double>* %4197
%4198 = or i64 %4175, 8
%4199 = getelementptr inbounds double, double* %4154, i64 %4198
%4200 = bitcast double* %4199 to <2 x double>*
%4201 = load <2 x double>, <2 x double>* %4200
%4202 = getelementptr inbounds double, double* %4199, i64 2
%4203 = bitcast double* %4202 to <2 x double>*
%4204 = load <2 x double>, <2 x double>* %4203
%4205 = getelementptr inbounds double, double* %4155, i64 %4198
%4206 = bitcast double* %4205 to <2 x double>*
store <2 x double> %4201, <2 x double>* %4206
%4207 = getelementptr inbounds double, double* %4205, i64 2
%4208 = bitcast double* %4207 to <2 x double>*
store <2 x double> %4204, <2 x double>* %4208
%4209 = or i64 %4175, 12
%4210 = getelementptr inbounds double, double* %4154, i64 %4209
%4211 = bitcast double* %4210 to <2 x double>*
%4212 = load <2 x double>, <2 x double>* %4211
%4213 = getelementptr inbounds double, double* %4210, i64 2
%4214 = bitcast double* %4213 to <2 x double>*
%4215 = load <2 x double>, <2 x double>* %4214
%4216 = getelementptr inbounds double, double* %4155, i64 %4209
%4217 = bitcast double* %4216 to <2 x double>*
store <2 x double> %4212, <2 x double>* %4217
%4218 = getelementptr inbounds double, double* %4216, i64 2
%4219 = bitcast double* %4218 to <2 x double>*
store <2 x double> %4215, <2 x double>* %4219
%4220 = add nuw i64 %4175, 16
%4221 = add nuw i64 %4176, 4
%4222 = icmp eq i64 %4221, %4173
br i1 %4222, label %4223, label %4174
4223: ; preds = %4174, %4165
%4224 = phi i64 [ 0, %4165 ], [ %4220, %4174 ]
%4225 = icmp eq i64 %4170, 0
br i1 %4225, label %4242, label %4226
4226: ; preds = %4223, %4226
%4227 = phi i64 [ %4239, %4226 ], [ %4224, %4223 ]
%4228 = phi i64 [ %4240, %4226 ], [ 0, %4223 ]
%4229 = getelementptr inbounds double, double* %4154, i64 %4227
%4230 = bitcast double* %4229 to <2 x double>*
%4231 = load <2 x double>, <2 x double>* %4230
%4232 = getelementptr inbounds double, double* %4229, i64 2
%4233 = bitcast double* %4232 to <2 x double>*
%4234 = load <2 x double>, <2 x double>* %4233
%4235 = getelementptr inbounds double, double* %4155, i64 %4227
%4236 = bitcast double* %4235 to <2 x double>*
store <2 x double> %4231, <2 x double>* %4236
%4237 = getelementptr inbounds double, double* %4235, i64 2
%4238 = bitcast double* %4237 to <2 x double>*
store <2 x double> %4234, <2 x double>* %4238
%4239 = add nuw i64 %4227, 4
%4240 = add i64 %4228, 1
%4241 = icmp eq i64 %4240, %4170
br i1 %4241, label %4242, label %4226
4242: ; preds = %4226, %4223
%4243 = icmp eq i64 %4166, %4156
br i1 %4243, label %4771, label %4244
4244: ; preds = %4158, %4153, %4242
%4245 = phi i64 [ 0, %4158 ], [ 0, %4153 ], [ %4166, %4242 ]
%4246 = xor i64 %4245, -1
%4247 = add nsw i64 %4246, %4156
%4248 = and i64 %4156, 3
%4249 = icmp eq i64 %4248, 0
br i1 %4249, label %4259, label %4250
4250: ; preds = %4244, %4250
%4251 = phi i64 [ %4256, %4250 ], [ %4245, %4244 ]
%4252 = phi i64 [ %4257, %4250 ], [ 0, %4244 ]
%4253 = getelementptr inbounds double, double* %4154, i64 %4251
%4254 = load double, double* %4253
%4255 = getelementptr inbounds double, double* %4155, i64 %4251
store double %4254, double* %4255
%4256 = add nuw nsw i64 %4251, 1
%4257 = add i64 %4252, 1
%4258 = icmp eq i64 %4257, %4248
br i1 %4258, label %4259, label %4250
4259: ; preds = %4250, %4244
%4260 = phi i64 [ %4245, %4244 ], [ %4256, %4250 ]
%4261 = icmp ult i64 %4247, 3
br i1 %4261, label %4771, label %4750
4262: ; preds = %4150
%4263 = icmp sgt i32 %4, 0
br i1 %4263, label %4264, label %4771
4264: ; preds = %4262
%4265 = bitcast i8* %0 to double*
%4266 = bitcast i8* %2 to float*
%4267 = zext i32 %4 to i64
%4268 = icmp ult i32 %4, 4
br i1 %4268, label %4327, label %4269
4269: ; preds = %4264
%4270 = and i64 %4267, 4294967292
%4271 = add nsw i64 %4270, -4
%4272 = lshr exact i64 %4271, 2
%4273 = add nuw nsw i64 %4272, 1
%4274 = and i64 %4273, 1
%4275 = icmp eq i64 %4271, 0
br i1 %4275, label %4309, label %4276
4276: ; preds = %4269
%4277 = and i64 %4273, 9223372036854775806
br label %4278
4278: ; preds = %4278, %4276
%4279 = phi i64 [ 0, %4276 ], [ %4306, %4278 ]
%4280 = phi i64 [ 0, %4276 ], [ %4307, %4278 ]
%4281 = getelementptr inbounds double, double* %4265, i64 %4279
%4282 = bitcast double* %4281 to <2 x double>*
%4283 = load <2 x double>, <2 x double>* %4282
%4284 = getelementptr inbounds double, double* %4281, i64 2
%4285 = bitcast double* %4284 to <2 x double>*
%4286 = load <2 x double>, <2 x double>* %4285
%4287 = fptrunc <2 x double> %4283 to <2 x float>
%4288 = fptrunc <2 x double> %4286 to <2 x float>
%4289 = getelementptr inbounds float, float* %4266, i64 %4279
%4290 = bitcast float* %4289 to <2 x float>*
store <2 x float> %4287, <2 x float>* %4290
%4291 = getelementptr inbounds float, float* %4289, i64 2
%4292 = bitcast float* %4291 to <2 x float>*
store <2 x float> %4288, <2 x float>* %4292
%4293 = or i64 %4279, 4
%4294 = getelementptr inbounds double, double* %4265, i64 %4293
%4295 = bitcast double* %4294 to <2 x double>*
%4296 = load <2 x double>, <2 x double>* %4295
%4297 = getelementptr inbounds double, double* %4294, i64 2
%4298 = bitcast double* %4297 to <2 x double>*
%4299 = load <2 x double>, <2 x double>* %4298
%4300 = fptrunc <2 x double> %4296 to <2 x float>
%4301 = fptrunc <2 x double> %4299 to <2 x float>
%4302 = getelementptr inbounds float, float* %4266, i64 %4293
%4303 = bitcast float* %4302 to <2 x float>*
store <2 x float> %4300, <2 x float>* %4303
%4304 = getelementptr inbounds float, float* %4302, i64 2
%4305 = bitcast float* %4304 to <2 x float>*
store <2 x float> %4301, <2 x float>* %4305
%4306 = add nuw i64 %4279, 8
%4307 = add i64 %4280, 2
%4308 = icmp eq i64 %4307, %4277
br i1 %4308, label %4309, label %4278
4309: ; preds = %4278, %4269
%4310 = phi i64 [ 0, %4269 ], [ %4306, %4278 ]
%4311 = icmp eq i64 %4274, 0
br i1 %4311, label %4325, label %4312
4312: ; preds = %4309
%4313 = getelementptr inbounds double, double* %4265, i64 %4310
%4314 = bitcast double* %4313 to <2 x double>*
%4315 = load <2 x double>, <2 x double>* %4314
%4316 = getelementptr inbounds double, double* %4313, i64 2
%4317 = bitcast double* %4316 to <2 x double>*
%4318 = load <2 x double>, <2 x double>* %4317
%4319 = fptrunc <2 x double> %4315 to <2 x float>
%4320 = fptrunc <2 x double> %4318 to <2 x float>
%4321 = getelementptr inbounds float, float* %4266, i64 %4310
%4322 = bitcast float* %4321 to <2 x float>*
store <2 x float> %4319, <2 x float>* %4322
%4323 = getelementptr inbounds float, float* %4321, i64 2
%4324 = bitcast float* %4323 to <2 x float>*
store <2 x float> %4320, <2 x float>* %4324
br label %4325
4325: ; preds = %4309, %4312
%4326 = icmp eq i64 %4270, %4267
br i1 %4326, label %4771, label %4327
4327: ; preds = %4264, %4325
%4328 = phi i64 [ 0, %4264 ], [ %4270, %4325 ]
br label %4742
4329: ; preds = %4150
%4330 = icmp sgt i32 %4, 0
br i1 %4330, label %4331, label %4771
4331: ; preds = %4329
%4332 = bitcast i8* %0 to double*
%4333 = bitcast i8* %2 to i32*
%4334 = zext i32 %4 to i64
%4335 = icmp ult i32 %4, 4
br i1 %4335, label %4394, label %4336
4336: ; preds = %4331
%4337 = and i64 %4334, 4294967292
%4338 = add nsw i64 %4337, -4
%4339 = lshr exact i64 %4338, 2
%4340 = add nuw nsw i64 %4339, 1
%4341 = and i64 %4340, 1
%4342 = icmp eq i64 %4338, 0
br i1 %4342, label %4376, label %4343
4343: ; preds = %4336
%4344 = and i64 %4340, 9223372036854775806
br label %4345
4345: ; preds = %4345, %4343
%4346 = phi i64 [ 0, %4343 ], [ %4373, %4345 ]
%4347 = phi i64 [ 0, %4343 ], [ %4374, %4345 ]
%4348 = getelementptr inbounds double, double* %4332, i64 %4346
%4349 = bitcast double* %4348 to <2 x double>*
%4350 = load <2 x double>, <2 x double>* %4349
%4351 = getelementptr inbounds double, double* %4348, i64 2
%4352 = bitcast double* %4351 to <2 x double>*
%4353 = load <2 x double>, <2 x double>* %4352
%4354 = fptoui <2 x double> %4350 to <2 x i32>
%4355 = fptoui <2 x double> %4353 to <2 x i32>
%4356 = getelementptr inbounds i32, i32* %4333, i64 %4346
%4357 = bitcast i32* %4356 to <2 x i32>*
store <2 x i32> %4354, <2 x i32>* %4357
%4358 = getelementptr inbounds i32, i32* %4356, i64 2
%4359 = bitcast i32* %4358 to <2 x i32>*
store <2 x i32> %4355, <2 x i32>* %4359
%4360 = or i64 %4346, 4
%4361 = getelementptr inbounds double, double* %4332, i64 %4360
%4362 = bitcast double* %4361 to <2 x double>*
%4363 = load <2 x double>, <2 x double>* %4362
%4364 = getelementptr inbounds double, double* %4361, i64 2
%4365 = bitcast double* %4364 to <2 x double>*
%4366 = load <2 x double>, <2 x double>* %4365
%4367 = fptoui <2 x double> %4363 to <2 x i32>
%4368 = fptoui <2 x double> %4366 to <2 x i32>
%4369 = getelementptr inbounds i32, i32* %4333, i64 %4360
%4370 = bitcast i32* %4369 to <2 x i32>*
store <2 x i32> %4367, <2 x i32>* %4370
%4371 = getelementptr inbounds i32, i32* %4369, i64 2
%4372 = bitcast i32* %4371 to <2 x i32>*
store <2 x i32> %4368, <2 x i32>* %4372
%4373 = add nuw i64 %4346, 8
%4374 = add i64 %4347, 2
%4375 = icmp eq i64 %4374, %4344
br i1 %4375, label %4376, label %4345
4376: ; preds = %4345, %4336
%4377 = phi i64 [ 0, %4336 ], [ %4373, %4345 ]
%4378 = icmp eq i64 %4341, 0
br i1 %4378, label %4392, label %4379
4379: ; preds = %4376
%4380 = getelementptr inbounds double, double* %4332, i64 %4377
%4381 = bitcast double* %4380 to <2 x double>*
%4382 = load <2 x double>, <2 x double>* %4381
%4383 = getelementptr inbounds double, double* %4380, i64 2
%4384 = bitcast double* %4383 to <2 x double>*
%4385 = load <2 x double>, <2 x double>* %4384
%4386 = fptoui <2 x double> %4382 to <2 x i32>
%4387 = fptoui <2 x double> %4385 to <2 x i32>
%4388 = getelementptr inbounds i32, i32* %4333, i64 %4377
%4389 = bitcast i32* %4388 to <2 x i32>*
store <2 x i32> %4386, <2 x i32>* %4389
%4390 = getelementptr inbounds i32, i32* %4388, i64 2
%4391 = bitcast i32* %4390 to <2 x i32>*
store <2 x i32> %4387, <2 x i32>* %4391
br label %4392
4392: ; preds = %4376, %4379
%4393 = icmp eq i64 %4337, %4334
br i1 %4393, label %4771, label %4394
4394: ; preds = %4331, %4392
%4395 = phi i64 [ 0, %4331 ], [ %4337, %4392 ]
br label %4734
4396: ; preds = %4150
%4397 = icmp sgt i32 %4, 0
br i1 %4397, label %4398, label %4771
4398: ; preds = %4396
%4399 = bitcast i8* %0 to double*
%4400 = bitcast i8* %2 to i16*
%4401 = zext i32 %4 to i64
%4402 = icmp ult i32 %4, 4
br i1 %4402, label %4461, label %4403
4403: ; preds = %4398
%4404 = and i64 %4401, 4294967292
%4405 = add nsw i64 %4404, -4
%4406 = lshr exact i64 %4405, 2
%4407 = add nuw nsw i64 %4406, 1
%4408 = and i64 %4407, 1
%4409 = icmp eq i64 %4405, 0
br i1 %4409, label %4443, label %4410
4410: ; preds = %4403
%4411 = and i64 %4407, 9223372036854775806
br label %4412
4412: ; preds = %4412, %4410
%4413 = phi i64 [ 0, %4410 ], [ %4440, %4412 ]
%4414 = phi i64 [ 0, %4410 ], [ %4441, %4412 ]
%4415 = getelementptr inbounds double, double* %4399, i64 %4413
%4416 = bitcast double* %4415 to <2 x double>*
%4417 = load <2 x double>, <2 x double>* %4416
%4418 = getelementptr inbounds double, double* %4415, i64 2
%4419 = bitcast double* %4418 to <2 x double>*
%4420 = load <2 x double>, <2 x double>* %4419
%4421 = fptoui <2 x double> %4417 to <2 x i16>
%4422 = fptoui <2 x double> %4420 to <2 x i16>
%4423 = getelementptr inbounds i16, i16* %4400, i64 %4413
%4424 = bitcast i16* %4423 to <2 x i16>*
store <2 x i16> %4421, <2 x i16>* %4424
%4425 = getelementptr inbounds i16, i16* %4423, i64 2
%4426 = bitcast i16* %4425 to <2 x i16>*
store <2 x i16> %4422, <2 x i16>* %4426
%4427 = or i64 %4413, 4
%4428 = getelementptr inbounds double, double* %4399, i64 %4427
%4429 = bitcast double* %4428 to <2 x double>*
%4430 = load <2 x double>, <2 x double>* %4429
%4431 = getelementptr inbounds double, double* %4428, i64 2
%4432 = bitcast double* %4431 to <2 x double>*
%4433 = load <2 x double>, <2 x double>* %4432
%4434 = fptoui <2 x double> %4430 to <2 x i16>
%4435 = fptoui <2 x double> %4433 to <2 x i16>
%4436 = getelementptr inbounds i16, i16* %4400, i64 %4427
%4437 = bitcast i16* %4436 to <2 x i16>*
store <2 x i16> %4434, <2 x i16>* %4437
%4438 = getelementptr inbounds i16, i16* %4436, i64 2
%4439 = bitcast i16* %4438 to <2 x i16>*
store <2 x i16> %4435, <2 x i16>* %4439
%4440 = add nuw i64 %4413, 8
%4441 = add i64 %4414, 2
%4442 = icmp eq i64 %4441, %4411
br i1 %4442, label %4443, label %4412
4443: ; preds = %4412, %4403
%4444 = phi i64 [ 0, %4403 ], [ %4440, %4412 ]
%4445 = icmp eq i64 %4408, 0
br i1 %4445, label %4459, label %4446
4446: ; preds = %4443
%4447 = getelementptr inbounds double, double* %4399, i64 %4444
%4448 = bitcast double* %4447 to <2 x double>*
%4449 = load <2 x double>, <2 x double>* %4448
%4450 = getelementptr inbounds double, double* %4447, i64 2
%4451 = bitcast double* %4450 to <2 x double>*
%4452 = load <2 x double>, <2 x double>* %4451
%4453 = fptoui <2 x double> %4449 to <2 x i16>
%4454 = fptoui <2 x double> %4452 to <2 x i16>
%4455 = getelementptr inbounds i16, i16* %4400, i64 %4444
%4456 = bitcast i16* %4455 to <2 x i16>*
store <2 x i16> %4453, <2 x i16>* %4456
%4457 = getelementptr inbounds i16, i16* %4455, i64 2
%4458 = bitcast i16* %4457 to <2 x i16>*
store <2 x i16> %4454, <2 x i16>* %4458
br label %4459
4459: ; preds = %4443, %4446
%4460 = icmp eq i64 %4404, %4401
br i1 %4460, label %4771, label %4461
4461: ; preds = %4398, %4459
%4462 = phi i64 [ 0, %4398 ], [ %4404, %4459 ]
br label %4651
4463: ; preds = %4150
%4464 = icmp sgt i32 %4, 0
br i1 %4464, label %4465, label %4771
4465: ; preds = %4463
%4466 = bitcast i8* %0 to double*
%4467 = bitcast i8* %2 to i16*
%4468 = zext i32 %4 to i64
%4469 = icmp ult i32 %4, 4
br i1 %4469, label %4528, label %4470
4470: ; preds = %4465
%4471 = and i64 %4468, 4294967292
%4472 = add nsw i64 %4471, -4
%4473 = lshr exact i64 %4472, 2
%4474 = add nuw nsw i64 %4473, 1
%4475 = and i64 %4474, 1
%4476 = icmp eq i64 %4472, 0
br i1 %4476, label %4510, label %4477
4477: ; preds = %4470
%4478 = and i64 %4474, 9223372036854775806
br label %4479
4479: ; preds = %4479, %4477
%4480 = phi i64 [ 0, %4477 ], [ %4507, %4479 ]
%4481 = phi i64 [ 0, %4477 ], [ %4508, %4479 ]
%4482 = getelementptr inbounds double, double* %4466, i64 %4480
%4483 = bitcast double* %4482 to <2 x double>*
%4484 = load <2 x double>, <2 x double>* %4483
%4485 = getelementptr inbounds double, double* %4482, i64 2
%4486 = bitcast double* %4485 to <2 x double>*
%4487 = load <2 x double>, <2 x double>* %4486
%4488 = fptosi <2 x double> %4484 to <2 x i16>
%4489 = fptosi <2 x double> %4487 to <2 x i16>
%4490 = getelementptr inbounds i16, i16* %4467, i64 %4480
%4491 = bitcast i16* %4490 to <2 x i16>*
store <2 x i16> %4488, <2 x i16>* %4491
%4492 = getelementptr inbounds i16, i16* %4490, i64 2
%4493 = bitcast i16* %4492 to <2 x i16>*
store <2 x i16> %4489, <2 x i16>* %4493
%4494 = or i64 %4480, 4
%4495 = getelementptr inbounds double, double* %4466, i64 %4494
%4496 = bitcast double* %4495 to <2 x double>*
%4497 = load <2 x double>, <2 x double>* %4496
%4498 = getelementptr inbounds double, double* %4495, i64 2
%4499 = bitcast double* %4498 to <2 x double>*
%4500 = load <2 x double>, <2 x double>* %4499
%4501 = fptosi <2 x double> %4497 to <2 x i16>
%4502 = fptosi <2 x double> %4500 to <2 x i16>
%4503 = getelementptr inbounds i16, i16* %4467, i64 %4494
%4504 = bitcast i16* %4503 to <2 x i16>*
store <2 x i16> %4501, <2 x i16>* %4504
%4505 = getelementptr inbounds i16, i16* %4503, i64 2
%4506 = bitcast i16* %4505 to <2 x i16>*
store <2 x i16> %4502, <2 x i16>* %4506
%4507 = add nuw i64 %4480, 8
%4508 = add i64 %4481, 2
%4509 = icmp eq i64 %4508, %4478
br i1 %4509, label %4510, label %4479
4510: ; preds = %4479, %4470
%4511 = phi i64 [ 0, %4470 ], [ %4507, %4479 ]
%4512 = icmp eq i64 %4475, 0
br i1 %4512, label %4526, label %4513
4513: ; preds = %4510
%4514 = getelementptr inbounds double, double* %4466, i64 %4511
%4515 = bitcast double* %4514 to <2 x double>*
%4516 = load <2 x double>, <2 x double>* %4515
%4517 = getelementptr inbounds double, double* %4514, i64 2
%4518 = bitcast double* %4517 to <2 x double>*
%4519 = load <2 x double>, <2 x double>* %4518
%4520 = fptosi <2 x double> %4516 to <2 x i16>
%4521 = fptosi <2 x double> %4519 to <2 x i16>
%4522 = getelementptr inbounds i16, i16* %4467, i64 %4511
%4523 = bitcast i16* %4522 to <2 x i16>*
store <2 x i16> %4520, <2 x i16>* %4523
%4524 = getelementptr inbounds i16, i16* %4522, i64 2
%4525 = bitcast i16* %4524 to <2 x i16>*
store <2 x i16> %4521, <2 x i16>* %4525
br label %4526
4526: ; preds = %4510, %4513
%4527 = icmp eq i64 %4471, %4468
br i1 %4527, label %4771, label %4528
4528: ; preds = %4465, %4526
%4529 = phi i64 [ 0, %4465 ], [ %4471, %4526 ]
br label %4643
4530: ; preds = %4150
%4531 = icmp sgt i32 %4, 0
br i1 %4531, label %4532, label %4771
4532: ; preds = %4530
%4533 = bitcast i8* %0 to double*
%4534 = zext i32 %4 to i64
%4535 = icmp ult i32 %4, 4
br i1 %4535, label %4601, label %4536
4536: ; preds = %4532
%4537 = getelementptr i8, i8* %2, i64 %4534
%4538 = shl nuw nsw i64 %4534, 3
%4539 = getelementptr i8, i8* %0, i64 %4538
%4540 = icmp ugt i8* %4539, %2
%4541 = icmp ugt i8* %4537, %0
%4542 = and i1 %4540, %4541
br i1 %4542, label %4601, label %4543
4543: ; preds = %4536
%4544 = and i64 %4534, 4294967292
%4545 = add nsw i64 %4544, -4
%4546 = lshr exact i64 %4545, 2
%4547 = add nuw nsw i64 %4546, 1
%4548 = and i64 %4547, 1
%4549 = icmp eq i64 %4545, 0
br i1 %4549, label %4583, label %4550
4550: ; preds = %4543
%4551 = and i64 %4547, 9223372036854775806
br label %4552
4552: ; preds = %4552, %4550
%4553 = phi i64 [ 0, %4550 ], [ %4580, %4552 ]
%4554 = phi i64 [ 0, %4550 ], [ %4581, %4552 ]
%4555 = getelementptr inbounds double, double* %4533, i64 %4553
%4556 = bitcast double* %4555 to <2 x double>*
%4557 = load <2 x double>, <2 x double>* %4556
%4558 = getelementptr inbounds double, double* %4555, i64 2
%4559 = bitcast double* %4558 to <2 x double>*
%4560 = load <2 x double>, <2 x double>* %4559
%4561 = fptoui <2 x double> %4557 to <2 x i8>
%4562 = fptoui <2 x double> %4560 to <2 x i8>
%4563 = getelementptr inbounds i8, i8* %2, i64 %4553
%4564 = bitcast i8* %4563 to <2 x i8>*
store <2 x i8> %4561, <2 x i8>* %4564
%4565 = getelementptr inbounds i8, i8* %4563, i64 2
%4566 = bitcast i8* %4565 to <2 x i8>*
store <2 x i8> %4562, <2 x i8>* %4566
%4567 = or i64 %4553, 4
%4568 = getelementptr inbounds double, double* %4533, i64 %4567
%4569 = bitcast double* %4568 to <2 x double>*
%4570 = load <2 x double>, <2 x double>* %4569
%4571 = getelementptr inbounds double, double* %4568, i64 2
%4572 = bitcast double* %4571 to <2 x double>*
%4573 = load <2 x double>, <2 x double>* %4572
%4574 = fptoui <2 x double> %4570 to <2 x i8>
%4575 = fptoui <2 x double> %4573 to <2 x i8>
%4576 = getelementptr inbounds i8, i8* %2, i64 %4567
%4577 = bitcast i8* %4576 to <2 x i8>*
store <2 x i8> %4574, <2 x i8>* %4577
%4578 = getelementptr inbounds i8, i8* %4576, i64 2
%4579 = bitcast i8* %4578 to <2 x i8>*
store <2 x i8> %4575, <2 x i8>* %4579
%4580 = add nuw i64 %4553, 8
%4581 = add i64 %4554, 2
%4582 = icmp eq i64 %4581, %4551
br i1 %4582, label %4583, label %4552
4583: ; preds = %4552, %4543
%4584 = phi i64 [ 0, %4543 ], [ %4580, %4552 ]
%4585 = icmp eq i64 %4548, 0
br i1 %4585, label %4599, label %4586
4586: ; preds = %4583
%4587 = getelementptr inbounds double, double* %4533, i64 %4584
%4588 = bitcast double* %4587 to <2 x double>*
%4589 = load <2 x double>, <2 x double>* %4588
%4590 = getelementptr inbounds double, double* %4587, i64 2
%4591 = bitcast double* %4590 to <2 x double>*
%4592 = load <2 x double>, <2 x double>* %4591
%4593 = fptoui <2 x double> %4589 to <2 x i8>
%4594 = fptoui <2 x double> %4592 to <2 x i8>
%4595 = getelementptr inbounds i8, i8* %2, i64 %4584
%4596 = bitcast i8* %4595 to <2 x i8>*
store <2 x i8> %4593, <2 x i8>* %4596
%4597 = getelementptr inbounds i8, i8* %4595, i64 2
%4598 = bitcast i8* %4597 to <2 x i8>*
store <2 x i8> %4594, <2 x i8>* %4598
br label %4599
4599: ; preds = %4583, %4586
%4600 = icmp eq i64 %4544, %4534
br i1 %4600, label %4771, label %4601
4601: ; preds = %4536, %4532, %4599
%4602 = phi i64 [ 0, %4536 ], [ 0, %4532 ], [ %4544, %4599 ]
%4603 = xor i64 %4602, -1
%4604 = add nsw i64 %4603, %4534
%4605 = and i64 %4534, 3
%4606 = icmp eq i64 %4605, 0
br i1 %4606, label %4617, label %4607
4607: ; preds = %4601, %4607
%4608 = phi i64 [ %4614, %4607 ], [ %4602, %4601 ]
%4609 = phi i64 [ %4615, %4607 ], [ 0, %4601 ]
%4610 = getelementptr inbounds double, double* %4533, i64 %4608
%4611 = load double, double* %4610
%4612 = fptoui double %4611 to i8
%4613 = getelementptr inbounds i8, i8* %2, i64 %4608
store i8 %4612, i8* %4613
%4614 = add nuw nsw i64 %4608, 1
%4615 = add i64 %4609, 1
%4616 = icmp eq i64 %4615, %4605
br i1 %4616, label %4617, label %4607
4617: ; preds = %4607, %4601
%4618 = phi i64 [ %4602, %4601 ], [ %4614, %4607 ]
%4619 = icmp ult i64 %4604, 3
br i1 %4619, label %4771, label %4620
4620: ; preds = %4617, %4620
%4621 = phi i64 [ %4641, %4620 ], [ %4618, %4617 ]
%4622 = getelementptr inbounds double, double* %4533, i64 %4621
%4623 = load double, double* %4622
%4624 = fptoui double %4623 to i8
%4625 = getelementptr inbounds i8, i8* %2, i64 %4621
store i8 %4624, i8* %4625
%4626 = add nuw nsw i64 %4621, 1
%4627 = getelementptr inbounds double, double* %4533, i64 %4626
%4628 = load double, double* %4627
%4629 = fptoui double %4628 to i8
%4630 = getelementptr inbounds i8, i8* %2, i64 %4626
store i8 %4629, i8* %4630
%4631 = add nuw nsw i64 %4621, 2
%4632 = getelementptr inbounds double, double* %4533, i64 %4631
%4633 = load double, double* %4632
%4634 = fptoui double %4633 to i8
%4635 = getelementptr inbounds i8, i8* %2, i64 %4631
store i8 %4634, i8* %4635
%4636 = add nuw nsw i64 %4621, 3
%4637 = getelementptr inbounds double, double* %4533, i64 %4636
%4638 = load double, double* %4637
%4639 = fptoui double %4638 to i8
%4640 = getelementptr inbounds i8, i8* %2, i64 %4636
store i8 %4639, i8* %4640
%4641 = add nuw nsw i64 %4621, 4
%4642 = icmp eq i64 %4641, %4534
br i1 %4642, label %4771, label %4620
4643: ; preds = %4528, %4643
%4644 = phi i64 [ %4649, %4643 ], [ %4529, %4528 ]
%4645 = getelementptr inbounds double, double* %4466, i64 %4644
%4646 = load double, double* %4645
%4647 = fptosi double %4646 to i16
%4648 = getelementptr inbounds i16, i16* %4467, i64 %4644
store i16 %4647, i16* %4648
%4649 = add nuw nsw i64 %4644, 1
%4650 = icmp eq i64 %4649, %4468
br i1 %4650, label %4771, label %4643
4651: ; preds = %4461, %4651
%4652 = phi i64 [ %4657, %4651 ], [ %4462, %4461 ]
%4653 = getelementptr inbounds double, double* %4399, i64 %4652
%4654 = load double, double* %4653
%4655 = fptoui double %4654 to i16
%4656 = getelementptr inbounds i16, i16* %4400, i64 %4652
store i16 %4655, i16* %4656
%4657 = add nuw nsw i64 %4652, 1
%4658 = icmp eq i64 %4657, %4401
br i1 %4658, label %4771, label %4651
4659: ; preds = %4150, %4150
%4660 = icmp sgt i32 %4, 0
br i1 %4660, label %4661, label %4771
4661: ; preds = %4659
%4662 = bitcast i8* %0 to double*
%4663 = bitcast i8* %2 to i32*
%4664 = zext i32 %4 to i64
%4665 = icmp ult i32 %4, 4
br i1 %4665, label %4724, label %4666
4666: ; preds = %4661
%4667 = and i64 %4664, 4294967292
%4668 = add nsw i64 %4667, -4
%4669 = lshr exact i64 %4668, 2
%4670 = add nuw nsw i64 %4669, 1
%4671 = and i64 %4670, 1
%4672 = icmp eq i64 %4668, 0
br i1 %4672, label %4706, label %4673
4673: ; preds = %4666
%4674 = and i64 %4670, 9223372036854775806
br label %4675
4675: ; preds = %4675, %4673
%4676 = phi i64 [ 0, %4673 ], [ %4703, %4675 ]
%4677 = phi i64 [ 0, %4673 ], [ %4704, %4675 ]
%4678 = getelementptr inbounds double, double* %4662, i64 %4676
%4679 = bitcast double* %4678 to <2 x double>*
%4680 = load <2 x double>, <2 x double>* %4679
%4681 = getelementptr inbounds double, double* %4678, i64 2
%4682 = bitcast double* %4681 to <2 x double>*
%4683 = load <2 x double>, <2 x double>* %4682
%4684 = fptosi <2 x double> %4680 to <2 x i32>
%4685 = fptosi <2 x double> %4683 to <2 x i32>
%4686 = getelementptr inbounds i32, i32* %4663, i64 %4676
%4687 = bitcast i32* %4686 to <2 x i32>*
store <2 x i32> %4684, <2 x i32>* %4687
%4688 = getelementptr inbounds i32, i32* %4686, i64 2
%4689 = bitcast i32* %4688 to <2 x i32>*
store <2 x i32> %4685, <2 x i32>* %4689
%4690 = or i64 %4676, 4
%4691 = getelementptr inbounds double, double* %4662, i64 %4690
%4692 = bitcast double* %4691 to <2 x double>*
%4693 = load <2 x double>, <2 x double>* %4692
%4694 = getelementptr inbounds double, double* %4691, i64 2
%4695 = bitcast double* %4694 to <2 x double>*
%4696 = load <2 x double>, <2 x double>* %4695
%4697 = fptosi <2 x double> %4693 to <2 x i32>
%4698 = fptosi <2 x double> %4696 to <2 x i32>
%4699 = getelementptr inbounds i32, i32* %4663, i64 %4690
%4700 = bitcast i32* %4699 to <2 x i32>*
store <2 x i32> %4697, <2 x i32>* %4700
%4701 = getelementptr inbounds i32, i32* %4699, i64 2
%4702 = bitcast i32* %4701 to <2 x i32>*
store <2 x i32> %4698, <2 x i32>* %4702
%4703 = add nuw i64 %4676, 8
%4704 = add i64 %4677, 2
%4705 = icmp eq i64 %4704, %4674
br i1 %4705, label %4706, label %4675
4706: ; preds = %4675, %4666
%4707 = phi i64 [ 0, %4666 ], [ %4703, %4675 ]
%4708 = icmp eq i64 %4671, 0
br i1 %4708, label %4722, label %4709
4709: ; preds = %4706
%4710 = getelementptr inbounds double, double* %4662, i64 %4707
%4711 = bitcast double* %4710 to <2 x double>*
%4712 = load <2 x double>, <2 x double>* %4711
%4713 = getelementptr inbounds double, double* %4710, i64 2
%4714 = bitcast double* %4713 to <2 x double>*
%4715 = load <2 x double>, <2 x double>* %4714
%4716 = fptosi <2 x double> %4712 to <2 x i32>
%4717 = fptosi <2 x double> %4715 to <2 x i32>
%4718 = getelementptr inbounds i32, i32* %4663, i64 %4707
%4719 = bitcast i32* %4718 to <2 x i32>*
store <2 x i32> %4716, <2 x i32>* %4719
%4720 = getelementptr inbounds i32, i32* %4718, i64 2
%4721 = bitcast i32* %4720 to <2 x i32>*
store <2 x i32> %4717, <2 x i32>* %4721
br label %4722
4722: ; preds = %4706, %4709
%4723 = icmp eq i64 %4667, %4664
br i1 %4723, label %4771, label %4724
4724: ; preds = %4661, %4722
%4725 = phi i64 [ 0, %4661 ], [ %4667, %4722 ]
br label %4726
4726: ; preds = %4724, %4726
%4727 = phi i64 [ %4732, %4726 ], [ %4725, %4724 ]
%4728 = getelementptr inbounds double, double* %4662, i64 %4727
%4729 = load double, double* %4728
%4730 = fptosi double %4729 to i32
%4731 = getelementptr inbounds i32, i32* %4663, i64 %4727
store i32 %4730, i32* %4731
%4732 = add nuw nsw i64 %4727, 1
%4733 = icmp eq i64 %4732, %4664
br i1 %4733, label %4771, label %4726
4734: ; preds = %4394, %4734
%4735 = phi i64 [ %4740, %4734 ], [ %4395, %4394 ]
%4736 = getelementptr inbounds double, double* %4332, i64 %4735
%4737 = load double, double* %4736
%4738 = fptoui double %4737 to i32
%4739 = getelementptr inbounds i32, i32* %4333, i64 %4735
store i32 %4738, i32* %4739
%4740 = add nuw nsw i64 %4735, 1
%4741 = icmp eq i64 %4740, %4334
br i1 %4741, label %4771, label %4734
4742: ; preds = %4327, %4742
%4743 = phi i64 [ %4748, %4742 ], [ %4328, %4327 ]
%4744 = getelementptr inbounds double, double* %4265, i64 %4743
%4745 = load double, double* %4744
%4746 = fptrunc double %4745 to float
%4747 = getelementptr inbounds float, float* %4266, i64 %4743
store float %4746, float* %4747
%4748 = add nuw nsw i64 %4743, 1
%4749 = icmp eq i64 %4748, %4267
br i1 %4749, label %4771, label %4742
4750: ; preds = %4259, %4750
%4751 = phi i64 [ %4767, %4750 ], [ %4260, %4259 ]
%4752 = getelementptr inbounds double, double* %4154, i64 %4751
%4753 = load double, double* %4752
%4754 = getelementptr inbounds double, double* %4155, i64 %4751
store double %4753, double* %4754
%4755 = add nuw nsw i64 %4751, 1
%4756 = getelementptr inbounds double, double* %4154, i64 %4755
%4757 = load double, double* %4756
%4758 = getelementptr inbounds double, double* %4155, i64 %4755
store double %4757, double* %4758
%4759 = add nuw nsw i64 %4751, 2
%4760 = getelementptr inbounds double, double* %4154, i64 %4759
%4761 = load double, double* %4760
%4762 = getelementptr inbounds double, double* %4155, i64 %4759
store double %4761, double* %4762
%4763 = add nuw nsw i64 %4751, 3
%4764 = getelementptr inbounds double, double* %4154, i64 %4763
%4765 = load double, double* %4764
%4766 = getelementptr inbounds double, double* %4155, i64 %4763
store double %4765, double* %4766
%4767 = add nuw nsw i64 %4751, 4
%4768 = icmp eq i64 %4767, %4156
br i1 %4768, label %4771, label %4750
4769: ; preds = %8
%4770 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @str, i64 0, i64 0))
br label %4771
4771: ; preds = %4259, %4750, %4742, %4734, %4726, %4651, %4643, %4617, %4620, %4142, %3707, %4123, %4115, %4107, %4032, %4024, %3998, %4001, %3523, %3515, %3100, %3496, %3474, %3477, %3358, %3350, %3324, %3327, %2849, %2841, %2426, %2822, %2800, %2803, %2684, %2676, %2650, %2653, %2175, %2167, %2159, %2151, %1819, %2065, %1930, %2046, %2020, %2023, %1501, %1493, %1485, %1477, %1145, %1391, %1256, %1372, %1346, %1349, %98, %812, %188, %789, %278, %766, %740, %743, %368, %630, %458, %607, %585, %588, %4242, %4325, %4392, %4722, %4459, %4526, %4599, %3595, %3690, %3773, %4103, %3840, %3907, %3980, %2921, %2988, %3083, %3457, %3166, %3233, %3306, %2247, %2314, %2409, %2783, %2492, %2559, %2632, %1573, %1640, %1707, %2147, %1802, %1913, %2002, %899, %966, %1033, %1473, %1128, %1239, %1328, %80, %170, %260, %722, %350, %440, %551, %568, %4151, %4262, %4329, %4659, %4396, %4463, %4530, %3532, %3599, %3710, %4040, %3777, %3844, %3911, %2858, %2925, %2992, %3366, %3103, %3170, %3237, %2184, %2251, %2318, %2692, %2429, %2496, %2563, %1510, %1577, %1644, %2084, %1711, %1822, %1933, %836, %903, %970, %1410, %1037, %1148, %1259, %11, %101, %191, %653, %281, %371, %461, %4150, %3531, %2857, %2183, %1509, %835, %10, %5, %4769
%4772 = phi i32 [ 6, %4769 ], [ 0, %5 ], [ 6, %10 ], [ 6, %835 ], [ 6, %1509 ], [ 6, %2183 ], [ 6, %2857 ], [ 6, %3531 ], [ 6, %4150 ], [ 0, %461 ], [ 0, %371 ], [ 0, %281 ], [ 0, %653 ], [ 0, %191 ], [ 0, %101 ], [ 0, %11 ], [ 0, %1259 ], [ 0, %1148 ], [ 0, %1037 ], [ 0, %1410 ], [ 0, %970 ], [ 0, %903 ], [ 0, %836 ], [ 0, %1933 ], [ 0, %1822 ], [ 0, %1711 ], [ 0, %2084 ], [ 0, %1644 ], [ 0, %1577 ], [ 0, %1510 ], [ 0, %2563 ], [ 0, %2496 ], [ 0, %2429 ], [ 0, %2692 ], [ 0, %2318 ], [ 0, %2251 ], [ 0, %2184 ], [ 0, %3237 ], [ 0, %3170 ], [ 0, %3103 ], [ 0, %3366 ], [ 0, %2992 ], [ 0, %2925 ], [ 0, %2858 ], [ 0, %3911 ], [ 0, %3844 ], [ 0, %3777 ], [ 0, %4040 ], [ 0, %3710 ], [ 0, %3599 ], [ 0, %3532 ], [ 0, %4530 ], [ 0, %4463 ], [ 0, %4396 ], [ 0, %4659 ], [ 0, %4329 ], [ 0, %4262 ], [ 0, %4151 ], [ 0, %568 ], [ 0, %551 ], [ 0, %440 ], [ 0, %350 ], [ 0, %722 ], [ 0, %260 ], [ 0, %170 ], [ 0, %80 ], [ 0, %1328 ], [ 0, %1239 ], [ 0, %1128 ], [ 0, %1473 ], [ 0, %1033 ], [ 0, %966 ], [ 0, %899 ], [ 0, %2002 ], [ 0, %1913 ], [ 0, %1802 ], [ 0, %2147 ], [ 0, %1707 ], [ 0, %1640 ], [ 0, %1573 ], [ 0, %2632 ], [ 0, %2559 ], [ 0, %2492 ], [ 0, %2783 ], [ 0, %2409 ], [ 0, %2314 ], [ 0, %2247 ], [ 0, %3306 ], [ 0, %3233 ], [ 0, %3166 ], [ 0, %3457 ], [ 0, %3083 ], [ 0, %2988 ], [ 0, %2921 ], [ 0, %3980 ], [ 0, %3907 ], [ 0, %3840 ], [ 0, %4103 ], [ 0, %3773 ], [ 0, %3690 ], [ 0, %3595 ], [ 0, %4599 ], [ 0, %4526 ], [ 0, %4459 ], [ 0, %4722 ], [ 0, %4392 ], [ 0, %4325 ], [ 0, %4242 ], [ 0, %588 ], [ 0, %585 ], [ 0, %607 ], [ 0, %458 ], [ 0, %630 ], [ 0, %368 ], [ 0, %743 ], [ 0, %740 ], [ 0, %766 ], [ 0, %278 ], [ 0, %789 ], [ 0, %188 ], [ 0, %812 ], [ 0, %98 ], [ 0, %1349 ], [ 0, %1346 ], [ 0, %1372 ], [ 0, %1256 ], [ 0, %1391 ], [ 0, %1145 ], [ 0, %1477 ], [ 0, %1485 ], [ 0, %1493 ], [ 0, %1501 ], [ 0, %2023 ], [ 0, %2020 ], [ 0, %2046 ], [ 0, %1930 ], [ 0, %2065 ], [ 0, %1819 ], [ 0, %2151 ], [ 0, %2159 ], [ 0, %2167 ], [ 0, %2175 ], [ 0, %2653 ], [ 0, %2650 ], [ 0, %2676 ], [ 0, %2684 ], [ 0, %2803 ], [ 0, %2800 ], [ 0, %2822 ], [ 0, %2426 ], [ 0, %2841 ], [ 0, %2849 ], [ 0, %3327 ], [ 0, %3324 ], [ 0, %3350 ], [ 0, %3358 ], [ 0, %3477 ], [ 0, %3474 ], [ 0, %3496 ], [ 0, %3100 ], [ 0, %3515 ], [ 0, %3523 ], [ 0, %4001 ], [ 0, %3998 ], [ 0, %4024 ], [ 0, %4032 ], [ 0, %4107 ], [ 0, %4115 ], [ 0, %4123 ], [ 0, %3707 ], [ 0, %4142 ], [ 0, %4620 ], [ 0, %4617 ], [ 0, %4643 ], [ 0, %4651 ], [ 0, %4726 ], [ 0, %4734 ], [ 0, %4742 ], [ 0, %4750 ], [ 0, %4259 ]
ret i32 %4772
}