int xmlDecodeBody(unsigned char *out, unsigned int olen,
                  const unsigned char *in, unsigned int ilen) {
  int len;
  len = 0;
  for (; ilen--;)
    switch (*in) {
    case '<':
      if (ilen > 10 && *(in + 1) == '!' && *(in + 2) == '[' &&
          *(in + 3) == 'C' && *(in + 4) == 'D' && *(in + 5) == 'A' &&
          *(in + 6) == 'T' && *(in + 7) == 'A' && *(in + 8) == '[') {
        for (in += 9, ilen -= 8; ilen--; in++, len++) {
          if (*(in + 0) == ']' && *(in + 1) == ']' && *(in + 2) == '>') {
            in += 3, ilen -= 2;
            break;
          }
          if (olen > 0) {
            *out++ = *in;
            olen--;
          }
        }
      } else {
        if (olen > 0) {
          *out++ = *in;
          olen--;
        }
        in++, len++;
      }
      break;
    case '&':
      if (!(in++, ilen--))
        goto err;
      else
        switch (*in) {
        case 'a':
          if (!(in++, ilen--))
            goto err;
          else
            switch (*in) {
            case 'm':
              if (!(in++, ilen--))
                goto err;
              else
                switch (*in) {
                case 'p':
                  if (!(in++, ilen--))
                    goto err;
                  else
                    switch (*in) {
                    case ';':
                      if (olen > 0) {
                        *out++ = '&';
                        olen--;
                      }
                      in++, len++;
                      continue;
                    default:
                      goto err;
                    }
                default:
                  goto err;
                }
            case 'p':
              if (!(in++, ilen--))
                goto err;
              else
                switch (*in) {
                case 'o':
                  if (!(in++, ilen--))
                    goto err;
                  else
                    switch (*in) {
                    case 's':
                      if (!(in++, ilen--))
                        goto err;
                      else
                        switch (*in) {
                        case ';':
                          if (olen > 0) {
                            *out++ = '\'';
                            olen--;
                          }
                          in++, len++;
                          continue;
                        default:
                          goto err;
                        }
                    default:
                      goto err;
                    }
                default:
                  goto err;
                }
            default:
              goto err;
            }
        case 'g':
          if (!(in++, ilen--))
            goto err;
          else
            switch (*in) {
            case 't':
              if (!(in++, ilen--))
                goto err;
              else
                switch (*in) {
                case ';':
                  if (olen > 0) {
                    *out++ = '>';
                    olen--;
                  }
                  in++, len++;
                  continue;
                default:
                  goto err;
                }
            default:
              goto err;
            }
        case 'l':
          if (!(in++, ilen--))
            goto err;
          else
            switch (*in) {
            case 't':
              if (!(in++, ilen--))
                goto err;
              else
                switch (*in) {
                case ';':
                  if (olen > 0) {
                    *out++ = '<';
                    olen--;
                  }
                  in++, len++;
                  continue;
                default:
                  goto err;
                }
            default:
              goto err;
            }
        case 'q':
          if (!(in++, ilen--))
            goto err;
          else
            switch (*in) {
            case 'u':
              if (!(in++, ilen--))
                goto err;
              else
                switch (*in) {
                case 'o':
                  if (!(in++, ilen--))
                    goto err;
                  else
                    switch (*in) {
                    case 't':
                      if (!(in++, ilen--))
                        goto err;
                      else
                        switch (*in) {
                        case ';':
                          if (olen > 0) {
                            *out++ = '"';
                            olen--;
                          }
                          in++, len++;
                          continue;
                        default:
                          goto err;
                        }
                    default:
                      goto err;
                    }
                default:
                  goto err;
                }
            default:
              goto err;
            }
        case '#':
          if (!(in++, ilen--))
            goto err;
          else
            switch (*in) {
              unsigned long c;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
              c = *in - '0';
              for (in++; ilen; in++, ilen--)
                switch (*in) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                  c *= 10;
                  c += *in - '0';
                  break;
                case ';':
                  goto enc;
                default:
                  goto err;
                }
              goto err;
            case 'x':
              if (!(in++, ilen--))
                goto err;
              else
                switch (*in) {
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                  c = *in - '0';
                  goto nxtH;
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                  c = 10 + (*in - 'A');
                  goto nxtH;
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                  c = 10 + (*in - 'a');
                nxtH:
                  for (in++; ilen; in++, ilen--)
                    switch (*in) {
                    case '0':
                    case '1':
                    case '2':
                    case '3':
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    case '8':
                    case '9':
                      c *= 16;
                      c += *in - '0';
                      break;
                    case 'A':
                    case 'B':
                    case 'C':
                    case 'D':
                    case 'E':
                    case 'F':
                      c *= 16;
                      c += 10 + (*in - 'A');
                      break;
                    case 'a':
                    case 'b':
                    case 'c':
                    case 'd':
                    case 'e':
                    case 'f':
                      c *= 16;
                      c += 10 + (*in - 'a');
                      break;
                    case ';':
                      goto enc;
                    default:
                      goto err;
                    }
                  goto err;
                enc:
                  if (!ilen--)
                    goto err;
                  if (c <= 0x7f) {
                    if (olen > 0) {
                      *out++ = c;
                      olen--;
                    }
                    len++;
                  } else if (c <= 0x7ff) {
                    if (olen > 1) {
                      *out++ = 0xc0 | (c >> 6);
                      *out++ = 0x80 | (c & 0x3f);
                      olen -= 2;
                    }
                    len += 2;
                  } else if (c <= 0xffff) {
                    if (olen > 2) {
                      *out++ = 0xe0 | (c >> 12);
                      *out++ = 0x80 | (c >> 6 & 0x3f);
                      *out++ = 0x80 | (c & 0x3f);
                      olen -= 3;
                    }
                    len += 3;
                  } else if (c <= 0x1fffff) {
                    if (olen > 3) {
                      *out++ = 0xf0 | (c >> 18);
                      *out++ = 0x80 | (c >> 12 & 0x3f);
                      *out++ = 0x80 | (c >> 6 & 0x3f);
                      *out++ = 0x80 | (c & 0x3f);
                      olen -= 4;
                    }
                    len += 4;
                  } else if (c <= 0x3ffffff) {
                    if (olen > 4) {
                      *out++ = 0xf8 | (c >> 24);
                      *out++ = 0x80 | (c >> 18 & 0x3f);
                      *out++ = 0x80 | (c >> 12 & 0x3f);
                      *out++ = 0x80 | (c >> 6 & 0x3f);
                      *out++ = 0x80 | (c & 0x3f);
                      olen -= 5;
                    }
                    len += 5;
                  } else if (c <= 0x7fffffff) {
                    if (olen > 5) {
                      *out++ = 0xfc | (c >> 30);
                      *out++ = 0x80 | (c >> 24 & 0x3f);
                      *out++ = 0x80 | (c >> 18 & 0x3f);
                      *out++ = 0x80 | (c >> 12 & 0x3f);
                      *out++ = 0x80 | (c >> 6 & 0x3f);
                      *out++ = 0x80 | (c & 0x3f);
                      olen -= 6;
                    }
                    len += 6;
                  } else
                    goto err;
                  in++;
                  continue;
                default:
                  goto err;
                }
            default:
              goto err;
            }
        default:
          goto err;
        }
    default:
      if ((*in & 0x80) == 0x00) {
        if (olen > 0) {
          *out++ = *in++;
          olen--;
        } else
          in++;
        len++;
      } else if (ilen > 0 && (*in & 0xe0) == 0xc0 &&
                 (*(in + 1) & 0xc0) == 0x80) {
        if (olen > 1) {
          *out++ = *in++;
          *out++ = *in++;
          olen -= 2;
        } else
          in += 2;
        len += 2;
        ilen--;
      } else if (ilen > 1 && (*in & 0xf0) == 0xe0 &&
                 (*(in + 1) & 0xc0) == 0x80 && (*(in + 2) & 0xc0) == 0x80) {
        if (olen > 2) {
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          olen -= 3;
        } else
          in += 3;
        len += 3;
        ilen -= 2;
      } else if (ilen > 2 && (*in & 0xf8) == 0xf0 &&
                 (*(in + 1) & 0xc0) == 0x80 && (*(in + 2) & 0xc0) == 0x80 &&
                 (*(in + 3) & 0xc0) == 0x80) {
        if (olen > 3) {
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          olen -= 4;
        } else
          in += 4;
        len += 4;
        ilen -= 3;
      } else if (ilen > 3 && (*in & 0xfc) == 0xf8 &&
                 (*(in + 1) & 0xc0) == 0x80 && (*(in + 2) & 0xc0) == 0x80 &&
                 (*(in + 3) & 0xc0) == 0x80 && (*(in + 4) & 0xc0) == 0x80) {
        if (olen > 4) {
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          olen -= 5;
        } else
          in += 5;
        len += 5;
        ilen -= 4;
      } else if (ilen > 4 && (*in & 0xfe) == 0xfc &&
                 (*(in + 1) & 0xc0) == 0x80 && (*(in + 2) & 0xc0) == 0x80 &&
                 (*(in + 3) & 0xc0) == 0x80 && (*(in + 4) & 0xc0) == 0x80 &&
                 (*(in + 5) & 0xc0) == 0x80) {
        if (olen > 5) {
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          *out++ = *in++;
          olen -= 6;
        } else
          in += 6;
        len += 6;
        ilen -= 5;
      } else
        goto err;
      break;
    }
  return (len);
err:
  return (-1);
}


x86 assembly (clang, -O0):
<xmlDecodeBody>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
je     2546 <xmlDecodeBody+0x1446>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x34(%rbp)
sub    $0x26,%eax
je     12ef <xmlDecodeBody+0x1ef>
jmp    1145 <xmlDecodeBody+0x45>
mov    -0x34(%rbp),%eax
sub    $0x3c,%eax
jne    1ed9 <xmlDecodeBody+0xdd9>
jmp    1156 <xmlDecodeBody+0x56>
cmpl   $0xa,-0x24(%rbp)
jbe    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x21,%eax
jne    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
movzbl 0x2(%rax),%eax
cmp    $0x5b,%eax
jne    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
movzbl 0x3(%rax),%eax
cmp    $0x43,%eax
jne    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
cmp    $0x44,%eax
jne    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
movzbl 0x5(%rax),%eax
cmp    $0x41,%eax
jne    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
movzbl 0x6(%rax),%eax
cmp    $0x54,%eax
jne    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
movzbl 0x7(%rax),%eax
cmp    $0x41,%eax
jne    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
movzbl 0x8(%rax),%eax
cmp    $0x5b,%eax
jne    12ab <xmlDecodeBody+0x1ab>
mov    -0x20(%rbp),%rax
add    $0x9,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
je     12a6 <xmlDecodeBody+0x1a6>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x5d,%eax
jne    125d <xmlDecodeBody+0x15d>
mov    -0x20(%rbp),%rax
movzbl 0x1(%rax),%eax
cmp    $0x5d,%eax
jne    125d <xmlDecodeBody+0x15d>
mov    -0x20(%rbp),%rax
movzbl 0x2(%rax),%eax
cmp    $0x3e,%eax
jne    125d <xmlDecodeBody+0x15d>
mov    -0x20(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    12a6 <xmlDecodeBody+0x1a6>
cmpl   $0x0,-0x14(%rbp)
jbe    1287 <xmlDecodeBody+0x187>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    128c <xmlDecodeBody+0x18c>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11fd <xmlDecodeBody+0xfd>
jmp    12ea <xmlDecodeBody+0x1ea>
cmpl   $0x0,-0x14(%rbp)
jbe    12d5 <xmlDecodeBody+0x1d5>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    2541 <xmlDecodeBody+0x1441>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1314 <xmlDecodeBody+0x214>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x38(%rbp)
sub    $0x23,%eax
je     1817 <xmlDecodeBody+0x717>
jmp    132c <xmlDecodeBody+0x22c>
mov    -0x38(%rbp),%eax
sub    $0x61,%eax
je     1370 <xmlDecodeBody+0x270>
jmp    133d <xmlDecodeBody+0x23d>
mov    -0x38(%rbp),%eax
sub    $0x67,%eax
je     1572 <xmlDecodeBody+0x472>
jmp    134e <xmlDecodeBody+0x24e>
mov    -0x38(%rbp),%eax
sub    $0x6c,%eax
je     162b <xmlDecodeBody+0x52b>
jmp    135f <xmlDecodeBody+0x25f>
mov    -0x38(%rbp),%eax
sub    $0x71,%eax
je     16e4 <xmlDecodeBody+0x5e4>
jmp    1ed4 <xmlDecodeBody+0xdd4>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1395 <xmlDecodeBody+0x295>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x3c(%rbp)
sub    $0x6d,%eax
je     13be <xmlDecodeBody+0x2be>
jmp    13ad <xmlDecodeBody+0x2ad>
mov    -0x3c(%rbp),%eax
sub    $0x70,%eax
je     1477 <xmlDecodeBody+0x377>
jmp    156d <xmlDecodeBody+0x46d>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    13e3 <xmlDecodeBody+0x2e3>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x70,%al
jne    1472 <xmlDecodeBody+0x372>
jmp    13f6 <xmlDecodeBody+0x2f6>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    141b <xmlDecodeBody+0x31b>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x3b,%al
jne    146d <xmlDecodeBody+0x36d>
jmp    142e <xmlDecodeBody+0x32e>
cmpl   $0x0,-0x14(%rbp)
jbe    1453 <xmlDecodeBody+0x353>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x26,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1119 <xmlDecodeBody+0x19>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    149c <xmlDecodeBody+0x39c>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x6f,%al
jne    1568 <xmlDecodeBody+0x468>
jmp    14af <xmlDecodeBody+0x3af>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    14d4 <xmlDecodeBody+0x3d4>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x73,%al
jne    1563 <xmlDecodeBody+0x463>
jmp    14e7 <xmlDecodeBody+0x3e7>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    150c <xmlDecodeBody+0x40c>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x3b,%al
jne    155e <xmlDecodeBody+0x45e>
jmp    151f <xmlDecodeBody+0x41f>
cmpl   $0x0,-0x14(%rbp)
jbe    1544 <xmlDecodeBody+0x444>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x27,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1119 <xmlDecodeBody+0x19>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1597 <xmlDecodeBody+0x497>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x74,%al
jne    1626 <xmlDecodeBody+0x526>
jmp    15aa <xmlDecodeBody+0x4aa>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    15cf <xmlDecodeBody+0x4cf>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x3b,%al
jne    1621 <xmlDecodeBody+0x521>
jmp    15e2 <xmlDecodeBody+0x4e2>
cmpl   $0x0,-0x14(%rbp)
jbe    1607 <xmlDecodeBody+0x507>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x3e,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1119 <xmlDecodeBody+0x19>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1650 <xmlDecodeBody+0x550>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x74,%al
jne    16df <xmlDecodeBody+0x5df>
jmp    1663 <xmlDecodeBody+0x563>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1688 <xmlDecodeBody+0x588>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x3b,%al
jne    16da <xmlDecodeBody+0x5da>
jmp    169b <xmlDecodeBody+0x59b>
cmpl   $0x0,-0x14(%rbp)
jbe    16c0 <xmlDecodeBody+0x5c0>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x3c,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1119 <xmlDecodeBody+0x19>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1709 <xmlDecodeBody+0x609>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x75,%al
jne    1812 <xmlDecodeBody+0x712>
jmp    171c <xmlDecodeBody+0x61c>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1741 <xmlDecodeBody+0x641>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x6f,%al
jne    180d <xmlDecodeBody+0x70d>
jmp    1754 <xmlDecodeBody+0x654>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1779 <xmlDecodeBody+0x679>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x74,%al
jne    1808 <xmlDecodeBody+0x708>
jmp    178c <xmlDecodeBody+0x68c>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    17b1 <xmlDecodeBody+0x6b1>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
sub    $0x3b,%al
jne    1803 <xmlDecodeBody+0x703>
jmp    17c4 <xmlDecodeBody+0x6c4>
cmpl   $0x0,-0x14(%rbp)
jbe    17e9 <xmlDecodeBody+0x6e9>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x22,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1119 <xmlDecodeBody+0x19>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    183c <xmlDecodeBody+0x73c>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x40(%rbp)
add    $0xffffffd0,%eax
sub    $0xa,%eax
jb     1868 <xmlDecodeBody+0x768>
jmp    1857 <xmlDecodeBody+0x757>
mov    -0x40(%rbp),%eax
sub    $0x78,%eax
je     190a <xmlDecodeBody+0x80a>
jmp    1ecf <xmlDecodeBody+0xdcf>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
cltq
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1905 <xmlDecodeBody+0x805>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x44(%rbp)
add    $0xffffffd0,%eax
sub    $0xa,%eax
jb     18ba <xmlDecodeBody+0x7ba>
jmp    18a9 <xmlDecodeBody+0x7a9>
mov    -0x44(%rbp),%eax
sub    $0x3b,%eax
je     18dc <xmlDecodeBody+0x7dc>
jmp    18e1 <xmlDecodeBody+0x7e1>
imul   $0xa,-0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
cltq
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    18e6 <xmlDecodeBody+0x7e6>
jmp    1a98 <xmlDecodeBody+0x998>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    18eb <xmlDecodeBody+0x7eb>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1884 <xmlDecodeBody+0x784>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    192f <xmlDecodeBody+0x82f>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x48(%rbp)
add    $0xffffffd0,%eax
sub    $0xa,%eax
jb     1972 <xmlDecodeBody+0x872>
jmp    194a <xmlDecodeBody+0x84a>
mov    -0x48(%rbp),%eax
add    $0xffffffbf,%eax
sub    $0x6,%eax
jb     1987 <xmlDecodeBody+0x887>
jmp    195e <xmlDecodeBody+0x85e>
mov    -0x48(%rbp),%eax
add    $0xffffff9f,%eax
sub    $0x6,%eax
jb     199f <xmlDecodeBody+0x89f>
jmp    1eca <xmlDecodeBody+0xdca>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
cltq
mov    %rax,-0x30(%rbp)
jmp    19b2 <xmlDecodeBody+0x8b2>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
sub    $0x41,%eax
add    $0xa,%eax
cltq
mov    %rax,-0x30(%rbp)
jmp    19b2 <xmlDecodeBody+0x8b2>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
sub    $0x61,%eax
add    $0xa,%eax
cltq
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1a93 <xmlDecodeBody+0x993>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
add    $0xffffffd0,%eax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
sub    $0x36,%eax
ja     1a6f <xmlDecodeBody+0x96f>
mov    -0x50(%rbp),%rax
lea    0x1614(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x30(%rbp),%rax
shl    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
sub    $0x30,%eax
cltq
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1a74 <xmlDecodeBody+0x974>
mov    -0x30(%rbp),%rax
shl    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
sub    $0x41,%eax
add    $0xa,%eax
cltq
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1a74 <xmlDecodeBody+0x974>
mov    -0x30(%rbp),%rax
shl    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
sub    $0x61,%eax
add    $0xa,%eax
cltq
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1a74 <xmlDecodeBody+0x974>
jmp    1a98 <xmlDecodeBody+0x998>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    1a79 <xmlDecodeBody+0x979>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    19be <xmlDecodeBody+0x8be>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
jne    1ab1 <xmlDecodeBody+0x9b1>
jmp    2551 <xmlDecodeBody+0x1451>
cmpq   $0x7f,-0x30(%rbp)
ja     1af4 <xmlDecodeBody+0x9f4>
cmpl   $0x0,-0x14(%rbp)
jbe    1ae6 <xmlDecodeBody+0x9e6>
mov    -0x30(%rbp),%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1eb9 <xmlDecodeBody+0xdb9>
cmpq   $0x7ff,-0x30(%rbp)
ja     1b65 <xmlDecodeBody+0xa65>
cmpl   $0x1,-0x14(%rbp)
jbe    1b57 <xmlDecodeBody+0xa57>
mov    -0x30(%rbp),%rax
shr    $0x6,%rax
or     $0xc0,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    1eb4 <xmlDecodeBody+0xdb4>
cmpq   $0xffff,-0x30(%rbp)
ja     1bfb <xmlDecodeBody+0xafb>
cmpl   $0x2,-0x14(%rbp)
jbe    1bed <xmlDecodeBody+0xaed>
mov    -0x30(%rbp),%rax
shr    $0xc,%rax
or     $0xe0,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0x6,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x28(%rbp)
jmp    1eaf <xmlDecodeBody+0xdaf>
cmpq   $0x1fffff,-0x30(%rbp)
ja     1cb6 <xmlDecodeBody+0xbb6>
cmpl   $0x3,-0x14(%rbp)
jbe    1ca8 <xmlDecodeBody+0xba8>
mov    -0x30(%rbp),%rax
shr    $0x12,%rax
or     $0xf0,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0xc,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0x6,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    1eaa <xmlDecodeBody+0xdaa>
cmpq   $0x3ffffff,-0x30(%rbp)
03
ja     1d96 <xmlDecodeBody+0xc96>
cmpl   $0x4,-0x14(%rbp)
jbe    1d88 <xmlDecodeBody+0xc88>
mov    -0x30(%rbp),%rax
shr    $0x18,%rax
or     $0xf8,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0x12,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0xc,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0x6,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x28(%rbp)
jmp    1ea5 <xmlDecodeBody+0xda5>
cmpq   $0x7fffffff,-0x30(%rbp)
7f
ja     1e9b <xmlDecodeBody+0xd9b>
cmpl   $0x5,-0x14(%rbp)
jbe    1e8d <xmlDecodeBody+0xd8d>
mov    -0x30(%rbp),%rax
shr    $0x1e,%rax
or     $0xfc,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0x18,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0x12,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0xc,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
shr    $0x6,%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
and    $0x3f,%rax
or     $0x80,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x28(%rbp)
jmp    1ea0 <xmlDecodeBody+0xda0>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    1ea5 <xmlDecodeBody+0xda5>
jmp    1eaa <xmlDecodeBody+0xdaa>
jmp    1eaf <xmlDecodeBody+0xdaf>
jmp    1eb4 <xmlDecodeBody+0xdb4>
jmp    1eb9 <xmlDecodeBody+0xdb9>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1119 <xmlDecodeBody+0x19>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2551 <xmlDecodeBody+0x1451>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
jne    1f42 <xmlDecodeBody+0xe42>
cmpl   $0x0,-0x14(%rbp)
jbe    1f28 <xmlDecodeBody+0xe28>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1f34 <xmlDecodeBody+0xe34>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    253c <xmlDecodeBody+0x143c>
cmpl   $0x0,-0x24(%rbp)
jbe    1ffa <xmlDecodeBody+0xefa>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0xe0,%eax
cmp    $0xc0,%eax
jne    1ffa <xmlDecodeBody+0xefa>
mov    -0x20(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    1ffa <xmlDecodeBody+0xefa>
cmpl   $0x1,-0x14(%rbp)
jbe    1fd7 <xmlDecodeBody+0xed7>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1fe3 <xmlDecodeBody+0xee3>
mov    -0x20(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    2537 <xmlDecodeBody+0x1437>
cmpl   $0x1,-0x24(%rbp)
jbe    20ec <xmlDecodeBody+0xfec>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0xf0,%eax
cmp    $0xe0,%eax
jne    20ec <xmlDecodeBody+0xfec>
mov    -0x20(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    20ec <xmlDecodeBody+0xfec>
mov    -0x20(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    20ec <xmlDecodeBody+0xfec>
cmpl   $0x2,-0x14(%rbp)
jbe    20c9 <xmlDecodeBody+0xfc9>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x14(%rbp)
jmp    20d5 <xmlDecodeBody+0xfd5>
mov    -0x20(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    2532 <xmlDecodeBody+0x1432>
cmpl   $0x2,-0x24(%rbp)
jbe    2218 <xmlDecodeBody+0x1118>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0xf8,%eax
cmp    $0xf0,%eax
jne    2218 <xmlDecodeBody+0x1118>
mov    -0x20(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    2218 <xmlDecodeBody+0x1118>
mov    -0x20(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    2218 <xmlDecodeBody+0x1118>
mov    -0x20(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    2218 <xmlDecodeBody+0x1118>
cmpl   $0x3,-0x14(%rbp)
jbe    21f5 <xmlDecodeBody+0x10f5>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x14(%rbp)
jmp    2201 <xmlDecodeBody+0x1101>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x24(%rbp)
jmp    252d <xmlDecodeBody+0x142d>
cmpl   $0x3,-0x24(%rbp)
jbe    237e <xmlDecodeBody+0x127e>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0xfc,%eax
cmp    $0xf8,%eax
jne    237e <xmlDecodeBody+0x127e>
mov    -0x20(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    237e <xmlDecodeBody+0x127e>
mov    -0x20(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    237e <xmlDecodeBody+0x127e>
mov    -0x20(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    237e <xmlDecodeBody+0x127e>
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    237e <xmlDecodeBody+0x127e>
cmpl   $0x4,-0x14(%rbp)
jbe    235b <xmlDecodeBody+0x125b>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x14(%rbp)
jmp    2367 <xmlDecodeBody+0x1267>
mov    -0x20(%rbp),%rax
add    $0x5,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x24(%rbp)
jmp    2528 <xmlDecodeBody+0x1428>
cmpl   $0x4,-0x24(%rbp)
jbe    251e <xmlDecodeBody+0x141e>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0xfe,%eax
cmp    $0xfc,%eax
jne    251e <xmlDecodeBody+0x141e>
mov    -0x20(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    251e <xmlDecodeBody+0x141e>
mov    -0x20(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    251e <xmlDecodeBody+0x141e>
mov    -0x20(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    251e <xmlDecodeBody+0x141e>
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    251e <xmlDecodeBody+0x141e>
mov    -0x20(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    251e <xmlDecodeBody+0x141e>
cmpl   $0x5,-0x14(%rbp)
jbe    24fb <xmlDecodeBody+0x13fb>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x14(%rbp)
jmp    2507 <xmlDecodeBody+0x1407>
mov    -0x20(%rbp),%rax
add    $0x6,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x5,%eax
mov    %eax,-0x24(%rbp)
jmp    2523 <xmlDecodeBody+0x1423>
jmp    2551 <xmlDecodeBody+0x1451>
jmp    2528 <xmlDecodeBody+0x1428>
jmp    252d <xmlDecodeBody+0x142d>
jmp    2532 <xmlDecodeBody+0x1432>
jmp    2537 <xmlDecodeBody+0x1437>
jmp    253c <xmlDecodeBody+0x143c>
jmp    2541 <xmlDecodeBody+0x1441>
jmp    1119 <xmlDecodeBody+0x19>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    2558 <xmlDecodeBody+0x1458>
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<xmlDecodeBody>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
test   %ecx,%ecx
je     1969 <xmlDecodeBody+0x869>
xor    %r14d,%r14d
movabs $0x7e0000007e03ff,%r8
lea    0xffc(%rip),%r9
lea    0xf19(%rip),%r10
lea    0xece(%rip),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%rcx),%r12d
movzbl (%rdx),%ebp
cmp    $0x26,%ebp
je     11d0 <xmlDecodeBody+0xd0>
cmp    $0x3c,%bpl
jne    1260 <xmlDecodeBody+0x160>
cmp    $0xb,%r12d
jb     1270 <xmlDecodeBody+0x170>
cmpb   $0x21,0x1(%rdx)
jne    1270 <xmlDecodeBody+0x170>
cmpb   $0x5b,0x2(%rdx)
jne    1270 <xmlDecodeBody+0x170>
cmpb   $0x43,0x3(%rdx)
jne    1270 <xmlDecodeBody+0x170>
cmpb   $0x44,0x4(%rdx)
jne    1270 <xmlDecodeBody+0x170>
cmpb   $0x41,0x5(%rdx)
jne    1270 <xmlDecodeBody+0x170>
cmpb   $0x54,0x6(%rdx)
jne    1270 <xmlDecodeBody+0x170>
cmpb   $0x41,0x7(%rdx)
jne    1270 <xmlDecodeBody+0x170>
cmpb   $0x5b,0x8(%rdx)
jne    1270 <xmlDecodeBody+0x170>
lea    (%rcx,%r14,1),%eax
add    $0xfffffff7,%eax
mov    %ecx,%ebp
add    $0xfffffffffffffff7,%rbp
xor    %ebx,%ebx
jmp    16aa <xmlDecodeBody+0x5aa>
nopl   0x0(%rax,%rax,1)
mov    $0xffffffff,%eax
test   %r12d,%r12d
je     196b <xmlDecodeBody+0x86b>
lea    -0x2(%rcx),%r15d
mov    0x1(%rdx),%bpl
lea    -0x61(%rbp),%ebx
cmp    $0x10,%bl
ja     14a5 <xmlDecodeBody+0x3a5>
movzbl %bl,%ebx
movslq (%r11,%rbx,4),%rbx
add    %r11,%rbx
jmp    *%rbx
test   %r15d,%r15d
je     196b <xmlDecodeBody+0x86b>
lea    -0x3(%rcx),%ebp
mov    0x2(%rdx),%bl
cmp    $0x70,%bl
je     15e7 <xmlDecodeBody+0x4e7>
cmp    $0x6d,%bl
jne    196b <xmlDecodeBody+0x86b>
test   %ebp,%ebp
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x70,0x3(%rdx)
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x4,%ecx
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x3b,0x4(%rdx)
jne    196b <xmlDecodeBody+0x86b>
test   %esi,%esi
je     163a <xmlDecodeBody+0x53a>
movb   $0x26,(%rdi)
add    $0x1,%rdi
add    $0xffffffff,%esi
jmp    163c <xmlDecodeBody+0x53c>
nopl   0x0(%rax,%rax,1)
test   $0x80,%bpl
jne    128f <xmlDecodeBody+0x18f>
test   %esi,%esi
je     1280 <xmlDecodeBody+0x180>
mov    %bpl,(%rdi)
jmp    1277 <xmlDecodeBody+0x177>
nop
test   %esi,%esi
je     1280 <xmlDecodeBody+0x180>
movb   $0x3c,(%rdi)
add    $0x1,%rdi
add    $0xffffffff,%esi
jmp    1282 <xmlDecodeBody+0x182>
xor    %esi,%esi
add    $0x1,%rdx
add    $0x1,%r14d
jmp    1657 <xmlDecodeBody+0x557>
test   %r12d,%r12d
je     12ce <xmlDecodeBody+0x1ce>
mov    %ebp,%eax
and    $0xffffffe0,%eax
cmp    $0xc0,%eax
jne    12ce <xmlDecodeBody+0x1ce>
mov    0x1(%rdx),%al
and    $0xc0,%al
cmp    $0x80,%al
jne    12ce <xmlDecodeBody+0x1ce>
cmp    $0x2,%esi
jb     12be <xmlDecodeBody+0x1be>
mov    %bpl,(%rdi)
mov    0x1(%rdx),%al
mov    %al,0x1(%rdi)
add    $0x2,%rdi
add    $0xfffffffe,%esi
add    $0x2,%rdx
add    $0x2,%r14d
add    $0xfffffffe,%ecx
jmp    1654 <xmlDecodeBody+0x554>
mov    $0xffffffff,%eax
cmp    $0x2,%r12d
jb     196b <xmlDecodeBody+0x86b>
mov    %ebp,%ebx
and    $0xf0,%bl
cmp    $0xe0,%bl
jne    1328 <xmlDecodeBody+0x228>
mov    0x1(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    1328 <xmlDecodeBody+0x228>
mov    0x2(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    1328 <xmlDecodeBody+0x228>
cmp    $0x3,%esi
jb     1318 <xmlDecodeBody+0x218>
mov    %bpl,(%rdi)
mov    0x1(%rdx),%al
mov    %al,0x1(%rdi)
mov    0x2(%rdx),%al
mov    %al,0x2(%rdi)
add    $0x3,%rdi
add    $0xfffffffd,%esi
add    $0x3,%rdx
add    $0x3,%r14d
add    $0xfffffffd,%ecx
jmp    1654 <xmlDecodeBody+0x554>
cmp    $0x3,%r12d
jb     196b <xmlDecodeBody+0x86b>
mov    %ebp,%ebx
and    $0xf8,%bl
cmp    $0xf0,%bl
jne    138e <xmlDecodeBody+0x28e>
mov    0x1(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    138e <xmlDecodeBody+0x28e>
mov    0x2(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    138e <xmlDecodeBody+0x28e>
mov    0x3(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    138e <xmlDecodeBody+0x28e>
cmp    $0x4,%esi
jb     137e <xmlDecodeBody+0x27e>
mov    %bpl,(%rdi)
mov    0x1(%rdx),%al
mov    %al,0x1(%rdi)
mov    0x2(%rdx),%al
mov    %al,0x2(%rdi)
mov    0x3(%rdx),%al
mov    %al,0x3(%rdi)
add    $0x4,%rdi
add    $0xfffffffc,%esi
add    $0x4,%rdx
add    $0x4,%r14d
add    $0xfffffffc,%ecx
jmp    1654 <xmlDecodeBody+0x554>
cmp    $0x4,%r12d
jb     196b <xmlDecodeBody+0x86b>
mov    %ebp,%ebx
and    $0xfc,%bl
cmp    $0xf8,%bl
jne    1405 <xmlDecodeBody+0x305>
mov    0x1(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    1405 <xmlDecodeBody+0x305>
mov    0x2(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    1405 <xmlDecodeBody+0x305>
mov    0x3(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    1405 <xmlDecodeBody+0x305>
mov    0x4(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    1405 <xmlDecodeBody+0x305>
cmp    $0x5,%esi
jb     13f5 <xmlDecodeBody+0x2f5>
mov    %bpl,(%rdi)
mov    0x1(%rdx),%al
mov    %al,0x1(%rdi)
mov    0x2(%rdx),%al
mov    %al,0x2(%rdi)
mov    0x3(%rdx),%al
mov    %al,0x3(%rdi)
mov    0x4(%rdx),%al
mov    %al,0x4(%rdi)
add    $0x5,%rdi
add    $0xfffffffb,%esi
add    $0x5,%rdx
add    $0x5,%r14d
add    $0xfffffffb,%ecx
jmp    1654 <xmlDecodeBody+0x554>
cmp    $0x5,%r12d
jb     196b <xmlDecodeBody+0x86b>
mov    %ebp,%ebx
and    $0xfe,%bl
cmp    $0xfc,%bl
jne    196b <xmlDecodeBody+0x86b>
mov    0x1(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    196b <xmlDecodeBody+0x86b>
mov    0x2(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    196b <xmlDecodeBody+0x86b>
mov    0x3(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    196b <xmlDecodeBody+0x86b>
mov    0x4(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    196b <xmlDecodeBody+0x86b>
mov    0x5(%rdx),%bl
and    $0xc0,%bl
cmp    $0x80,%bl
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x6,%esi
jb     1495 <xmlDecodeBody+0x395>
mov    %bpl,(%rdi)
mov    0x1(%rdx),%al
mov    %al,0x1(%rdi)
mov    0x2(%rdx),%al
mov    %al,0x2(%rdi)
mov    0x3(%rdx),%al
mov    %al,0x3(%rdi)
mov    0x4(%rdx),%al
mov    %al,0x4(%rdi)
mov    0x5(%rdx),%al
mov    %al,0x5(%rdi)
add    $0x6,%rdi
add    $0xfffffffa,%esi
add    $0x6,%rdx
add    $0x6,%r14d
add    $0xfffffffa,%ecx
jmp    1654 <xmlDecodeBody+0x554>
cmp    $0x23,%bpl
jne    196b <xmlDecodeBody+0x86b>
test   %r15d,%r15d
je     196b <xmlDecodeBody+0x86b>
lea    -0x3(%rcx),%r12d
mov    0x2(%rdx),%r15b
lea    -0x30(%r15),%ebx
cmp    $0xa,%bl
jae    16d8 <xmlDecodeBody+0x5d8>
test   %r12d,%r12d
je     196b <xmlDecodeBody+0x86b>
movzbl %r15b,%ebx
add    $0x3,%rdx
add    $0xffffffffffffffd0,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdx),%ecx
lea    -0x30(%rcx),%ebp
cmp    $0xa,%bpl
jae    166e <xmlDecodeBody+0x56e>
movzbl %cl,%ecx
lea    (%rbx,%rbx,4),%rbx
lea    (%rcx,%rbx,2),%rbx
add    $0xffffffffffffffd0,%rbx
add    $0x1,%rdx
add    $0xffffffff,%r12d
jne    14f0 <xmlDecodeBody+0x3f0>
jmp    196b <xmlDecodeBody+0x86b>
test   %r15d,%r15d
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x74,0x2(%rdx)
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x3,%ecx
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x3b,0x3(%rdx)
jne    196b <xmlDecodeBody+0x86b>
test   %esi,%esi
je     15dc <xmlDecodeBody+0x4dc>
movb   $0x3e,(%rdi)
jmp    157e <xmlDecodeBody+0x47e>
test   %r15d,%r15d
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x74,0x2(%rdx)
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x3,%ecx
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x3b,0x3(%rdx)
jne    196b <xmlDecodeBody+0x86b>
test   %esi,%esi
je     15dc <xmlDecodeBody+0x4dc>
movb   $0x3c,(%rdi)
add    $0x1,%rdi
add    $0xffffffff,%esi
jmp    15de <xmlDecodeBody+0x4de>
test   %r15d,%r15d
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x75,0x2(%rdx)
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x3,%ecx
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x6f,0x3(%rdx)
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x4,%ecx
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x74,0x4(%rdx)
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x5,%ecx
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x3b,0x5(%rdx)
jne    196b <xmlDecodeBody+0x86b>
test   %esi,%esi
je     162f <xmlDecodeBody+0x52f>
movb   $0x22,(%rdi)
jmp    1626 <xmlDecodeBody+0x526>
xor    %esi,%esi
add    $0xfffffffc,%ecx
add    $0x4,%rdx
jmp    1650 <xmlDecodeBody+0x550>
test   %ebp,%ebp
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x6f,0x3(%rdx)
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x4,%ecx
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x73,0x4(%rdx)
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x5,%ecx
je     196b <xmlDecodeBody+0x86b>
cmpb   $0x3b,0x5(%rdx)
jne    196b <xmlDecodeBody+0x86b>
test   %esi,%esi
je     162f <xmlDecodeBody+0x52f>
movb   $0x27,(%rdi)
add    $0x1,%rdi
add    $0xffffffff,%esi
jmp    1631 <xmlDecodeBody+0x531>
xor    %esi,%esi
add    $0xfffffffa,%ecx
add    $0x6,%rdx
jmp    1650 <xmlDecodeBody+0x550>
xor    %esi,%esi
add    $0xfffffffb,%ecx
add    $0x5,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14d
mov    %ecx,%r12d
mov    %r14d,%eax
mov    %eax,%r14d
mov    %r12d,%ecx
test   %r12d,%r12d
jne    1140 <xmlDecodeBody+0x40>
jmp    196b <xmlDecodeBody+0x86b>
cmp    $0x3b,%cl
jne    196b <xmlDecodeBody+0x86b>
cmp    $0x7f,%rbx
ja     1795 <xmlDecodeBody+0x695>
mov    $0x1,%eax
test   %esi,%esi
je     176f <xmlDecodeBody+0x66f>
mov    %bl,(%rdi)
add    $0x1,%rdi
add    $0xffffffff,%esi
jmp    1945 <xmlDecodeBody+0x845>
xor    %esi,%esi
add    $0x1,%rbx
cmp    %ebx,%ebp
je     1776 <xmlDecodeBody+0x676>
movzbl 0x9(%rdx,%rbx,1),%r15d
cmp    $0x5d,%r15b
jne    16c8 <xmlDecodeBody+0x5c8>
cmpb   $0x5d,0xa(%rdx,%rbx,1)
jne    16c8 <xmlDecodeBody+0x5c8>
cmpb   $0x3e,0xb(%rdx,%rbx,1)
je     1955 <xmlDecodeBody+0x855>
test   %esi,%esi
je     169c <xmlDecodeBody+0x59c>
mov    %r15b,(%rdi)
add    $0x1,%rdi
add    $0xffffffff,%esi
jmp    169e <xmlDecodeBody+0x59e>
cmp    $0x78,%r15b
jne    196b <xmlDecodeBody+0x86b>
test   %r12d,%r12d
je     196b <xmlDecodeBody+0x86b>
movzbl 0x3(%rdx),%ebx
lea    -0x30(%rbx),%r15d
cmp    $0x36,%r15b
ja     196b <xmlDecodeBody+0x86b>
movzbl %r15b,%ebp
bt     %rbp,%r8
jae    196b <xmlDecodeBody+0x86b>
add    $0xfffffffc,%ecx
je     196b <xmlDecodeBody+0x86b>
movsbq %r15b,%rbp
add    (%r9,%rbp,8),%rbx
add    $0x4,%rdx
jmp    1740 <xmlDecodeBody+0x640>
mov    $0xffffffffffffffa9,%r12
shl    $0x4,%rbx
add    %r12,%rbx
add    %r15,%rbx
add    $0x1,%rdx
add    $0xffffffff,%ecx
je     196b <xmlDecodeBody+0x86b>
movzbl (%rdx),%r15d
lea    -0x30(%r15),%ebp
cmp    $0x36,%bpl
ja     196b <xmlDecodeBody+0x86b>
mov    $0xffffffffffffffd0,%r12
movzbl %bpl,%ebp
movslq (%r10,%rbp,4),%rbp
add    %r10,%rbp
jmp    *%rbp
mov    $0xffffffffffffffc9,%r12
jmp    1729 <xmlDecodeBody+0x629>
xor    %esi,%esi
jmp    1945 <xmlDecodeBody+0x845>
add    %rbx,%rdx
add    $0x9,%rdx
mov    $0xffffffff,%r12d
jmp    165a <xmlDecodeBody+0x55a>
mov    %ecx,%r12d
cmp    $0x7f,%rbx
jbe    1681 <xmlDecodeBody+0x581>
cmp    $0x7ff,%rbx
ja     17cd <xmlDecodeBody+0x6cd>
mov    $0x2,%eax
cmp    $0x2,%esi
jb     1945 <xmlDecodeBody+0x845>
mov    %rbx,%rcx
shr    $0x6,%rcx
or     $0xc0,%cl
mov    %cl,(%rdi)
and    $0x3f,%bl
or     $0x80,%bl
mov    %bl,0x1(%rdi)
add    $0x2,%rdi
add    $0xfffffffe,%esi
jmp    1945 <xmlDecodeBody+0x845>
cmp    $0xffff,%rbx
ja     1815 <xmlDecodeBody+0x715>
mov    $0x3,%eax
cmp    $0x3,%esi
jb     1945 <xmlDecodeBody+0x845>
mov    %rbx,%rcx
shr    $0xc,%rcx
or     $0xe0,%cl
mov    %cl,(%rdi)
mov    %rbx,%rcx
shr    $0x6,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x1(%rdi)
and    $0x3f,%bl
or     $0x80,%bl
mov    %bl,0x2(%rdi)
add    $0x3,%rdi
add    $0xfffffffd,%esi
jmp    1945 <xmlDecodeBody+0x845>
cmp    $0x1fffff,%rbx
ja     186d <xmlDecodeBody+0x76d>
mov    $0x4,%eax
cmp    $0x4,%esi
jb     1945 <xmlDecodeBody+0x845>
mov    %rbx,%rcx
shr    $0x12,%rcx
or     $0xf0,%cl
mov    %cl,(%rdi)
mov    %rbx,%rcx
shr    $0xc,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x1(%rdi)
mov    %rbx,%rcx
shr    $0x6,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x2(%rdi)
and    $0x3f,%bl
or     $0x80,%bl
mov    %bl,0x3(%rdi)
add    $0x4,%rdi
add    $0xfffffffc,%esi
jmp    1945 <xmlDecodeBody+0x845>
cmp    $0x3ffffff,%rbx
ja     18d2 <xmlDecodeBody+0x7d2>
mov    $0x5,%eax
cmp    $0x5,%esi
jb     1945 <xmlDecodeBody+0x845>
mov    %rbx,%rcx
shr    $0x18,%rcx
or     $0xf8,%cl
mov    %cl,(%rdi)
mov    %rbx,%rcx
shr    $0x12,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x1(%rdi)
mov    %rbx,%rcx
shr    $0xc,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x2(%rdi)
mov    %rbx,%rcx
shr    $0x6,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x3(%rdi)
and    $0x3f,%bl
or     $0x80,%bl
mov    %bl,0x4(%rdi)
add    $0x5,%rdi
add    $0xfffffffb,%esi
jmp    1945 <xmlDecodeBody+0x845>
cmp    $0x7fffffff,%rbx
ja     196b <xmlDecodeBody+0x86b>
mov    $0x6,%eax
cmp    $0x6,%esi
jb     1945 <xmlDecodeBody+0x845>
mov    %rbx,%rcx
shr    $0x1e,%rcx
or     $0xfc,%cl
mov    %cl,(%rdi)
mov    %rbx,%rcx
shr    $0x18,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x1(%rdi)
mov    %rbx,%rcx
shr    $0x12,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x2(%rdi)
mov    %rbx,%rcx
shr    $0xc,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x3(%rdi)
mov    %rbx,%rcx
shr    $0x6,%rcx
and    $0x3f,%cl
or     $0x80,%cl
mov    %cl,0x4(%rdi)
and    $0x3f,%bl
or     $0x80,%bl
mov    %bl,0x5(%rdi)
add    $0x6,%rdi
add    $0xfffffffa,%esi
add    $0xffffffff,%r12d
add    %eax,%r14d
add    $0x1,%rdx
jmp    1657 <xmlDecodeBody+0x557>
add    %rbx,%rdx
add    $0xc,%rdx
sub    %ebx,%ecx
add    $0xfffffff4,%ecx
add    %ebx,%r14d
jmp    1654 <xmlDecodeBody+0x554>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@switch.table.xmlDecodeBody = [55 x i64] [i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -55, i64 -55, i64 -55, i64 -55, i64 -55, i64 -55, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -48, i64 -87, i64 -87, i64 -87, i64 -87, i64 -87, i64 -87]
define i32 @xmlDecodeBody(i8* writeonly %0, i32 %1, i8* %2, i32 %3) {
%5 = icmp eq i32 %3, 0
br i1 %5, label %647, label %6
6: ; preds = %4, %131
%7 = phi i32 [ %136, %131 ], [ 0, %4 ]
%8 = phi i32 [ %135, %131 ], [ %3, %4 ]
%9 = phi i8* [ %134, %131 ], [ %2, %4 ]
%10 = phi i32 [ %133, %131 ], [ %1, %4 ]
%11 = phi i8* [ %132, %131 ], [ %0, %4 ]
%12 = add i32 %8, -1
%13 = load i8, i8* %9
%14 = zext i8 %13 to i32
switch i8 %13, label %449 [
i8 60, label %15
i8 38, label %96
]
15: ; preds = %6
%16 = icmp ugt i32 %12, 10
br i1 %16, label %17, label %86
17: ; preds = %15
%18 = getelementptr inbounds i8, i8* %9, i64 1
%19 = load i8, i8* %18
%20 = icmp eq i8 %19, 33
br i1 %20, label %21, label %86
21: ; preds = %17
%22 = getelementptr inbounds i8, i8* %9, i64 2
%23 = load i8, i8* %22
%24 = icmp eq i8 %23, 91
br i1 %24, label %25, label %86
25: ; preds = %21
%26 = getelementptr inbounds i8, i8* %9, i64 3
%27 = load i8, i8* %26
%28 = icmp eq i8 %27, 67
br i1 %28, label %29, label %86
29: ; preds = %25
%30 = getelementptr inbounds i8, i8* %9, i64 4
%31 = load i8, i8* %30
%32 = icmp eq i8 %31, 68
br i1 %32, label %33, label %86
33: ; preds = %29
%34 = getelementptr inbounds i8, i8* %9, i64 5
%35 = load i8, i8* %34
%36 = icmp eq i8 %35, 65
br i1 %36, label %37, label %86
37: ; preds = %33
%38 = getelementptr inbounds i8, i8* %9, i64 6
%39 = load i8, i8* %38
%40 = icmp eq i8 %39, 84
br i1 %40, label %41, label %86
41: ; preds = %37
%42 = getelementptr inbounds i8, i8* %9, i64 7
%43 = load i8, i8* %42
%44 = icmp eq i8 %43, 65
br i1 %44, label %45, label %86
45: ; preds = %41
%46 = getelementptr inbounds i8, i8* %9, i64 8
%47 = load i8, i8* %46
%48 = icmp eq i8 %47, 91
br i1 %48, label %49, label %86
49: ; preds = %45
%50 = getelementptr inbounds i8, i8* %9, i64 9
%51 = add i32 %8, -9
%52 = add i32 %8, -10
%53 = add i32 %51, %7
br label %54
54: ; preds = %49, %79
%55 = phi i32 [ %84, %79 ], [ %52, %49 ]
%56 = phi i32 [ %83, %79 ], [ %7, %49 ]
%57 = phi i32 [ %55, %79 ], [ %51, %49 ]
%58 = phi i8* [ %82, %79 ], [ %50, %49 ]
%59 = phi i32 [ %81, %79 ], [ %10, %49 ]
%60 = phi i8* [ %80, %79 ], [ %11, %49 ]
%61 = load i8, i8* %58
%62 = icmp eq i8 %61, 93
br i1 %62, label %63, label %74
63: ; preds = %54
%64 = getelementptr inbounds i8, i8* %58, i64 1
%65 = load i8, i8* %64
%66 = icmp eq i8 %65, 93
br i1 %66, label %67, label %74
67: ; preds = %63
%68 = getelementptr inbounds i8, i8* %58, i64 2
%69 = load i8, i8* %68
%70 = icmp eq i8 %69, 62
br i1 %70, label %71, label %74
71: ; preds = %67
%72 = getelementptr inbounds i8, i8* %58, i64 3
%73 = add i32 %57, -3
br label %131
74: ; preds = %67, %63, %54
%75 = icmp eq i32 %59, 0
br i1 %75, label %79, label %76
76: ; preds = %74
%77 = getelementptr inbounds i8, i8* %60, i64 1
store i8 %61, i8* %60
%78 = add i32 %59, -1
br label %79
79: ; preds = %74, %76
%80 = phi i8* [ %77, %76 ], [ %60, %74 ]
%81 = phi i32 [ %78, %76 ], [ 0, %74 ]
%82 = getelementptr inbounds i8, i8* %58, i64 1
%83 = add nsw i32 %56, 1
%84 = add i32 %55, -1
%85 = icmp eq i32 %55, 0
br i1 %85, label %131, label %54
86: ; preds = %45, %41, %37, %33, %29, %25, %21, %17, %15
%87 = icmp eq i32 %10, 0
br i1 %87, label %91, label %88
88: ; preds = %86
%89 = getelementptr inbounds i8, i8* %11, i64 1
store i8 60, i8* %11
%90 = add i32 %10, -1
br label %91
91: ; preds = %88, %86
%92 = phi i8* [ %89, %88 ], [ %11, %86 ]
%93 = phi i32 [ %90, %88 ], [ 0, %86 ]
%94 = getelementptr inbounds i8, i8* %9, i64 1
%95 = add nsw i32 %7, 1
br label %131
96: ; preds = %6
%97 = add i32 %8, -2
%98 = icmp eq i32 %12, 0
br i1 %98, label %647, label %99
99: ; preds = %96
%100 = getelementptr inbounds i8, i8* %9, i64 1
%101 = load i8, i8* %100
switch i8 %101, label %647 [
i8 97, label %102
i8 103, label %167
i8 108, label %190
i8 113, label %213
i8 35, label %248
]
102: ; preds = %99
%103 = add i32 %8, -3
%104 = icmp eq i32 %97, 0
br i1 %104, label %647, label %105
105: ; preds = %102
%106 = getelementptr inbounds i8, i8* %9, i64 2
%107 = load i8, i8* %106
switch i8 %107, label %647 [
i8 109, label %108
i8 112, label %138
]
108: ; preds = %105
%109 = icmp eq i32 %103, 0
br i1 %109, label %647, label %110
110: ; preds = %108
%111 = getelementptr inbounds i8, i8* %9, i64 3
%112 = load i8, i8* %111
%113 = icmp eq i8 %112, 112
br i1 %113, label %114, label %647
114: ; preds = %110
%115 = add i32 %8, -5
%116 = icmp eq i32 %8, 4
br i1 %116, label %647, label %117
117: ; preds = %114
%118 = getelementptr inbounds i8, i8* %9, i64 4
%119 = load i8, i8* %118
%120 = icmp eq i8 %119, 59
br i1 %120, label %121, label %647
121: ; preds = %117
%122 = icmp eq i32 %10, 0
br i1 %122, label %126, label %123
123: ; preds = %121
%124 = getelementptr inbounds i8, i8* %11, i64 1
store i8 38, i8* %11
%125 = add i32 %10, -1
br label %126
126: ; preds = %123, %121
%127 = phi i8* [ %124, %123 ], [ %11, %121 ]
%128 = phi i32 [ %125, %123 ], [ 0, %121 ]
%129 = getelementptr inbounds i8, i8* %9, i64 5
%130 = add nsw i32 %7, 1
br label %131
131: ; preds = %79, %71, %91, %479, %546, %641, %590, %509, %457, %126, %162, %185, %208, %243, %443
%132 = phi i8* [ %445, %443 ], [ %244, %243 ], [ %209, %208 ], [ %186, %185 ], [ %163, %162 ], [ %127, %126 ], [ %458, %457 ], [ %480, %479 ], [ %510, %509 ], [ %547, %546 ], [ %591, %590 ], [ %642, %641 ], [ %60, %71 ], [ %92, %91 ], [ %80, %79 ]
%133 = phi i32 [ %446, %443 ], [ %245, %243 ], [ %210, %208 ], [ %187, %185 ], [ %164, %162 ], [ %128, %126 ], [ %459, %457 ], [ %481, %479 ], [ %511, %509 ], [ %548, %546 ], [ %592, %590 ], [ %643, %641 ], [ %59, %71 ], [ %93, %91 ], [ %81, %79 ]
%134 = phi i8* [ %448, %443 ], [ %246, %243 ], [ %211, %208 ], [ %188, %185 ], [ %165, %162 ], [ %129, %126 ], [ %460, %457 ], [ %482, %479 ], [ %512, %509 ], [ %549, %546 ], [ %593, %590 ], [ %644, %641 ], [ %72, %71 ], [ %94, %91 ], [ %82, %79 ]
%135 = phi i32 [ %315, %443 ], [ %232, %243 ], [ %197, %208 ], [ %174, %185 ], [ %151, %162 ], [ %115, %126 ], [ %12, %457 ], [ %484, %479 ], [ %514, %509 ], [ %551, %546 ], [ %595, %590 ], [ %646, %641 ], [ %73, %71 ], [ %12, %91 ], [ -1, %79 ]
%136 = phi i32 [ %447, %443 ], [ %247, %243 ], [ %212, %208 ], [ %189, %185 ], [ %166, %162 ], [ %130, %126 ], [ %461, %457 ], [ %483, %479 ], [ %513, %509 ], [ %550, %546 ], [ %594, %590 ], [ %645, %641 ], [ %56, %71 ], [ %95, %91 ], [ %53, %79 ]
%137 = icmp eq i32 %135, 0
br i1 %137, label %647, label %6
138: ; preds = %105
%139 = icmp eq i32 %103, 0
br i1 %139, label %647, label %140
140: ; preds = %138
%141 = getelementptr inbounds i8, i8* %9, i64 3
%142 = load i8, i8* %141
%143 = icmp ne i8 %142, 111
%144 = icmp eq i32 %8, 4
%145 = select i1 %143, i1 true, i1 %144
br i1 %145, label %647, label %146
146: ; preds = %140
%147 = getelementptr inbounds i8, i8* %9, i64 4
%148 = load i8, i8* %147
%149 = icmp eq i8 %148, 115
br i1 %149, label %150, label %647
150: ; preds = %146
%151 = add i32 %8, -6
%152 = icmp eq i32 %8, 5
br i1 %152, label %647, label %153
153: ; preds = %150
%154 = getelementptr inbounds i8, i8* %9, i64 5
%155 = load i8, i8* %154
%156 = icmp eq i8 %155, 59
br i1 %156, label %157, label %647
157: ; preds = %153
%158 = icmp eq i32 %10, 0
br i1 %158, label %162, label %159
159: ; preds = %157
%160 = getelementptr inbounds i8, i8* %11, i64 1
store i8 39, i8* %11
%161 = add i32 %10, -1
br label %162
162: ; preds = %159, %157
%163 = phi i8* [ %160, %159 ], [ %11, %157 ]
%164 = phi i32 [ %161, %159 ], [ 0, %157 ]
%165 = getelementptr inbounds i8, i8* %9, i64 6
%166 = add nsw i32 %7, 1
br label %131
167: ; preds = %99
%168 = icmp eq i32 %97, 0
br i1 %168, label %647, label %169
169: ; preds = %167
%170 = getelementptr inbounds i8, i8* %9, i64 2
%171 = load i8, i8* %170
%172 = icmp eq i8 %171, 116
br i1 %172, label %173, label %647
173: ; preds = %169
%174 = add i32 %8, -4
%175 = icmp eq i32 %8, 3
br i1 %175, label %647, label %176
176: ; preds = %173
%177 = getelementptr inbounds i8, i8* %9, i64 3
%178 = load i8, i8* %177
%179 = icmp eq i8 %178, 59
br i1 %179, label %180, label %647
180: ; preds = %176
%181 = icmp eq i32 %10, 0
br i1 %181, label %185, label %182
182: ; preds = %180
%183 = getelementptr inbounds i8, i8* %11, i64 1
store i8 62, i8* %11
%184 = add i32 %10, -1
br label %185
185: ; preds = %182, %180
%186 = phi i8* [ %183, %182 ], [ %11, %180 ]
%187 = phi i32 [ %184, %182 ], [ 0, %180 ]
%188 = getelementptr inbounds i8, i8* %9, i64 4
%189 = add nsw i32 %7, 1
br label %131
190: ; preds = %99
%191 = icmp eq i32 %97, 0
br i1 %191, label %647, label %192
192: ; preds = %190
%193 = getelementptr inbounds i8, i8* %9, i64 2
%194 = load i8, i8* %193
%195 = icmp eq i8 %194, 116
br i1 %195, label %196, label %647
196: ; preds = %192
%197 = add i32 %8, -4
%198 = icmp eq i32 %8, 3
br i1 %198, label %647, label %199
199: ; preds = %196
%200 = getelementptr inbounds i8, i8* %9, i64 3
%201 = load i8, i8* %200
%202 = icmp eq i8 %201, 59
br i1 %202, label %203, label %647
203: ; preds = %199
%204 = icmp eq i32 %10, 0
br i1 %204, label %208, label %205
205: ; preds = %203
%206 = getelementptr inbounds i8, i8* %11, i64 1
store i8 60, i8* %11
%207 = add i32 %10, -1
br label %208
208: ; preds = %205, %203
%209 = phi i8* [ %206, %205 ], [ %11, %203 ]
%210 = phi i32 [ %207, %205 ], [ 0, %203 ]
%211 = getelementptr inbounds i8, i8* %9, i64 4
%212 = add nsw i32 %7, 1
br label %131
213: ; preds = %99
%214 = icmp eq i32 %97, 0
br i1 %214, label %647, label %215
215: ; preds = %213
%216 = getelementptr inbounds i8, i8* %9, i64 2
%217 = load i8, i8* %216
%218 = icmp ne i8 %217, 117
%219 = icmp eq i32 %8, 3
%220 = select i1 %218, i1 true, i1 %219
br i1 %220, label %647, label %221
221: ; preds = %215
%222 = getelementptr inbounds i8, i8* %9, i64 3
%223 = load i8, i8* %222
%224 = icmp ne i8 %223, 111
%225 = icmp eq i32 %8, 4
%226 = select i1 %224, i1 true, i1 %225
br i1 %226, label %647, label %227
227: ; preds = %221
%228 = getelementptr inbounds i8, i8* %9, i64 4
%229 = load i8, i8* %228
%230 = icmp eq i8 %229, 116
br i1 %230, label %231, label %647
231: ; preds = %227
%232 = add i32 %8, -6
%233 = icmp eq i32 %8, 5
br i1 %233, label %647, label %234
234: ; preds = %231
%235 = getelementptr inbounds i8, i8* %9, i64 5
%236 = load i8, i8* %235
%237 = icmp eq i8 %236, 59
br i1 %237, label %238, label %647
238: ; preds = %234
%239 = icmp eq i32 %10, 0
br i1 %239, label %243, label %240
240: ; preds = %238
%241 = getelementptr inbounds i8, i8* %11, i64 1
store i8 34, i8* %11
%242 = add i32 %10, -1
br label %243
243: ; preds = %240, %238
%244 = phi i8* [ %241, %240 ], [ %11, %238 ]
%245 = phi i32 [ %242, %240 ], [ 0, %238 ]
%246 = getelementptr inbounds i8, i8* %9, i64 6
%247 = add nsw i32 %7, 1
br label %131
248: ; preds = %99
%249 = add i32 %8, -3
%250 = icmp eq i32 %97, 0
br i1 %250, label %647, label %251
251: ; preds = %248
%252 = getelementptr inbounds i8, i8* %9, i64 2
%253 = load i8, i8* %252
switch i8 %253, label %647 [
i8 48, label %254
i8 49, label %254
i8 50, label %254
i8 51, label %254
i8 52, label %254
i8 53, label %254
i8 54, label %254
i8 55, label %254
i8 56, label %254
i8 57, label %254
i8 120, label %273
]
254: ; preds = %251, %251, %251, %251, %251, %251, %251, %251, %251, %251
%255 = icmp eq i32 %249, 0
br i1 %255, label %647, label %256
256: ; preds = %254
%257 = getelementptr inbounds i8, i8* %9, i64 3
%258 = zext i8 %253 to i64
%259 = add nsw i64 %258, -48
br label %260
260: ; preds = %256, %265
%261 = phi i64 [ %269, %265 ], [ %259, %256 ]
%262 = phi i32 [ %271, %265 ], [ %249, %256 ]
%263 = phi i8* [ %270, %265 ], [ %257, %256 ]
%264 = load i8, i8* %263
switch i8 %264, label %647 [
i8 48, label %265
i8 49, label %265
i8 50, label %265
i8 51, label %265
i8 52, label %265
i8 53, label %265
i8 54, label %265
i8 55, label %265
i8 56, label %265
i8 57, label %265
i8 59, label %311
]
265: ; preds = %260, %260, %260, %260, %260, %260, %260, %260, %260, %260
%266 = mul i64 %261, 10
%267 = zext i8 %264 to i64
%268 = add i64 %266, -48
%269 = add i64 %268, %267
%270 = getelementptr inbounds i8, i8* %263, i64 1
%271 = add i32 %262, -1
%272 = icmp eq i32 %271, 0
br i1 %272, label %647, label %260
273: ; preds = %251
%274 = add i32 %8, -4
%275 = icmp eq i32 %249, 0
br i1 %275, label %647, label %276
276: ; preds = %273
%277 = getelementptr inbounds i8, i8* %9, i64 3
%278 = load i8, i8* %277
%279 = add i8 %278, -48
%280 = icmp ult i8 %279, 55
br i1 %280, label %281, label %647
281: ; preds = %276
%282 = zext i8 %279 to i64
%283 = lshr i64 35465847073801215, %282
%284 = and i64 %283, 1
%285 = icmp eq i64 %284, 0
%286 = icmp eq i32 %274, 0
%287 = select i1 %285, i1 true, i1 %286
br i1 %287, label %647, label %288
288: ; preds = %281
%289 = sext i8 %279 to i64
%290 = getelementptr inbounds [55 x i64], [55 x i64]* @switch.table.xmlDecodeBody, i64 0, i64 %289
%291 = load i64, i64* %290
%292 = zext i8 %278 to i64
%293 = add nsw i64 %291, %292
%294 = getelementptr inbounds i8, i8* %9, i64 4
br label %295
295: ; preds = %288, %302
%296 = phi i64 [ %307, %302 ], [ %293, %288 ]
%297 = phi i32 [ %309, %302 ], [ %274, %288 ]
%298 = phi i8* [ %308, %302 ], [ %294, %288 ]
%299 = load i8, i8* %298
switch i8 %299, label %647 [
i8 48, label %302
i8 49, label %302
i8 50, label %302
i8 51, label %302
i8 52, label %302
i8 53, label %302
i8 54, label %302
i8 55, label %302
i8 56, label %302
i8 57, label %302
i8 65, label %300
i8 66, label %300
i8 67, label %300
i8 68, label %300
i8 69, label %300
i8 70, label %300
i8 97, label %301
i8 98, label %301
i8 99, label %301
i8 100, label %301
i8 101, label %301
i8 102, label %301
i8 59, label %311
]
300: ; preds = %295, %295, %295, %295, %295, %295
br label %302
301: ; preds = %295, %295, %295, %295, %295, %295
br label %302
302: ; preds = %295, %295, %295, %295, %295, %295, %295, %295, %295, %295, %300, %301
%303 = phi i64 [ -55, %300 ], [ -87, %301 ], [ -48, %295 ], [ -48, %295 ], [ -48, %295 ], [ -48, %295 ], [ -48, %295 ], [ -48, %295 ], [ -48, %295 ], [ -48, %295 ], [ -48, %295 ], [ -48, %295 ]
%304 = shl i64 %296, 4
%305 = zext i8 %299 to i64
%306 = add i64 %304, %303
%307 = add i64 %306, %305
%308 = getelementptr inbounds i8, i8* %298, i64 1
%309 = add i32 %297, -1
%310 = icmp eq i32 %309, 0
br i1 %310, label %647, label %295
311: ; preds = %295, %260
%312 = phi i8* [ %263, %260 ], [ %298, %295 ]
%313 = phi i32 [ %262, %260 ], [ %297, %295 ]
%314 = phi i64 [ %261, %260 ], [ %296, %295 ]
%315 = add i32 %313, -1
%316 = icmp ult i64 %314, 128
br i1 %316, label %317, label %323
317: ; preds = %311
%318 = icmp eq i32 %10, 0
br i1 %318, label %443, label %319
319: ; preds = %317
%320 = trunc i64 %314 to i8
%321 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %320, i8* %11
%322 = add i32 %10, -1
br label %443
323: ; preds = %311
%324 = icmp ult i64 %314, 2048
br i1 %324, label %325, label %337
325: ; preds = %323
%326 = icmp ugt i32 %10, 1
br i1 %326, label %327, label %443
327: ; preds = %325
%328 = lshr i64 %314, 6
%329 = trunc i64 %328 to i8
%330 = or i8 %329, -64
%331 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %330, i8* %11
%332 = trunc i64 %314 to i8
%333 = and i8 %332, 63
%334 = or i8 %333, -128
%335 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %334, i8* %331
%336 = add i32 %10, -2
br label %443
337: ; preds = %323
%338 = icmp ult i64 %314, 65536
br i1 %338, label %339, label %356
339: ; preds = %337
%340 = icmp ugt i32 %10, 2
br i1 %340, label %341, label %443
341: ; preds = %339
%342 = lshr i64 %314, 12
%343 = trunc i64 %342 to i8
%344 = or i8 %343, -32
%345 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %344, i8* %11
%346 = lshr i64 %314, 6
%347 = trunc i64 %346 to i8
%348 = and i8 %347, 63
%349 = or i8 %348, -128
%350 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %349, i8* %345
%351 = trunc i64 %314 to i8
%352 = and i8 %351, 63
%353 = or i8 %352, -128
%354 = getelementptr inbounds i8, i8* %11, i64 3
store i8 %353, i8* %350
%355 = add i32 %10, -3
br label %443
356: ; preds = %337
%357 = icmp ult i64 %314, 2097152
br i1 %357, label %358, label %380
358: ; preds = %356
%359 = icmp ugt i32 %10, 3
br i1 %359, label %360, label %443
360: ; preds = %358
%361 = lshr i64 %314, 18
%362 = trunc i64 %361 to i8
%363 = or i8 %362, -16
%364 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %363, i8* %11
%365 = lshr i64 %314, 12
%366 = trunc i64 %365 to i8
%367 = and i8 %366, 63
%368 = or i8 %367, -128
%369 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %368, i8* %364
%370 = lshr i64 %314, 6
%371 = trunc i64 %370 to i8
%372 = and i8 %371, 63
%373 = or i8 %372, -128
%374 = getelementptr inbounds i8, i8* %11, i64 3
store i8 %373, i8* %369
%375 = trunc i64 %314 to i8
%376 = and i8 %375, 63
%377 = or i8 %376, -128
%378 = getelementptr inbounds i8, i8* %11, i64 4
store i8 %377, i8* %374
%379 = add i32 %10, -4
br label %443
380: ; preds = %356
%381 = icmp ult i64 %314, 67108864
br i1 %381, label %382, label %409
382: ; preds = %380
%383 = icmp ugt i32 %10, 4
br i1 %383, label %384, label %443
384: ; preds = %382
%385 = lshr i64 %314, 24
%386 = trunc i64 %385 to i8
%387 = or i8 %386, -8
%388 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %387, i8* %11
%389 = lshr i64 %314, 18
%390 = trunc i64 %389 to i8
%391 = and i8 %390, 63
%392 = or i8 %391, -128
%393 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %392, i8* %388
%394 = lshr i64 %314, 12
%395 = trunc i64 %394 to i8
%396 = and i8 %395, 63
%397 = or i8 %396, -128
%398 = getelementptr inbounds i8, i8* %11, i64 3
store i8 %397, i8* %393
%399 = lshr i64 %314, 6
%400 = trunc i64 %399 to i8
%401 = and i8 %400, 63
%402 = or i8 %401, -128
%403 = getelementptr inbounds i8, i8* %11, i64 4
store i8 %402, i8* %398
%404 = trunc i64 %314 to i8
%405 = and i8 %404, 63
%406 = or i8 %405, -128
%407 = getelementptr inbounds i8, i8* %11, i64 5
store i8 %406, i8* %403
%408 = add i32 %10, -5
br label %443
409: ; preds = %380
%410 = icmp ult i64 %314, 2147483648
br i1 %410, label %411, label %647
411: ; preds = %409
%412 = icmp ugt i32 %10, 5
br i1 %412, label %413, label %443
413: ; preds = %411
%414 = lshr i64 %314, 30
%415 = trunc i64 %414 to i8
%416 = or i8 %415, -4
%417 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %416, i8* %11
%418 = lshr i64 %314, 24
%419 = trunc i64 %418 to i8
%420 = and i8 %419, 63
%421 = or i8 %420, -128
%422 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %421, i8* %417
%423 = lshr i64 %314, 18
%424 = trunc i64 %423 to i8
%425 = and i8 %424, 63
%426 = or i8 %425, -128
%427 = getelementptr inbounds i8, i8* %11, i64 3
store i8 %426, i8* %422
%428 = lshr i64 %314, 12
%429 = trunc i64 %428 to i8
%430 = and i8 %429, 63
%431 = or i8 %430, -128
%432 = getelementptr inbounds i8, i8* %11, i64 4
store i8 %431, i8* %427
%433 = lshr i64 %314, 6
%434 = trunc i64 %433 to i8
%435 = and i8 %434, 63
%436 = or i8 %435, -128
%437 = getelementptr inbounds i8, i8* %11, i64 5
store i8 %436, i8* %432
%438 = trunc i64 %314 to i8
%439 = and i8 %438, 63
%440 = or i8 %439, -128
%441 = getelementptr inbounds i8, i8* %11, i64 6
store i8 %440, i8* %437
%442 = add i32 %10, -6
br label %443
443: ; preds = %411, %413, %382, %384, %358, %360, %339, %341, %325, %327, %317, %319
%444 = phi i32 [ 1, %319 ], [ 1, %317 ], [ 2, %327 ], [ 2, %325 ], [ 3, %341 ], [ 3, %339 ], [ 4, %360 ], [ 4, %358 ], [ 5, %384 ], [ 5, %382 ], [ 6, %413 ], [ 6, %411 ]
%445 = phi i8* [ %321, %319 ], [ %11, %317 ], [ %335, %327 ], [ %11, %325 ], [ %354, %341 ], [ %11, %339 ], [ %378, %360 ], [ %11, %358 ], [ %407, %384 ], [ %11, %382 ], [ %441, %413 ], [ %11, %411 ]
%446 = phi i32 [ %322, %319 ], [ 0, %317 ], [ %336, %327 ], [ %10, %325 ], [ %355, %341 ], [ %10, %339 ], [ %379, %360 ], [ %10, %358 ], [ %408, %384 ], [ %10, %382 ], [ %442, %413 ], [ %10, %411 ]
%447 = add nsw i32 %7, %444
%448 = getelementptr inbounds i8, i8* %312, i64 1
br label %131
449: ; preds = %6
%450 = and i32 %14, 128
%451 = icmp eq i32 %450, 0
br i1 %451, label %452, label %462
452: ; preds = %449
%453 = icmp eq i32 %10, 0
br i1 %453, label %457, label %454
454: ; preds = %452
%455 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %13, i8* %11
%456 = add i32 %10, -1
br label %457
457: ; preds = %452, %454
%458 = phi i8* [ %455, %454 ], [ %11, %452 ]
%459 = phi i32 [ %456, %454 ], [ 0, %452 ]
%460 = getelementptr inbounds i8, i8* %9, i64 1
%461 = add nsw i32 %7, 1
br label %131
462: ; preds = %449
%463 = icmp ne i32 %12, 0
%464 = and i32 %14, 224
%465 = icmp eq i32 %464, 192
%466 = select i1 %463, i1 %465, i1 false
br i1 %466, label %467, label %485
467: ; preds = %462
%468 = getelementptr inbounds i8, i8* %9, i64 1
%469 = load i8, i8* %468
%470 = and i8 %469, -64
%471 = icmp eq i8 %470, -128
br i1 %471, label %472, label %485
472: ; preds = %467
%473 = icmp ugt i32 %10, 1
br i1 %473, label %474, label %479
474: ; preds = %472
%475 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %13, i8* %11
%476 = load i8, i8* %468
%477 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %476, i8* %475
%478 = add i32 %10, -2
br label %479
479: ; preds = %472, %474
%480 = phi i8* [ %477, %474 ], [ %11, %472 ]
%481 = phi i32 [ %478, %474 ], [ %10, %472 ]
%482 = getelementptr inbounds i8, i8* %9, i64 2
%483 = add nsw i32 %7, 2
%484 = add i32 %8, -2
br label %131
485: ; preds = %467, %462
%486 = icmp ugt i32 %12, 1
br i1 %486, label %487, label %647
487: ; preds = %485
%488 = and i8 %13, -16
%489 = icmp eq i8 %488, -32
br i1 %489, label %490, label %515
490: ; preds = %487
%491 = getelementptr inbounds i8, i8* %9, i64 1
%492 = load i8, i8* %491
%493 = and i8 %492, -64
%494 = icmp eq i8 %493, -128
br i1 %494, label %495, label %515
495: ; preds = %490
%496 = getelementptr inbounds i8, i8* %9, i64 2
%497 = load i8, i8* %496
%498 = and i8 %497, -64
%499 = icmp eq i8 %498, -128
br i1 %499, label %500, label %515
500: ; preds = %495
%501 = icmp ugt i32 %10, 2
br i1 %501, label %502, label %509
502: ; preds = %500
%503 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %13, i8* %11
%504 = load i8, i8* %491
%505 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %504, i8* %503
%506 = load i8, i8* %496
%507 = getelementptr inbounds i8, i8* %11, i64 3
store i8 %506, i8* %505
%508 = add i32 %10, -3
br label %509
509: ; preds = %500, %502
%510 = phi i8* [ %507, %502 ], [ %11, %500 ]
%511 = phi i32 [ %508, %502 ], [ %10, %500 ]
%512 = getelementptr inbounds i8, i8* %9, i64 3
%513 = add nsw i32 %7, 3
%514 = add i32 %8, -3
br label %131
515: ; preds = %495, %490, %487
%516 = icmp ugt i32 %12, 2
br i1 %516, label %517, label %647
517: ; preds = %515
%518 = and i8 %13, -8
%519 = icmp eq i8 %518, -16
br i1 %519, label %520, label %552
520: ; preds = %517
%521 = getelementptr inbounds i8, i8* %9, i64 1
%522 = load i8, i8* %521
%523 = and i8 %522, -64
%524 = icmp eq i8 %523, -128
br i1 %524, label %525, label %552
525: ; preds = %520
%526 = getelementptr inbounds i8, i8* %9, i64 2
%527 = load i8, i8* %526
%528 = and i8 %527, -64
%529 = icmp eq i8 %528, -128
br i1 %529, label %530, label %552
530: ; preds = %525
%531 = getelementptr inbounds i8, i8* %9, i64 3
%532 = load i8, i8* %531
%533 = and i8 %532, -64
%534 = icmp eq i8 %533, -128
br i1 %534, label %535, label %552
535: ; preds = %530
%536 = icmp ugt i32 %10, 3
br i1 %536, label %537, label %546
537: ; preds = %535
%538 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %13, i8* %11
%539 = load i8, i8* %521
%540 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %539, i8* %538
%541 = load i8, i8* %526
%542 = getelementptr inbounds i8, i8* %11, i64 3
store i8 %541, i8* %540
%543 = load i8, i8* %531
%544 = getelementptr inbounds i8, i8* %11, i64 4
store i8 %543, i8* %542
%545 = add i32 %10, -4
br label %546
546: ; preds = %535, %537
%547 = phi i8* [ %544, %537 ], [ %11, %535 ]
%548 = phi i32 [ %545, %537 ], [ %10, %535 ]
%549 = getelementptr inbounds i8, i8* %9, i64 4
%550 = add nsw i32 %7, 4
%551 = add i32 %8, -4
br label %131
552: ; preds = %530, %525, %520, %517
%553 = icmp ugt i32 %12, 3
br i1 %553, label %554, label %647
554: ; preds = %552
%555 = and i8 %13, -4
%556 = icmp eq i8 %555, -8
br i1 %556, label %557, label %596
557: ; preds = %554
%558 = getelementptr inbounds i8, i8* %9, i64 1
%559 = load i8, i8* %558
%560 = and i8 %559, -64
%561 = icmp eq i8 %560, -128
br i1 %561, label %562, label %596
562: ; preds = %557
%563 = getelementptr inbounds i8, i8* %9, i64 2
%564 = load i8, i8* %563
%565 = and i8 %564, -64
%566 = icmp eq i8 %565, -128
br i1 %566, label %567, label %596
567: ; preds = %562
%568 = getelementptr inbounds i8, i8* %9, i64 3
%569 = load i8, i8* %568
%570 = and i8 %569, -64
%571 = icmp eq i8 %570, -128
br i1 %571, label %572, label %596
572: ; preds = %567
%573 = getelementptr inbounds i8, i8* %9, i64 4
%574 = load i8, i8* %573
%575 = and i8 %574, -64
%576 = icmp eq i8 %575, -128
br i1 %576, label %577, label %596
577: ; preds = %572
%578 = icmp ugt i32 %10, 4
br i1 %578, label %579, label %590
579: ; preds = %577
%580 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %13, i8* %11
%581 = load i8, i8* %558
%582 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %581, i8* %580
%583 = load i8, i8* %563
%584 = getelementptr inbounds i8, i8* %11, i64 3
store i8 %583, i8* %582
%585 = load i8, i8* %568
%586 = getelementptr inbounds i8, i8* %11, i64 4
store i8 %585, i8* %584
%587 = load i8, i8* %573
%588 = getelementptr inbounds i8, i8* %11, i64 5
store i8 %587, i8* %586
%589 = add i32 %10, -5
br label %590
590: ; preds = %577, %579
%591 = phi i8* [ %588, %579 ], [ %11, %577 ]
%592 = phi i32 [ %589, %579 ], [ %10, %577 ]
%593 = getelementptr inbounds i8, i8* %9, i64 5
%594 = add nsw i32 %7, 5
%595 = add i32 %8, -5
br label %131
596: ; preds = %572, %567, %562, %557, %554
%597 = icmp ugt i32 %12, 4
%598 = and i8 %13, -2
%599 = icmp eq i8 %598, -4
%600 = select i1 %597, i1 %599, i1 false
br i1 %600, label %601, label %647
601: ; preds = %596
%602 = getelementptr inbounds i8, i8* %9, i64 1
%603 = load i8, i8* %602
%604 = and i8 %603, -64
%605 = icmp eq i8 %604, -128
br i1 %605, label %606, label %647
606: ; preds = %601
%607 = getelementptr inbounds i8, i8* %9, i64 2
%608 = load i8, i8* %607
%609 = and i8 %608, -64
%610 = icmp eq i8 %609, -128
br i1 %610, label %611, label %647
611: ; preds = %606
%612 = getelementptr inbounds i8, i8* %9, i64 3
%613 = load i8, i8* %612
%614 = and i8 %613, -64
%615 = icmp eq i8 %614, -128
br i1 %615, label %616, label %647
616: ; preds = %611
%617 = getelementptr inbounds i8, i8* %9, i64 4
%618 = load i8, i8* %617
%619 = and i8 %618, -64
%620 = icmp eq i8 %619, -128
br i1 %620, label %621, label %647
621: ; preds = %616
%622 = getelementptr inbounds i8, i8* %9, i64 5
%623 = load i8, i8* %622
%624 = and i8 %623, -64
%625 = icmp eq i8 %624, -128
br i1 %625, label %626, label %647
626: ; preds = %621
%627 = icmp ugt i32 %10, 5
br i1 %627, label %628, label %641
628: ; preds = %626
%629 = getelementptr inbounds i8, i8* %11, i64 1
store i8 %13, i8* %11
%630 = load i8, i8* %602
%631 = getelementptr inbounds i8, i8* %11, i64 2
store i8 %630, i8* %629
%632 = load i8, i8* %607
%633 = getelementptr inbounds i8, i8* %11, i64 3
store i8 %632, i8* %631
%634 = load i8, i8* %612
%635 = getelementptr inbounds i8, i8* %11, i64 4
store i8 %634, i8* %633
%636 = load i8, i8* %617
%637 = getelementptr inbounds i8, i8* %11, i64 5
store i8 %636, i8* %635
%638 = load i8, i8* %622
%639 = getelementptr inbounds i8, i8* %11, i64 6
store i8 %638, i8* %637
%640 = add i32 %10, -6
br label %641
641: ; preds = %626, %628
%642 = phi i8* [ %639, %628 ], [ %11, %626 ]
%643 = phi i32 [ %640, %628 ], [ %10, %626 ]
%644 = getelementptr inbounds i8, i8* %9, i64 6
%645 = add nsw i32 %7, 6
%646 = add i32 %8, -6
br label %131
647: ; preds = %131, %596, %601, %606, %611, %616, %621, %99, %251, %409, %273, %248, %215, %221, %227, %234, %231, %213, %192, %199, %196, %190, %169, %176, %173, %167, %105, %140, %146, %153, %150, %138, %110, %117, %114, %108, %102, %96, %552, %515, %485, %254, %276, %281, %302, %295, %265, %260, %4
%648 = phi i32 [ 0, %4 ], [ -1, %260 ], [ -1, %265 ], [ -1, %295 ], [ -1, %302 ], [ -1, %281 ], [ -1, %254 ], [ %136, %131 ], [ -1, %596 ], [ -1, %601 ], [ -1, %606 ], [ -1, %611 ], [ -1, %616 ], [ -1, %621 ], [ -1, %99 ], [ -1, %251 ], [ -1, %276 ], [ -1, %409 ], [ -1, %273 ], [ -1, %248 ], [ -1, %215 ], [ -1, %221 ], [ -1, %227 ], [ -1, %234 ], [ -1, %231 ], [ -1, %213 ], [ -1, %192 ], [ -1, %199 ], [ -1, %196 ], [ -1, %190 ], [ -1, %169 ], [ -1, %176 ], [ -1, %173 ], [ -1, %167 ], [ -1, %105 ], [ -1, %140 ], [ -1, %146 ], [ -1, %153 ], [ -1, %150 ], [ -1, %138 ], [ -1, %110 ], [ -1, %117 ], [ -1, %114 ], [ -1, %108 ], [ -1, %102 ], [ -1, %96 ], [ -1, %552 ], [ -1, %515 ], [ -1, %485 ]
ret i32 %648
}