void util_format_unsigned_encode_rgtc_ubyte(unsigned char *blkaddr,
                                            unsigned char srccolors[4][4],
                                            int numxpixels, int numypixels) {
  unsigned char alphabase[2], alphause[2];
  short alphatest[2] = {0};
  unsigned int alphablockerror1, alphablockerror2, alphablockerror3;
  unsigned char i, j, aindex, acutValues[7];
  unsigned char alphaenc1[16], alphaenc2[16], alphaenc3[16];
  int alphaabsmin = 0, alphaabsmax = 0;
  short alphadist;
  alphabase[0] = 0xff;
  alphabase[1] = 0;
  for (j = 0; j < numypixels; j++) {
    for (i = 0; i < numxpixels; i++) {
      if (srccolors[j][i] == 0)
        alphaabsmin = 1;
      else if (srccolors[j][i] == 0xff)
        alphaabsmax = 1;
      else {
        if (srccolors[j][i] > alphabase[1])
          alphabase[1] = srccolors[j][i];
        if (srccolors[j][i] < alphabase[0])
          alphabase[0] = srccolors[j][i];
      }
    }
  }
  if (((alphabase[0] > alphabase[1]) && !(alphaabsmin && alphaabsmax)) ||
      (alphabase[0] == alphabase[1] && !alphaabsmin && !alphaabsmax)) {
    *blkaddr++ = srccolors[0][0];
    blkaddr++;
    *blkaddr++ = 0;
    *blkaddr++ = 0;
    *blkaddr++ = 0;
    *blkaddr++ = 0;
    *blkaddr++ = 0;
    *blkaddr++ = 0;
    return;
  }
  alphablockerror1 = 0x0;
  alphablockerror2 = 0xffffffff;
  alphablockerror3 = 0xffffffff;
  if (alphaabsmin)
    alphause[0] = 0;
  else
    alphause[0] = alphabase[0];
  if (alphaabsmax)
    alphause[1] = 0xff;
  else
    alphause[1] = alphabase[1];
  for (aindex = 0; aindex < 7; aindex++) {
    acutValues[aindex] = (alphause[0] * (2 * aindex + 1) +
                          alphause[1] * (14 - (2 * aindex + 1))) /
                         14;
  }
  for (j = 0; j < numypixels; j++) {
    for (i = 0; i < numxpixels; i++) {
      if (srccolors[j][i] > acutValues[0]) {
        alphaenc1[4 * j + i] = 0;
        alphadist = srccolors[j][i] - alphause[1];
      } else if (srccolors[j][i] > acutValues[1]) {
        alphaenc1[4 * j + i] = 2;
        alphadist = srccolors[j][i] - (alphause[1] * 6 + alphause[0] * 1) / 7;
      } else if (srccolors[j][i] > acutValues[2]) {
        alphaenc1[4 * j + i] = 3;
        alphadist = srccolors[j][i] - (alphause[1] * 5 + alphause[0] * 2) / 7;
      } else if (srccolors[j][i] > acutValues[3]) {
        alphaenc1[4 * j + i] = 4;
        alphadist = srccolors[j][i] - (alphause[1] * 4 + alphause[0] * 3) / 7;
      } else if (srccolors[j][i] > acutValues[4]) {
        alphaenc1[4 * j + i] = 5;
        alphadist = srccolors[j][i] - (alphause[1] * 3 + alphause[0] * 4) / 7;
      } else if (srccolors[j][i] > acutValues[5]) {
        alphaenc1[4 * j + i] = 6;
        alphadist = srccolors[j][i] - (alphause[1] * 2 + alphause[0] * 5) / 7;
      } else if (srccolors[j][i] > acutValues[6]) {
        alphaenc1[4 * j + i] = 7;
        alphadist = srccolors[j][i] - (alphause[1] * 1 + alphause[0] * 6) / 7;
      } else {
        alphaenc1[4 * j + i] = 1;
        alphadist = srccolors[j][i] - alphause[0];
      }
      alphablockerror1 += alphadist * alphadist;
    }
  }
  if (alphablockerror1 >= 32) {
    alphablockerror2 = 0;
    for (aindex = 0; aindex < 5; aindex++) {
      acutValues[aindex] = (alphabase[0] * (10 - (2 * aindex + 1)) +
                            alphabase[1] * (2 * aindex + 1)) /
                           10;
    }
    for (j = 0; j < numypixels; j++) {
      for (i = 0; i < numxpixels; i++) {
        if (srccolors[j][i] == 0) {
          alphaenc2[4 * j + i] = 6;
          alphadist = 0;
        } else if (srccolors[j][i] == 0xff) {
          alphaenc2[4 * j + i] = 7;
          alphadist = 0;
        } else if (srccolors[j][i] <= acutValues[0]) {
          alphaenc2[4 * j + i] = 0;
          alphadist = srccolors[j][i] - alphabase[0];
        } else if (srccolors[j][i] <= acutValues[1]) {
          alphaenc2[4 * j + i] = 2;
          alphadist =
              srccolors[j][i] - (alphabase[0] * 4 + alphabase[1] * 1) / 5;
        } else if (srccolors[j][i] <= acutValues[2]) {
          alphaenc2[4 * j + i] = 3;
          alphadist =
              srccolors[j][i] - (alphabase[0] * 3 + alphabase[1] * 2) / 5;
        } else if (srccolors[j][i] <= acutValues[3]) {
          alphaenc2[4 * j + i] = 4;
          alphadist =
              srccolors[j][i] - (alphabase[0] * 2 + alphabase[1] * 3) / 5;
        } else if (srccolors[j][i] <= acutValues[4]) {
          alphaenc2[4 * j + i] = 5;
          alphadist =
              srccolors[j][i] - (alphabase[0] * 1 + alphabase[1] * 4) / 5;
        } else {
          alphaenc2[4 * j + i] = 1;
          alphadist = srccolors[j][i] - alphabase[1];
        }
        alphablockerror2 += alphadist * alphadist;
      }
    }
    if ((alphablockerror2 > 96) && (alphablockerror1 > 96)) {
      short blockerrlin1 = 0;
      short blockerrlin2 = 0;
      unsigned char nralphainrangelow = 0;
      unsigned char nralphainrangehigh = 0;
      alphatest[0] = 0xff;
      alphatest[1] = 0;
      for (j = 0; j < numypixels; j++) {
        for (i = 0; i < numxpixels; i++) {
          if ((srccolors[j][i] > alphatest[1]) &&
              (srccolors[j][i] < (0xff - (alphabase[1] - alphabase[0]) / 28)))
            alphatest[1] = srccolors[j][i];
          if ((srccolors[j][i] < alphatest[0]) &&
              (srccolors[j][i] > (alphabase[1] - alphabase[0]) / 28))
            alphatest[0] = srccolors[j][i];
        }
      }
      if (alphatest[1] <= alphatest[0]) {
        alphatest[0] = 0 + 1;
        alphatest[1] = 0xff - 1;
      }
      for (aindex = 0; aindex < 5; aindex++) {
        acutValues[aindex] = (alphatest[0] * (10 - (2 * aindex + 1)) +
                              alphatest[1] * (2 * aindex + 1)) /
                             10;
      }
      for (j = 0; j < numypixels; j++) {
        for (i = 0; i < numxpixels; i++) {
          if (srccolors[j][i] <= alphatest[0] / 2) {
          } else if (srccolors[j][i] > ((0xff + alphatest[1]) / 2)) {
          } else if (srccolors[j][i] <= acutValues[0]) {
            blockerrlin1 += (srccolors[j][i] - alphatest[0]);
            nralphainrangelow += 1;
          } else if (srccolors[j][i] <= acutValues[1]) {
            blockerrlin1 +=
                (srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5);
            blockerrlin2 +=
                (srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5);
            nralphainrangelow += 1;
            nralphainrangehigh += 1;
          } else if (srccolors[j][i] <= acutValues[2]) {
            blockerrlin1 +=
                (srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5);
            blockerrlin2 +=
                (srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5);
            nralphainrangelow += 1;
            nralphainrangehigh += 1;
          } else if (srccolors[j][i] <= acutValues[3]) {
            blockerrlin1 +=
                (srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5);
            blockerrlin2 +=
                (srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5);
            nralphainrangelow += 1;
            nralphainrangehigh += 1;
          } else if (srccolors[j][i] <= acutValues[4]) {
            blockerrlin1 +=
                (srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5);
            blockerrlin2 +=
                (srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5);
            nralphainrangelow += 1;
            nralphainrangehigh += 1;
          } else {
            blockerrlin2 += (srccolors[j][i] - alphatest[1]);
            nralphainrangehigh += 1;
          }
        }
      }
      if (nralphainrangelow == 0)
        nralphainrangelow = 1;
      if (nralphainrangehigh == 0)
        nralphainrangehigh = 1;
      alphatest[0] = alphatest[0] + (blockerrlin1 / nralphainrangelow);
      if (alphatest[0] < 0) {
        alphatest[0] = 0;
      }
      alphatest[1] = alphatest[1] + (blockerrlin2 / nralphainrangehigh);
      if (alphatest[1] > 0xff) {
        alphatest[1] = 0xff;
      }
      alphablockerror3 = 0;
      for (aindex = 0; aindex < 5; aindex++) {
        acutValues[aindex] = (alphatest[0] * (10 - (2 * aindex + 1)) +
                              alphatest[1] * (2 * aindex + 1)) /
                             10;
      }
      for (j = 0; j < numypixels; j++) {
        for (i = 0; i < numxpixels; i++) {
          if (srccolors[j][i] <= alphatest[0] / 2) {
            alphaenc3[4 * j + i] = 6;
            alphadist = srccolors[j][i];
          } else if (srccolors[j][i] > ((0xff + alphatest[1]) / 2)) {
            alphaenc3[4 * j + i] = 7;
            alphadist = 0xff - srccolors[j][i];
          } else if (srccolors[j][i] <= acutValues[0]) {
            alphaenc3[4 * j + i] = 0;
            alphadist = srccolors[j][i] - alphatest[0];
          } else if (srccolors[j][i] <= acutValues[1]) {
            alphaenc3[4 * j + i] = 2;
            alphadist =
                srccolors[j][i] - (alphatest[0] * 4 + alphatest[1] * 1) / 5;
          } else if (srccolors[j][i] <= acutValues[2]) {
            alphaenc3[4 * j + i] = 3;
            alphadist =
                srccolors[j][i] - (alphatest[0] * 3 + alphatest[1] * 2) / 5;
          } else if (srccolors[j][i] <= acutValues[3]) {
            alphaenc3[4 * j + i] = 4;
            alphadist =
                srccolors[j][i] - (alphatest[0] * 2 + alphatest[1] * 3) / 5;
          } else if (srccolors[j][i] <= acutValues[4]) {
            alphaenc3[4 * j + i] = 5;
            alphadist =
                srccolors[j][i] - (alphatest[0] * 1 + alphatest[1] * 4) / 5;
          } else {
            alphaenc3[4 * j + i] = 1;
            alphadist = srccolors[j][i] - alphatest[1];
          }
          alphablockerror3 += alphadist * alphadist;
        }
      }
    }
  }
  if ((alphablockerror1 <= alphablockerror2) &&
      (alphablockerror1 <= alphablockerror3)) {
    util_format_unsigned_write_rgtc_encoded_channel(blkaddr, alphause[1],
                                                    alphause[0], alphaenc1);
  } else if (alphablockerror2 <= alphablockerror3) {
    util_format_unsigned_write_rgtc_encoded_channel(blkaddr, alphabase[0],
                                                    alphabase[1], alphaenc2);
  } else {
    util_format_unsigned_write_rgtc_encoded_channel(
        blkaddr, (unsigned char)alphatest[0], (unsigned char)alphatest[1],
        alphaenc3);
  }
}


x86 assembly (clang, -O0):
<util_format_unsigned_encode_rgtc_ubyte>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
lea    -0x20(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
movb   $0xff,-0x1a(%rbp)
movb   $0x0,-0x19(%rbp)
movb   $0x0,-0x2e(%rbp)
movzbl -0x2e(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1281 <util_format_unsigned_encode_rgtc_ubyte+0x161>
movb   $0x0,-0x2d(%rbp)
movzbl -0x2d(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    126f <util_format_unsigned_encode_rgtc_ubyte+0x14f>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    11ad <util_format_unsigned_encode_rgtc_ubyte+0x8d>
movl   $0x1,-0x74(%rbp)
jmp    125d <util_format_unsigned_encode_rgtc_ubyte+0x13d>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0xff,%eax
jne    11db <util_format_unsigned_encode_rgtc_ubyte+0xbb>
movl   $0x1,-0x78(%rbp)
jmp    1258 <util_format_unsigned_encode_rgtc_ubyte+0x138>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jle    1217 <util_format_unsigned_encode_rgtc_ubyte+0xf7>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x1a(%rbp),%ecx
cmp    %ecx,%eax
jge    1253 <util_format_unsigned_encode_rgtc_ubyte+0x133>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1a(%rbp)
jmp    1258 <util_format_unsigned_encode_rgtc_ubyte+0x138>
jmp    125d <util_format_unsigned_encode_rgtc_ubyte+0x13d>
jmp    1262 <util_format_unsigned_encode_rgtc_ubyte+0x142>
mov    -0x2d(%rbp),%al
add    $0x1,%al
mov    %al,-0x2d(%rbp)
jmp    1174 <util_format_unsigned_encode_rgtc_ubyte+0x54>
jmp    1274 <util_format_unsigned_encode_rgtc_ubyte+0x154>
mov    -0x2e(%rbp),%al
add    $0x1,%al
mov    %al,-0x2e(%rbp)
jmp    1163 <util_format_unsigned_encode_rgtc_ubyte+0x43>
movzbl -0x1a(%rbp),%eax
movzbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jle    12a5 <util_format_unsigned_encode_rgtc_ubyte+0x185>
cmpl   $0x0,-0x74(%rbp)
je     12c9 <util_format_unsigned_encode_rgtc_ubyte+0x1a9>
cmpl   $0x0,-0x78(%rbp)
je     12c9 <util_format_unsigned_encode_rgtc_ubyte+0x1a9>
movzbl -0x1a(%rbp),%eax
movzbl -0x19(%rbp),%ecx
cmp    %ecx,%eax
jne    135d <util_format_unsigned_encode_rgtc_ubyte+0x23d>
cmpl   $0x0,-0x74(%rbp)
jne    135d <util_format_unsigned_encode_rgtc_ubyte+0x23d>
cmpl   $0x0,-0x78(%rbp)
jne    135d <util_format_unsigned_encode_rgtc_ubyte+0x23d>
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x0,(%rax)
jmp    276c <util_format_unsigned_encode_rgtc_ubyte+0x164c>
movl   $0x0,-0x24(%rbp)
movl   $0xffffffff,-0x28(%rbp)
movl   $0xffffffff,-0x2c(%rbp)
cmpl   $0x0,-0x74(%rbp)
je     1385 <util_format_unsigned_encode_rgtc_ubyte+0x265>
movb   $0x0,-0x1c(%rbp)
jmp    138b <util_format_unsigned_encode_rgtc_ubyte+0x26b>
mov    -0x1a(%rbp),%al
mov    %al,-0x1c(%rbp)
cmpl   $0x0,-0x78(%rbp)
je     139e <util_format_unsigned_encode_rgtc_ubyte+0x27e>
movb   $0xff,-0x1b(%rbp)
jmp    13a4 <util_format_unsigned_encode_rgtc_ubyte+0x284>
mov    -0x19(%rbp),%al
mov    %al,-0x1b(%rbp)
movb   $0x0,-0x2f(%rbp)
movzbl -0x2f(%rbp),%eax
cmp    $0x7,%eax
jge    13ff <util_format_unsigned_encode_rgtc_ubyte+0x2df>
movzbl -0x1c(%rbp),%eax
movzbl -0x2f(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
movzbl -0x1b(%rbp),%ecx
movzbl -0x2f(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
mov    $0xe,%edx
sub    %esi,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xe,%ecx
cltd
idiv   %ecx
mov    %al,%cl
movzbl -0x2f(%rbp),%eax
mov    %cl,-0x36(%rbp,%rax,1)
mov    -0x2f(%rbp),%al
add    $0x1,%al
mov    %al,-0x2f(%rbp)
jmp    13a8 <util_format_unsigned_encode_rgtc_ubyte+0x288>
movb   $0x0,-0x2e(%rbp)
movzbl -0x2e(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    17fb <util_format_unsigned_encode_rgtc_ubyte+0x6db>
movb   $0x0,-0x2d(%rbp)
movzbl -0x2d(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17e9 <util_format_unsigned_encode_rgtc_ubyte+0x6c9>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x36(%rbp),%ecx
cmp    %ecx,%eax
jle    147e <util_format_unsigned_encode_rgtc_ubyte+0x35e>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x0,-0x50(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x1b(%rbp),%ecx
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    17cb <util_format_unsigned_encode_rgtc_ubyte+0x6ab>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x35(%rbp),%ecx
cmp    %ecx,%eax
jle    14fd <util_format_unsigned_encode_rgtc_ubyte+0x3dd>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x2,-0x50(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x84(%rbp)
movzbl -0x1b(%rbp),%eax
imul   $0x6,%eax,%eax
movzbl -0x1c(%rbp),%ecx
shl    $0x0,%ecx
add    %ecx,%eax
mov    $0x7,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    17c6 <util_format_unsigned_encode_rgtc_ubyte+0x6a6>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x34(%rbp),%ecx
cmp    %ecx,%eax
jle    157c <util_format_unsigned_encode_rgtc_ubyte+0x45c>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x3,-0x50(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x88(%rbp)
movzbl -0x1b(%rbp),%eax
imul   $0x5,%eax,%eax
movzbl -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x7,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x88(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    17c1 <util_format_unsigned_encode_rgtc_ubyte+0x6a1>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x33(%rbp),%ecx
cmp    %ecx,%eax
jle    15fb <util_format_unsigned_encode_rgtc_ubyte+0x4db>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x4,-0x50(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x8c(%rbp)
movzbl -0x1b(%rbp),%eax
shl    $0x2,%eax
movzbl -0x1c(%rbp),%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
mov    $0x7,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8c(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    17bc <util_format_unsigned_encode_rgtc_ubyte+0x69c>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x32(%rbp),%ecx
cmp    %ecx,%eax
jle    167a <util_format_unsigned_encode_rgtc_ubyte+0x55a>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x5,-0x50(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x90(%rbp)
movzbl -0x1b(%rbp),%eax
imul   $0x3,%eax,%eax
movzbl -0x1c(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    $0x7,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x90(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    17b7 <util_format_unsigned_encode_rgtc_ubyte+0x697>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x31(%rbp),%ecx
cmp    %ecx,%eax
jle    16f9 <util_format_unsigned_encode_rgtc_ubyte+0x5d9>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x6,-0x50(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x94(%rbp)
movzbl -0x1b(%rbp),%eax
shl    $0x1,%eax
movzbl -0x1c(%rbp),%ecx
imul   $0x5,%ecx,%ecx
add    %ecx,%eax
mov    $0x7,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    17b2 <util_format_unsigned_encode_rgtc_ubyte+0x692>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x30(%rbp),%ecx
cmp    %ecx,%eax
jle    1778 <util_format_unsigned_encode_rgtc_ubyte+0x658>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x7,-0x50(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x98(%rbp)
movzbl -0x1b(%rbp),%eax
shl    $0x0,%eax
movzbl -0x1c(%rbp),%ecx
imul   $0x6,%ecx,%ecx
add    %ecx,%eax
mov    $0x7,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x98(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    17ad <util_format_unsigned_encode_rgtc_ubyte+0x68d>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x1,-0x50(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x1c(%rbp),%ecx
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    17b2 <util_format_unsigned_encode_rgtc_ubyte+0x692>
jmp    17b7 <util_format_unsigned_encode_rgtc_ubyte+0x697>
jmp    17bc <util_format_unsigned_encode_rgtc_ubyte+0x69c>
jmp    17c1 <util_format_unsigned_encode_rgtc_ubyte+0x6a1>
jmp    17c6 <util_format_unsigned_encode_rgtc_ubyte+0x6a6>
jmp    17cb <util_format_unsigned_encode_rgtc_ubyte+0x6ab>
movswl -0x7a(%rbp),%eax
movswl -0x7a(%rbp),%ecx
imul   %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2d(%rbp),%al
add    $0x1,%al
mov    %al,-0x2d(%rbp)
jmp    1414 <util_format_unsigned_encode_rgtc_ubyte+0x2f4>
jmp    17ee <util_format_unsigned_encode_rgtc_ubyte+0x6ce>
mov    -0x2e(%rbp),%al
add    $0x1,%al
mov    %al,-0x2e(%rbp)
jmp    1403 <util_format_unsigned_encode_rgtc_ubyte+0x2e3>
cmpl   $0x20,-0x24(%rbp)
jb     26ee <util_format_unsigned_encode_rgtc_ubyte+0x15ce>
movl   $0x0,-0x28(%rbp)
movb   $0x0,-0x2f(%rbp)
movzbl -0x2f(%rbp),%eax
cmp    $0x5,%eax
jge    1867 <util_format_unsigned_encode_rgtc_ubyte+0x747>
movzbl -0x1a(%rbp),%eax
movzbl -0x2f(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
mov    $0xa,%ecx
sub    %edx,%ecx
imul   %ecx,%eax
movzbl -0x19(%rbp),%ecx
movzbl -0x2f(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,%cl
movzbl -0x2f(%rbp),%eax
mov    %cl,-0x36(%rbp,%rax,1)
mov    -0x2f(%rbp),%al
add    $0x1,%al
mov    %al,-0x2f(%rbp)
jmp    1810 <util_format_unsigned_encode_rgtc_ubyte+0x6f0>
movb   $0x0,-0x2e(%rbp)
movzbl -0x2e(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1be5 <util_format_unsigned_encode_rgtc_ubyte+0xac5>
movb   $0x0,-0x2d(%rbp)
movzbl -0x2d(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1bd3 <util_format_unsigned_encode_rgtc_ubyte+0xab3>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    18c8 <util_format_unsigned_encode_rgtc_ubyte+0x7a8>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x6,-0x60(%rbp,%rax,1)
movw   $0x0,-0x7a(%rbp)
jmp    1bb5 <util_format_unsigned_encode_rgtc_ubyte+0xa95>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
cmp    $0xff,%eax
jne    1909 <util_format_unsigned_encode_rgtc_ubyte+0x7e9>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x7,-0x60(%rbp,%rax,1)
movw   $0x0,-0x7a(%rbp)
jmp    1bb0 <util_format_unsigned_encode_rgtc_ubyte+0xa90>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x36(%rbp),%ecx
cmp    %ecx,%eax
jg     1966 <util_format_unsigned_encode_rgtc_ubyte+0x846>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x0,-0x60(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x1a(%rbp),%ecx
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    1bab <util_format_unsigned_encode_rgtc_ubyte+0xa8b>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x35(%rbp),%ecx
cmp    %ecx,%eax
jg     19e5 <util_format_unsigned_encode_rgtc_ubyte+0x8c5>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x2,-0x60(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x9c(%rbp)
movzbl -0x1a(%rbp),%eax
shl    $0x2,%eax
movzbl -0x19(%rbp),%ecx
shl    $0x0,%ecx
add    %ecx,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x9c(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    1ba6 <util_format_unsigned_encode_rgtc_ubyte+0xa86>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x34(%rbp),%ecx
cmp    %ecx,%eax
jg     1a64 <util_format_unsigned_encode_rgtc_ubyte+0x944>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x3,-0x60(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa0(%rbp)
movzbl -0x1a(%rbp),%eax
imul   $0x3,%eax,%eax
movzbl -0x19(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa0(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    1ba1 <util_format_unsigned_encode_rgtc_ubyte+0xa81>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x33(%rbp),%ecx
cmp    %ecx,%eax
jg     1ae3 <util_format_unsigned_encode_rgtc_ubyte+0x9c3>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x4,-0x60(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa4(%rbp)
movzbl -0x1a(%rbp),%eax
shl    $0x1,%eax
movzbl -0x19(%rbp),%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    1b9c <util_format_unsigned_encode_rgtc_ubyte+0xa7c>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x32(%rbp),%ecx
cmp    %ecx,%eax
jg     1b62 <util_format_unsigned_encode_rgtc_ubyte+0xa42>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x5,-0x60(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa8(%rbp)
movzbl -0x1a(%rbp),%eax
shl    $0x0,%eax
movzbl -0x19(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa8(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    1b97 <util_format_unsigned_encode_rgtc_ubyte+0xa77>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x1,-0x60(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x19(%rbp),%ecx
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    1b9c <util_format_unsigned_encode_rgtc_ubyte+0xa7c>
jmp    1ba1 <util_format_unsigned_encode_rgtc_ubyte+0xa81>
jmp    1ba6 <util_format_unsigned_encode_rgtc_ubyte+0xa86>
jmp    1bab <util_format_unsigned_encode_rgtc_ubyte+0xa8b>
jmp    1bb0 <util_format_unsigned_encode_rgtc_ubyte+0xa90>
jmp    1bb5 <util_format_unsigned_encode_rgtc_ubyte+0xa95>
movswl -0x7a(%rbp),%eax
movswl -0x7a(%rbp),%ecx
imul   %ecx,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2d(%rbp),%al
add    $0x1,%al
mov    %al,-0x2d(%rbp)
jmp    187c <util_format_unsigned_encode_rgtc_ubyte+0x75c>
jmp    1bd8 <util_format_unsigned_encode_rgtc_ubyte+0xab8>
mov    -0x2e(%rbp),%al
add    $0x1,%al
mov    %al,-0x2e(%rbp)
jmp    186b <util_format_unsigned_encode_rgtc_ubyte+0x74b>
cmpl   $0x60,-0x28(%rbp)
jbe    26e9 <util_format_unsigned_encode_rgtc_ubyte+0x15c9>
cmpl   $0x60,-0x24(%rbp)
jbe    26e9 <util_format_unsigned_encode_rgtc_ubyte+0x15c9>
movw   $0x0,-0x7c(%rbp)
movw   $0x0,-0x7e(%rbp)
movb   $0x0,-0x7f(%rbp)
movb   $0x0,-0x80(%rbp)
movw   $0xff,-0x20(%rbp)
movw   $0x0,-0x1e(%rbp)
movb   $0x0,-0x2e(%rbp)
movzbl -0x2e(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1d60 <util_format_unsigned_encode_rgtc_ubyte+0xc40>
movb   $0x0,-0x2d(%rbp)
movzbl -0x2d(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d4e <util_format_unsigned_encode_rgtc_ubyte+0xc2e>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movswl -0x1e(%rbp),%ecx
cmp    %ecx,%eax
jle    1cbf <util_format_unsigned_encode_rgtc_ubyte+0xb9f>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xac(%rbp)
movzbl -0x19(%rbp),%eax
movzbl -0x1a(%rbp),%ecx
sub    %ecx,%eax
mov    $0x1c,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0xac(%rbp),%eax
mov    $0xff,%ecx
sub    %edx,%ecx
cmp    %ecx,%eax
jge    1cbf <util_format_unsigned_encode_rgtc_ubyte+0xb9f>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %ax,-0x1e(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movswl -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1d3c <util_format_unsigned_encode_rgtc_ubyte+0xc1c>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xb0(%rbp)
movzbl -0x19(%rbp),%eax
movzbl -0x1a(%rbp),%ecx
sub    %ecx,%eax
mov    $0x1c,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xb0(%rbp),%eax
cmp    %ecx,%eax
jle    1d3c <util_format_unsigned_encode_rgtc_ubyte+0xc1c>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %ax,-0x20(%rbp)
jmp    1d41 <util_format_unsigned_encode_rgtc_ubyte+0xc21>
mov    -0x2d(%rbp),%al
add    $0x1,%al
mov    %al,-0x2d(%rbp)
jmp    1c2e <util_format_unsigned_encode_rgtc_ubyte+0xb0e>
jmp    1d53 <util_format_unsigned_encode_rgtc_ubyte+0xc33>
mov    -0x2e(%rbp),%al
add    $0x1,%al
mov    %al,-0x2e(%rbp)
jmp    1c1d <util_format_unsigned_encode_rgtc_ubyte+0xafd>
movswl -0x1e(%rbp),%eax
movswl -0x20(%rbp),%ecx
cmp    %ecx,%eax
jg     1d7c <util_format_unsigned_encode_rgtc_ubyte+0xc5c>
movw   $0x1,-0x20(%rbp)
movw   $0xfe,-0x1e(%rbp)
movb   $0x0,-0x2f(%rbp)
movzbl -0x2f(%rbp),%eax
cmp    $0x5,%eax
jge    1dd7 <util_format_unsigned_encode_rgtc_ubyte+0xcb7>
movswl -0x20(%rbp),%eax
movzbl -0x2f(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
mov    $0xa,%ecx
sub    %edx,%ecx
imul   %ecx,%eax
movswl -0x1e(%rbp),%ecx
movzbl -0x2f(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,%cl
movzbl -0x2f(%rbp),%eax
mov    %cl,-0x36(%rbp,%rax,1)
mov    -0x2f(%rbp),%al
add    $0x1,%al
mov    %al,-0x2f(%rbp)
jmp    1d80 <util_format_unsigned_encode_rgtc_ubyte+0xc60>
movb   $0x0,-0x2e(%rbp)
movzbl -0x2e(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    220e <util_format_unsigned_encode_rgtc_ubyte+0x10ee>
movb   $0x0,-0x2d(%rbp)
movzbl -0x2d(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    21fc <util_format_unsigned_encode_rgtc_ubyte+0x10dc>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xb4(%rbp)
movswl -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xb4(%rbp),%eax
cmp    %ecx,%eax
jg     1e37 <util_format_unsigned_encode_rgtc_ubyte+0xd17>
jmp    21ea <util_format_unsigned_encode_rgtc_ubyte+0x10ca>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xb8(%rbp)
movswl -0x1e(%rbp),%eax
add    $0xff,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
cmp    %ecx,%eax
jle    1e7a <util_format_unsigned_encode_rgtc_ubyte+0xd5a>
jmp    21e5 <util_format_unsigned_encode_rgtc_ubyte+0x10c5>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x36(%rbp),%ecx
cmp    %ecx,%eax
jg     1ed3 <util_format_unsigned_encode_rgtc_ubyte+0xdb3>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
sub    %eax,%ecx
movswl -0x7c(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7c(%rbp)
movzbl -0x7f(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x7f(%rbp)
jmp    21e0 <util_format_unsigned_encode_rgtc_ubyte+0x10c0>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x35(%rbp),%ecx
cmp    %ecx,%eax
jg     1f85 <util_format_unsigned_encode_rgtc_ubyte+0xe65>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
shl    $0x2,%eax
movswl -0x1e(%rbp),%edx
shl    $0x0,%edx
add    %edx,%eax
mov    $0x5,%esi
cltd
idiv   %esi
sub    %eax,%ecx
movswl -0x7c(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
shl    $0x2,%eax
movswl -0x1e(%rbp),%edx
shl    $0x0,%edx
add    %edx,%eax
mov    $0x5,%esi
cltd
idiv   %esi
sub    %eax,%ecx
movswl -0x7e(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7e(%rbp)
movzbl -0x7f(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x7f(%rbp)
movzbl -0x80(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x80(%rbp)
jmp    21db <util_format_unsigned_encode_rgtc_ubyte+0x10bb>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x34(%rbp),%ecx
cmp    %ecx,%eax
jg     2037 <util_format_unsigned_encode_rgtc_ubyte+0xf17>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
imul   $0x3,%eax,%eax
movswl -0x1e(%rbp),%edx
shl    $0x1,%edx
add    %edx,%eax
mov    $0x5,%esi
cltd
idiv   %esi
sub    %eax,%ecx
movswl -0x7c(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
imul   $0x3,%eax,%eax
movswl -0x1e(%rbp),%edx
shl    $0x1,%edx
add    %edx,%eax
mov    $0x5,%esi
cltd
idiv   %esi
sub    %eax,%ecx
movswl -0x7e(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7e(%rbp)
movzbl -0x7f(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x7f(%rbp)
movzbl -0x80(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x80(%rbp)
jmp    21d6 <util_format_unsigned_encode_rgtc_ubyte+0x10b6>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x33(%rbp),%ecx
cmp    %ecx,%eax
jg     20e9 <util_format_unsigned_encode_rgtc_ubyte+0xfc9>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
shl    $0x1,%eax
movswl -0x1e(%rbp),%edx
imul   $0x3,%edx,%edx
add    %edx,%eax
mov    $0x5,%esi
cltd
idiv   %esi
sub    %eax,%ecx
movswl -0x7c(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
shl    $0x1,%eax
movswl -0x1e(%rbp),%edx
imul   $0x3,%edx,%edx
add    %edx,%eax
mov    $0x5,%esi
cltd
idiv   %esi
sub    %eax,%ecx
movswl -0x7e(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7e(%rbp)
movzbl -0x7f(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x7f(%rbp)
movzbl -0x80(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x80(%rbp)
jmp    21d1 <util_format_unsigned_encode_rgtc_ubyte+0x10b1>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x32(%rbp),%ecx
cmp    %ecx,%eax
jg     219b <util_format_unsigned_encode_rgtc_ubyte+0x107b>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
shl    $0x0,%eax
movswl -0x1e(%rbp),%edx
shl    $0x2,%edx
add    %edx,%eax
mov    $0x5,%esi
cltd
idiv   %esi
sub    %eax,%ecx
movswl -0x7c(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x20(%rbp),%eax
shl    $0x0,%eax
movswl -0x1e(%rbp),%edx
shl    $0x2,%edx
add    %edx,%eax
mov    $0x5,%esi
cltd
idiv   %esi
sub    %eax,%ecx
movswl -0x7e(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7e(%rbp)
movzbl -0x7f(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x7f(%rbp)
movzbl -0x80(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x80(%rbp)
jmp    21cc <util_format_unsigned_encode_rgtc_ubyte+0x10ac>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
movswl -0x1e(%rbp),%eax
sub    %eax,%ecx
movswl -0x7e(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x7e(%rbp)
movzbl -0x80(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x80(%rbp)
jmp    21d1 <util_format_unsigned_encode_rgtc_ubyte+0x10b1>
jmp    21d6 <util_format_unsigned_encode_rgtc_ubyte+0x10b6>
jmp    21db <util_format_unsigned_encode_rgtc_ubyte+0x10bb>
jmp    21e0 <util_format_unsigned_encode_rgtc_ubyte+0x10c0>
jmp    21e5 <util_format_unsigned_encode_rgtc_ubyte+0x10c5>
jmp    21ea <util_format_unsigned_encode_rgtc_ubyte+0x10ca>
jmp    21ef <util_format_unsigned_encode_rgtc_ubyte+0x10cf>
mov    -0x2d(%rbp),%al
add    $0x1,%al
mov    %al,-0x2d(%rbp)
jmp    1dec <util_format_unsigned_encode_rgtc_ubyte+0xccc>
jmp    2201 <util_format_unsigned_encode_rgtc_ubyte+0x10e1>
mov    -0x2e(%rbp),%al
add    $0x1,%al
mov    %al,-0x2e(%rbp)
jmp    1ddb <util_format_unsigned_encode_rgtc_ubyte+0xcbb>
movzbl -0x7f(%rbp),%eax
cmp    $0x0,%eax
jne    221f <util_format_unsigned_encode_rgtc_ubyte+0x10ff>
movb   $0x1,-0x7f(%rbp)
movzbl -0x80(%rbp),%eax
cmp    $0x0,%eax
jne    2230 <util_format_unsigned_encode_rgtc_ubyte+0x1110>
movb   $0x1,-0x80(%rbp)
movswl -0x20(%rbp),%eax
mov    %eax,-0xbc(%rbp)
movswl -0x7c(%rbp),%eax
movzbl -0x7f(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xbc(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x20(%rbp)
movswl -0x20(%rbp),%eax
cmp    $0x0,%eax
jge    2266 <util_format_unsigned_encode_rgtc_ubyte+0x1146>
movw   $0x0,-0x20(%rbp)
movswl -0x1e(%rbp),%eax
mov    %eax,-0xc0(%rbp)
movswl -0x7e(%rbp),%eax
movzbl -0x80(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xc0(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x1e(%rbp)
movswl -0x1e(%rbp),%eax
cmp    $0xff,%eax
jle    229e <util_format_unsigned_encode_rgtc_ubyte+0x117e>
movw   $0xff,-0x1e(%rbp)
movl   $0x0,-0x2c(%rbp)
movb   $0x0,-0x2f(%rbp)
movzbl -0x2f(%rbp),%eax
cmp    $0x5,%eax
jge    2300 <util_format_unsigned_encode_rgtc_ubyte+0x11e0>
movswl -0x20(%rbp),%eax
movzbl -0x2f(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
mov    $0xa,%ecx
sub    %edx,%ecx
imul   %ecx,%eax
movswl -0x1e(%rbp),%ecx
movzbl -0x2f(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,%cl
movzbl -0x2f(%rbp),%eax
mov    %cl,-0x36(%rbp,%rax,1)
mov    -0x2f(%rbp),%al
add    $0x1,%al
mov    %al,-0x2f(%rbp)
jmp    22a9 <util_format_unsigned_encode_rgtc_ubyte+0x1189>
movb   $0x0,-0x2e(%rbp)
movzbl -0x2e(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    26e4 <util_format_unsigned_encode_rgtc_ubyte+0x15c4>
movb   $0x0,-0x2d(%rbp)
movzbl -0x2d(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    26d2 <util_format_unsigned_encode_rgtc_ubyte+0x15b2>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xc4(%rbp)
movswl -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xc4(%rbp),%eax
cmp    %ecx,%eax
jg     238f <util_format_unsigned_encode_rgtc_ubyte+0x126f>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x6,-0x70(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %ax,-0x7a(%rbp)
jmp    26b4 <util_format_unsigned_encode_rgtc_ubyte+0x1594>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xc8(%rbp)
movswl -0x1e(%rbp),%eax
add    $0xff,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xc8(%rbp),%eax
cmp    %ecx,%eax
jle    2408 <util_format_unsigned_encode_rgtc_ubyte+0x12e8>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x7,-0x70(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%ecx
mov    $0xff,%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    26af <util_format_unsigned_encode_rgtc_ubyte+0x158f>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x36(%rbp),%ecx
cmp    %ecx,%eax
jg     2465 <util_format_unsigned_encode_rgtc_ubyte+0x1345>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x0,-0x70(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movswl -0x20(%rbp),%ecx
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    26aa <util_format_unsigned_encode_rgtc_ubyte+0x158a>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x35(%rbp),%ecx
cmp    %ecx,%eax
jg     24e4 <util_format_unsigned_encode_rgtc_ubyte+0x13c4>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x2,-0x70(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xcc(%rbp)
movswl -0x20(%rbp),%eax
shl    $0x2,%eax
movswl -0x1e(%rbp),%ecx
shl    $0x0,%ecx
add    %ecx,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xcc(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    26a5 <util_format_unsigned_encode_rgtc_ubyte+0x1585>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x34(%rbp),%ecx
cmp    %ecx,%eax
jg     2563 <util_format_unsigned_encode_rgtc_ubyte+0x1443>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x3,-0x70(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xd0(%rbp)
movswl -0x20(%rbp),%eax
imul   $0x3,%eax,%eax
movswl -0x1e(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd0(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    26a0 <util_format_unsigned_encode_rgtc_ubyte+0x1580>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x33(%rbp),%ecx
cmp    %ecx,%eax
jg     25e2 <util_format_unsigned_encode_rgtc_ubyte+0x14c2>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x4,-0x70(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xd4(%rbp)
movswl -0x20(%rbp),%eax
shl    $0x1,%eax
movswl -0x1e(%rbp),%ecx
imul   $0x3,%ecx,%ecx
add    %ecx,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd4(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    269b <util_format_unsigned_encode_rgtc_ubyte+0x157b>
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x32(%rbp),%ecx
cmp    %ecx,%eax
jg     2661 <util_format_unsigned_encode_rgtc_ubyte+0x1541>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x5,-0x70(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xd8(%rbp)
movswl -0x20(%rbp),%eax
shl    $0x0,%eax
movswl -0x1e(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd8(%rbp),%eax
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    2696 <util_format_unsigned_encode_rgtc_ubyte+0x1576>
movzbl -0x2e(%rbp),%eax
shl    $0x2,%eax
movzbl -0x2d(%rbp),%ecx
add    %ecx,%eax
cltq
movb   $0x1,-0x70(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movzbl -0x2e(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
movzbl -0x2d(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movswl -0x1e(%rbp),%ecx
sub    %ecx,%eax
mov    %ax,-0x7a(%rbp)
jmp    269b <util_format_unsigned_encode_rgtc_ubyte+0x157b>
jmp    26a0 <util_format_unsigned_encode_rgtc_ubyte+0x1580>
jmp    26a5 <util_format_unsigned_encode_rgtc_ubyte+0x1585>
jmp    26aa <util_format_unsigned_encode_rgtc_ubyte+0x158a>
jmp    26af <util_format_unsigned_encode_rgtc_ubyte+0x158f>
jmp    26b4 <util_format_unsigned_encode_rgtc_ubyte+0x1594>
movswl -0x7a(%rbp),%eax
movswl -0x7a(%rbp),%ecx
imul   %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2d(%rbp),%al
add    $0x1,%al
mov    %al,-0x2d(%rbp)
jmp    2315 <util_format_unsigned_encode_rgtc_ubyte+0x11f5>
jmp    26d7 <util_format_unsigned_encode_rgtc_ubyte+0x15b7>
mov    -0x2e(%rbp),%al
add    $0x1,%al
mov    %al,-0x2e(%rbp)
jmp    2304 <util_format_unsigned_encode_rgtc_ubyte+0x11e4>
jmp    26e9 <util_format_unsigned_encode_rgtc_ubyte+0x15c9>
jmp    26ee <util_format_unsigned_encode_rgtc_ubyte+0x15ce>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
ja     2722 <util_format_unsigned_encode_rgtc_ubyte+0x1602>
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
ja     2722 <util_format_unsigned_encode_rgtc_ubyte+0x1602>
mov    -0x8(%rbp),%rdi
movzbl -0x1b(%rbp),%esi
movzbl -0x1c(%rbp),%edx
lea    -0x50(%rbp),%rcx
mov    $0x0,%al
call   1040 <util_format_unsigned_write_rgtc_encoded_channel@plt>
jmp    276c <util_format_unsigned_encode_rgtc_ubyte+0x164c>
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
ja     274a <util_format_unsigned_encode_rgtc_ubyte+0x162a>
mov    -0x8(%rbp),%rdi
movzbl -0x1a(%rbp),%esi
movzbl -0x19(%rbp),%edx
lea    -0x60(%rbp),%rcx
mov    $0x0,%al
call   1040 <util_format_unsigned_write_rgtc_encoded_channel@plt>
jmp    2767 <util_format_unsigned_encode_rgtc_ubyte+0x1647>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%ax
movzbl %al,%esi
mov    -0x1e(%rbp),%ax
movzbl %al,%edx
lea    -0x70(%rbp),%rcx
mov    $0x0,%al
call   1040 <util_format_unsigned_write_rgtc_encoded_channel@plt>
jmp    276c <util_format_unsigned_encode_rgtc_ubyte+0x164c>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<util_format_unsigned_encode_rgtc_ubyte>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
test   %ecx,%ecx
jle    11cf <util_format_unsigned_encode_rgtc_ubyte+0xbf>
mov    %edx,%r8d
mov    $0xff,%bl
xor    %r9d,%r9d
xor    %r10d,%r10d
xor    %r11d,%r11d
xor    %r14d,%r14d
jmp    114c <util_format_unsigned_encode_rgtc_ubyte+0x3c>
nopl   0x0(%rax)
add    $0x1,%r11b
movzbl %r11b,%eax
cmp    %ecx,%eax
jge    11a8 <util_format_unsigned_encode_rgtc_ubyte+0x98>
test   %r8d,%r8d
jle    1140 <util_format_unsigned_encode_rgtc_ubyte+0x30>
movzbl %r11b,%r15d
xor    %edx,%edx
jmp    1181 <util_format_unsigned_encode_rgtc_ubyte+0x71>
nopl   0x0(%rax)
cmp    %r14b,%al
movzbl %r14b,%r14d
movzbl %al,%ebp
cmova  %ebp,%r14d
cmp    %bl,%al
movzbl %bl,%ebx
cmovb  %ebp,%ebx
add    $0x1,%dl
movzbl %dl,%eax
cmp    %r8d,%eax
jge    1140 <util_format_unsigned_encode_rgtc_ubyte+0x30>
movzbl %dl,%eax
lea    (%rsi,%r15,4),%rbp
movzbl (%rax,%rbp,1),%eax
test   %al,%al
je     11a0 <util_format_unsigned_encode_rgtc_ubyte+0x90>
cmp    $0xff,%al
jne    1160 <util_format_unsigned_encode_rgtc_ubyte+0x50>
mov    $0x1,%r9d
jmp    1176 <util_format_unsigned_encode_rgtc_ubyte+0x66>
nopl   0x0(%rax)
mov    $0x1,%r10d
jmp    1176 <util_format_unsigned_encode_rgtc_ubyte+0x66>
movzbl %bl,%eax
mov    %rax,0x60(%rsp)
cmp    %al,%r14b
jae    11c3 <util_format_unsigned_encode_rgtc_ubyte+0xb3>
test   %r10d,%r10d
je     11cf <util_format_unsigned_encode_rgtc_ubyte+0xbf>
test   %r9d,%r9d
je     11cf <util_format_unsigned_encode_rgtc_ubyte+0xbf>
xor    %edx,%edx
jmp    11f7 <util_format_unsigned_encode_rgtc_ubyte+0xe7>
jne    11e5 <util_format_unsigned_encode_rgtc_ubyte+0xd5>
test   %r10d,%r10d
jne    11e5 <util_format_unsigned_encode_rgtc_ubyte+0xd5>
test   %r9d,%r9d
jne    11e5 <util_format_unsigned_encode_rgtc_ubyte+0xd5>
mov    (%rsi),%al
mov    %al,(%rdi)
movl   $0x0,0x2(%rdi)
movw   $0x0,0x6(%rdi)
jmp    1ca6 <util_format_unsigned_encode_rgtc_ubyte+0xb96>
xor    %edx,%edx
test   %r10d,%r10d
cmove  0x60(%rsp),%edx
mov    %r14d,%eax
test   %r9d,%r9d
je     11f9 <util_format_unsigned_encode_rgtc_ubyte+0xe9>
mov    $0xff,%al
movzbl %dl,%edx
mov    %rdx,0x80(%rsp)
movzbl %al,%ebx
test   %ecx,%ecx
jle    1c8d <util_format_unsigned_encode_rgtc_ubyte+0xb7d>
mov    %ecx,0xc(%rsp)
mov    %rdi,0x38(%rsp)
movzbl %r14b,%eax
mov    %rax,0x70(%rsp)
lea    (%rbx,%rbx,2),%r9d
lea    (%rbx,%r9,4),%eax
mov    0x80(%rsp),%r14
add    %r14d,%eax
movzwl %ax,%eax
shr    %eax
imul   $0x4925,%eax,%eax
shr    $0x11,%eax
mov    %rbx,(%rsp)
mov    (%rsp),%rcx
lea    (%rcx,%rcx,4),%ebx
mov    (%rsp),%rcx
lea    (%rcx,%rbx,2),%edx
lea    (%r14,%r14,2),%r11d
add    %r11d,%edx
movzwl %dx,%edx
shr    %edx
imul   $0x4925,%edx,%r10d
shr    $0x11,%r10d
mov    (%rsp),%rcx
lea    (%rcx,%rcx,8),%ebp
lea    (%r14,%r14,4),%ecx
add    %ecx,%ebp
movzwl %bp,%ebp
shr    %ebp
imul   $0x4925,%ebp,%edx
shr    $0x11,%edx
mov    %edx,0x28(%rsp)
mov    (%rsp),%rdx
add    %r14d,%edx
shr    %edx
mov    %edx,0x10(%rsp)
lea    (%r14,%r14,8),%edi
add    %ebx,%edi
movzwl %di,%edi
shr    %edi
imul   $0x4925,%edi,%edx
shr    $0x11,%edx
mov    %edx,0x18(%rsp)
lea    (%r14,%rcx,2),%ecx
add    %r9d,%ecx
movzwl %cx,%ecx
shr    %ecx
imul   $0x4925,%ecx,%ecx
shr    $0x11,%ecx
mov    %ecx,0x58(%rsp)
lea    (%r14,%r11,4),%ecx
add    (%rsp),%ecx
movzwl %cx,%ecx
shr    %ecx
imul   $0x4925,%ecx,%ecx
shr    $0x11,%ecx
mov    %ecx,0x48(%rsp)
lea    (%r14,%r14,2),%r9d
mov    (%rsp),%rcx
lea    (%rcx,%r9,2),%edi
movzwl %di,%ebx
imul   $0x2493,%ebx,%ebx
shr    $0x10,%ebx
sub    %ebx,%edi
movzwl %di,%ecx
shr    %ecx
add    %ebx,%ecx
shr    $0x2,%ecx
mov    %ecx,0x30(%rsp)
lea    (%r14,%r14,4),%edi
mov    (%rsp),%rcx
lea    (%rdi,%rcx,2),%edi
movzwl %di,%ebx
imul   $0x2493,%ebx,%ebx
shr    $0x10,%ebx
sub    %ebx,%edi
movzwl %di,%ecx
shr    %ecx
add    %ebx,%ecx
shr    $0x2,%ecx
mov    %ecx,0x40(%rsp)
mov    (%rsp),%rcx
lea    (%rcx,%rcx,2),%edi
lea    (%rdi,%r14,4),%ebx
movzwl %bx,%ecx
imul   $0x2493,%ecx,%ecx
shr    $0x10,%ecx
sub    %ecx,%ebx
movzwl %bx,%edx
shr    %edx
add    %ecx,%edx
shr    $0x2,%edx
mov    %edx,0x50(%rsp)
mov    (%rsp),%rcx
lea    (%r9,%rcx,4),%ecx
movzwl %cx,%ebx
imul   $0x2493,%ebx,%ebx
shr    $0x10,%ebx
sub    %ebx,%ecx
movzwl %cx,%ecx
shr    %ecx
add    %ebx,%ecx
shr    $0x2,%ecx
mov    %ecx,0x68(%rsp)
mov    (%rsp),%rcx
lea    (%rcx,%rcx,4),%ecx
lea    (%rcx,%r14,2),%ecx
movzwl %cx,%ebx
imul   $0x2493,%ebx,%ebx
shr    $0x10,%ebx
sub    %ebx,%ecx
movzwl %cx,%ecx
shr    %ecx
add    %ebx,%ecx
mov    (%rsp),%rbx
shr    $0x2,%ecx
mov    %ecx,0x20(%rsp)
lea    (%r14,%rdi,2),%ecx
movzwl %cx,%edi
imul   $0x2493,%edi,%edi
shr    $0x10,%edi
sub    %edi,%ecx
movzwl %cx,%r9d
shr    %r9d
add    %edi,%r9d
shr    $0x2,%r9d
xor    %r13d,%r13d
xor    %edi,%edi
xor    %r15d,%r15d
jmp    13e8 <util_format_unsigned_encode_rgtc_ubyte+0x2d8>
lea    0x1(%rdi),%ecx
movzbl %cl,%ecx
add    $0x1,%rdi
add    $0x4,%r13
cmp    0xc(%rsp),%ecx
jge    14dd <util_format_unsigned_encode_rgtc_ubyte+0x3cd>
test   %r8d,%r8d
jle    13d0 <util_format_unsigned_encode_rgtc_ubyte+0x2c0>
mov    %r13d,%ecx
and    $0xfffffffc,%ecx
add    %rsp,%rcx
add    $0xb0,%rcx
xor    %r14d,%r14d
jmp    142f <util_format_unsigned_encode_rgtc_ubyte+0x31f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movb   $0x0,(%rcx,%r14,1)
mov    %ebx,%r12d
sub    %r12d,%r11d
imul   %r11d,%r11d
add    %r11d,%r15d
add    $0x1,%r14
movzbl %r14b,%edx
cmp    %r8d,%edx
jge    13d0 <util_format_unsigned_encode_rgtc_ubyte+0x2c0>
movzbl %r14b,%ebp
lea    (%rsi,%rdi,4),%rdx
movzbl 0x0(%rbp,%rdx,1),%r11d
cmp    %al,%r11b
ja     1410 <util_format_unsigned_encode_rgtc_ubyte+0x300>
cmp    %r10b,%r11b
jbe    1460 <util_format_unsigned_encode_rgtc_ubyte+0x350>
movb   $0x2,(%rcx,%r14,1)
mov    %r9d,%r12d
jmp    1418 <util_format_unsigned_encode_rgtc_ubyte+0x308>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    0x28(%rsp),%r11b
jbe    1473 <util_format_unsigned_encode_rgtc_ubyte+0x363>
movb   $0x3,(%rcx,%r14,1)
mov    0x20(%rsp),%r12d
jmp    1418 <util_format_unsigned_encode_rgtc_ubyte+0x308>
cmp    0x10(%rsp),%r11b
jbe    1486 <util_format_unsigned_encode_rgtc_ubyte+0x376>
movb   $0x4,(%rcx,%r14,1)
mov    0x68(%rsp),%r12d
jmp    1418 <util_format_unsigned_encode_rgtc_ubyte+0x308>
cmp    0x18(%rsp),%r11b
jbe    149c <util_format_unsigned_encode_rgtc_ubyte+0x38c>
movb   $0x5,(%rcx,%r14,1)
mov    0x50(%rsp),%r12d
jmp    1418 <util_format_unsigned_encode_rgtc_ubyte+0x308>
cmp    0x58(%rsp),%r11b
jbe    14b2 <util_format_unsigned_encode_rgtc_ubyte+0x3a2>
movb   $0x6,(%rcx,%r14,1)
mov    0x40(%rsp),%r12d
jmp    1418 <util_format_unsigned_encode_rgtc_ubyte+0x308>
cmp    0x48(%rsp),%r11b
jbe    14c8 <util_format_unsigned_encode_rgtc_ubyte+0x3b8>
movb   $0x7,(%rcx,%r14,1)
mov    0x30(%rsp),%r12d
jmp    1418 <util_format_unsigned_encode_rgtc_ubyte+0x308>
movb   $0x1,(%rcx,%r14,1)
mov    0x80(%rsp),%rdx
mov    %edx,%r12d
jmp    1418 <util_format_unsigned_encode_rgtc_ubyte+0x308>
cmp    $0x20,%r15d
mov    0x38(%rsp),%rdi
mov    0xc(%rsp),%eax
jb     1c8d <util_format_unsigned_encode_rgtc_ubyte+0xb7d>
test   %eax,%eax
jle    1cce <util_format_unsigned_encode_rgtc_ubyte+0xbbe>
mov    0x60(%rsp),%rdi
lea    (%rdi,%rdi,8),%eax
mov    0x70(%rsp),%rbp
add    %ebp,%eax
mov    $0xcccccccd,%r10d
imul   %r10,%rax
shr    $0x23,%rax
lea    0x0(,%rdi,8),%edx
sub    %edi,%edx
lea    0x0(%rbp,%rbp,2),%r9d
add    %r9d,%edx
imul   %r10,%rdx
shr    $0x23,%rdx
lea    (%rdi,%rbp,1),%r14d
shr    %r14d
lea    (%rdi,%rdi,2),%ecx
lea    0x0(,%rbp,8),%ebx
sub    %ebp,%ebx
add    %ecx,%ebx
imul   %r10,%rbx
shr    $0x23,%rbx
mov    %rbx,0x28(%rsp)
lea    0x0(%rbp,%rbp,8),%ebx
add    %edi,%ebx
imul   %r10,%rbx
shr    $0x23,%rbx
mov    %rbx,0x10(%rsp)
lea    0x0(%rbp,%rdi,4),%r11d
imul   %r10,%r11
shr    $0x22,%r11
lea    (%rcx,%rbp,2),%ebx
imul   %r10,%rbx
shr    $0x22,%rbx
lea    (%r9,%rdi,2),%ecx
imul   %r10,%rcx
shr    $0x22,%rcx
mov    %rcx,0x20(%rsp)
lea    (%rdi,%rbp,4),%ecx
imul   %r10,%rcx
shr    $0x22,%rcx
mov    %rcx,0x18(%rsp)
xor    %r13d,%r13d
xor    %r9d,%r9d
jmp    15c5 <util_format_unsigned_encode_rgtc_ubyte+0x4b5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r13),%ecx
movzbl %cl,%ecx
add    $0x1,%r13
cmp    0xc(%rsp),%ecx
jge    16ad <util_format_unsigned_encode_rgtc_ubyte+0x59d>
test   %r8d,%r8d
jle    15b0 <util_format_unsigned_encode_rgtc_ubyte+0x4a0>
mov    %r13d,%ecx
and    $0x3fffffff,%ecx
lea    (%rsp,%rcx,4),%rcx
add    $0xa0,%rcx
xor    %r10d,%r10d
jmp    160f <util_format_unsigned_encode_rgtc_ubyte+0x4ff>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movb   $0x7,(%rcx,%r10,1)
xor    %r12d,%r12d
movswl %r12w,%edi
imul   %edi,%edi
add    %edi,%r9d
add    $0x1,%r10
movzbl %r10b,%edi
cmp    %r8d,%edi
jge    15b0 <util_format_unsigned_encode_rgtc_ubyte+0x4a0>
movzbl %r10b,%ebp
lea    (%rsi,%r13,4),%rdi
movzbl 0x0(%rbp,%rdi,1),%r12d
cmp    $0xff,%r12d
je     15f0 <util_format_unsigned_encode_rgtc_ubyte+0x4e0>
test   %r12b,%r12b
jne    1640 <util_format_unsigned_encode_rgtc_ubyte+0x530>
movb   $0x6,(%rcx,%r10,1)
jmp    15f5 <util_format_unsigned_encode_rgtc_ubyte+0x4e5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %al,%r12b
jbe    1669 <util_format_unsigned_encode_rgtc_ubyte+0x559>
cmp    %dl,%r12b
jbe    1675 <util_format_unsigned_encode_rgtc_ubyte+0x565>
cmp    %r14b,%r12b
jbe    1682 <util_format_unsigned_encode_rgtc_ubyte+0x572>
cmp    0x28(%rsp),%r12b
jbe    168f <util_format_unsigned_encode_rgtc_ubyte+0x57f>
cmp    0x10(%rsp),%r12b
jbe    169e <util_format_unsigned_encode_rgtc_ubyte+0x58e>
movb   $0x1,(%rcx,%r10,1)
sub    0x70(%rsp),%r12d
jmp    15f8 <util_format_unsigned_encode_rgtc_ubyte+0x4e8>
movb   $0x0,(%rcx,%r10,1)
sub    0x60(%rsp),%r12d
jmp    15f8 <util_format_unsigned_encode_rgtc_ubyte+0x4e8>
movb   $0x2,(%rcx,%r10,1)
sub    %r11d,%r12d
jmp    15f8 <util_format_unsigned_encode_rgtc_ubyte+0x4e8>
movb   $0x3,(%rcx,%r10,1)
sub    %ebx,%r12d
jmp    15f8 <util_format_unsigned_encode_rgtc_ubyte+0x4e8>
movb   $0x4,(%rcx,%r10,1)
sub    0x20(%rsp),%r12d
jmp    15f8 <util_format_unsigned_encode_rgtc_ubyte+0x4e8>
movb   $0x5,(%rcx,%r10,1)
sub    0x18(%rsp),%r12d
jmp    15f8 <util_format_unsigned_encode_rgtc_ubyte+0x4e8>
xor    %ebp,%ebp
mov    $0xffffffff,%r14d
cmp    $0x61,%r9d
jb     17ac <util_format_unsigned_encode_rgtc_ubyte+0x69c>
mov    $0x0,%ecx
cmp    $0x61,%r15d
mov    0x38(%rsp),%rdi
mov    (%rsp),%rbx
jb     1c83 <util_format_unsigned_encode_rgtc_ubyte+0xb73>
mov    0xc(%rsp),%r13d
test   %r13d,%r13d
jle    17bc <util_format_unsigned_encode_rgtc_ubyte+0x6ac>
mov    0x70(%rsp),%rax
sub    0x60(%rsp),%eax
cltq
imul   $0x6db6db6d,%rax,%rcx
shr    $0x20,%rcx
sub    %eax,%ecx
mov    %ecx,%edx
sar    $0x4,%edx
shr    $0x1f,%ecx
lea    (%rdx,%rcx,1),%r10d
add    $0xff,%r10d
imul   $0xffffffff92492493,%rax,%r11
shr    $0x20,%r11
add    %eax,%r11d
mov    %r11d,%eax
shr    $0x1f,%eax
sar    $0x4,%r11d
add    %eax,%r11d
mov    $0xff,%ax
xor    %r12d,%r12d
xor    %ecx,%ecx
jmp    1759 <util_format_unsigned_encode_rgtc_ubyte+0x649>
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%edx
mov    %ecx,%edi
add    $0x1,%r12b
movzbl %r12b,%ebx
mov    %edi,%ecx
mov    %edx,%eax
cmp    %r13d,%ebx
mov    (%rsp),%rbx
jge    17c2 <util_format_unsigned_encode_rgtc_ubyte+0x6b2>
test   %r8d,%r8d
jle    1740 <util_format_unsigned_encode_rgtc_ubyte+0x630>
movzbl %r12b,%r14d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl %bpl,%ebp
lea    (%rsi,%r14,4),%rdx
movzbl 0x0(%rbp,%rdx,1),%ebx
cmp    %ebx,%r10d
mov    %ecx,%edi
cmovg  %ebx,%edi
cmp    %bx,%cx
cmovae %ecx,%edi
cmp    %ebx,%r11d
mov    %ebx,%edx
cmovge %eax,%edx
cmp    %bx,%ax
cmovbe %eax,%edx
add    $0x1,%bpl
movzbl %bpl,%ebx
mov    %edi,%ecx
mov    %edx,%eax
cmp    %r8d,%ebx
jl     1770 <util_format_unsigned_encode_rgtc_ubyte+0x660>
jmp    1744 <util_format_unsigned_encode_rgtc_ubyte+0x634>
xor    %ecx,%ecx
mov    0x38(%rsp),%rdi
mov    (%rsp),%rbx
jmp    1c83 <util_format_unsigned_encode_rgtc_ubyte+0xb73>
mov    $0xff,%dx
xor    %edi,%edi
cmp    %dx,%di
mov    $0x1,%eax
cmova  %edx,%eax
mov    $0xfe,%ecx
cmova  %edi,%ecx
movzwl %ax,%r14d
movzwl %cx,%r10d
test   %r13d,%r13d
jle    1997 <util_format_unsigned_encode_rgtc_ubyte+0x887>
lea    (%r14,%r14,8),%ecx
add    %r10d,%ecx
mov    $0xcccccccd,%eax
imul   %rax,%rcx
shr    $0x23,%rcx
mov    %rcx,0x28(%rsp)
lea    0x0(,%r14,8),%edx
sub    %r14d,%edx
lea    (%r10,%r10,2),%ecx
add    %ecx,%edx
imul   %rax,%rdx
shr    $0x23,%rdx
mov    %rdx,0x20(%rsp)
lea    (%r14,%r10,1),%edx
shr    %edx
mov    %edx,0x18(%rsp)
lea    (%r14,%r14,2),%edx
lea    0x0(,%r10,8),%edi
sub    %r10d,%edi
add    %edx,%edi
imul   %rax,%rdi
shr    $0x23,%rdi
mov    %rdi,0x58(%rsp)
lea    (%r10,%r10,8),%edi
add    %r14d,%edi
imul   %rax,%rdi
shr    $0x23,%rdi
mov    %rdi,0x48(%rsp)
mov    %r10,%rdi
mov    %r14d,%r10d
shr    %r10d
lea    0xff(%rdi),%r11d
shr    %r11d
lea    (%rdi,%r14,4),%ebx
imul   %rax,%rbx
shr    $0x22,%rbx
mov    %rbx,0x68(%rsp)
lea    (%rdx,%rdi,2),%edx
imul   %rax,%rdx
shr    $0x22,%rdx
mov    %rdx,0x50(%rsp)
lea    (%rcx,%r14,2),%ecx
imul   %rax,%rcx
shr    $0x22,%rcx
mov    %rcx,0x40(%rsp)
mov    %rdi,0x30(%rsp)
mov    %r14,0x10(%rsp)
lea    (%r14,%rdi,4),%ecx
imul   %rax,%rcx
shr    $0x22,%rcx
mov    %rcx,0x78(%rsp)
xor    %r13d,%r13d
xor    %ebp,%ebp
xor    %r12d,%r12d
xor    %eax,%eax
xor    %r14d,%r14d
jmp    18e2 <util_format_unsigned_encode_rgtc_ubyte+0x7d2>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14b
movzbl %r14b,%ecx
cmp    0xc(%rsp),%ecx
jge    1982 <util_format_unsigned_encode_rgtc_ubyte+0x872>
test   %r8d,%r8d
jle    18d0 <util_format_unsigned_encode_rgtc_ubyte+0x7c0>
movzbl %r14b,%ebx
xor    %edx,%edx
jmp    1905 <util_format_unsigned_encode_rgtc_ubyte+0x7f5>
nop
sub    0x10(%rsp),%eax
add    %ecx,%eax
add    $0x1,%bpl
add    $0x1,%dl
movzbl %dl,%ecx
cmp    %r8d,%ecx
jge    18d0 <util_format_unsigned_encode_rgtc_ubyte+0x7c0>
movzbl %dl,%ecx
lea    (%rsi,%rbx,4),%rdi
movzbl (%rcx,%rdi,1),%ecx
cmp    %ecx,%r10d
jae    18fa <util_format_unsigned_encode_rgtc_ubyte+0x7ea>
cmp    %ecx,%r11d
jb     18fa <util_format_unsigned_encode_rgtc_ubyte+0x7ea>
cmp    0x28(%rsp),%cl
jbe    18f0 <util_format_unsigned_encode_rgtc_ubyte+0x7e0>
cmp    0x20(%rsp),%cl
jbe    194c <util_format_unsigned_encode_rgtc_ubyte+0x83c>
cmp    0x18(%rsp),%cl
jbe    1952 <util_format_unsigned_encode_rgtc_ubyte+0x842>
cmp    0x58(%rsp),%cl
jbe    1958 <util_format_unsigned_encode_rgtc_ubyte+0x848>
cmp    0x48(%rsp),%cl
jbe    195e <util_format_unsigned_encode_rgtc_ubyte+0x84e>
sub    0x30(%rsp),%r12d
movzwl %cx,%ecx
add    %r12d,%ecx
add    $0x1,%r13b
mov    %ecx,%r12d
jmp    18fa <util_format_unsigned_encode_rgtc_ubyte+0x7ea>
sub    0x68(%rsp),%ecx
jmp    1970 <util_format_unsigned_encode_rgtc_ubyte+0x860>
sub    0x50(%rsp),%ecx
jmp    1970 <util_format_unsigned_encode_rgtc_ubyte+0x860>
sub    0x40(%rsp),%ecx
jmp    1970 <util_format_unsigned_encode_rgtc_ubyte+0x860>
sub    0x78(%rsp),%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %ecx,%eax
add    %ecx,%r12d
add    $0x1,%bpl
add    $0x1,%r13b
jmp    18fa <util_format_unsigned_encode_rgtc_ubyte+0x7ea>
test   %bpl,%bpl
mov    (%rsp),%rbx
mov    0x30(%rsp),%r10
mov    0x10(%rsp),%r14
jne    19a2 <util_format_unsigned_encode_rgtc_ubyte+0x892>
jmp    199f <util_format_unsigned_encode_rgtc_ubyte+0x88f>
xor    %r13d,%r13d
xor    %r12d,%r12d
xor    %eax,%eax
mov    $0x1,%bpl
test   %r13b,%r13b
movzbl %r13b,%ecx
mov    $0x1,%edi
cmovne %ecx,%edi
movzbl %bpl,%ecx
cwtd
idiv   %cx
mov    %eax,%ebp
add    %r14d,%ebp
xor    %r14d,%r14d
test   %bp,%bp
cmovs  %r14d,%ebp
movzbl %dil,%ecx
mov    %r12d,%eax
cwtd
idiv   %cx
add    %r10d,%eax
movswl %ax,%ecx
cmp    $0xff,%ecx
mov    $0xff,%ecx
cmovl  %eax,%ecx
cmpl   $0x0,0xc(%rsp)
jle    1c7e <util_format_unsigned_encode_rgtc_ubyte+0xb6e>
mov    %ebp,0x78(%rsp)
movzwl %bp,%r10d
mov    %ecx,0x8c(%rsp)
movswl %cx,%edx
lea    (%r10,%r10,8),%eax
add    %edx,%eax
cltq
imul   $0x66666667,%rax,%r11
mov    %r11,%rax
shr    $0x3f,%rax
shr    $0x22,%r11
add    %eax,%r11d
lea    0x0(,%r10,8),%ecx
sub    %r10d,%ecx
lea    (%rdx,%rdx,2),%r14d
add    %r14d,%ecx
movslq %ecx,%rcx
imul   $0x66666667,%rcx,%rdi
mov    %rdi,%rcx
shr    $0x3f,%rcx
shr    $0x22,%rdi
add    %ecx,%edi
mov    %rdi,0x10(%rsp)
lea    (%r10,%rdx,1),%ecx
mov    %ecx,%edi
shr    $0x1f,%edi
add    %ecx,%edi
shr    %edi
mov    %edi,0x20(%rsp)
lea    (%r10,%r10,2),%ecx
lea    0x0(,%rdx,8),%edi
sub    %edx,%edi
add    %ecx,%edi
movslq %edi,%rdi
imul   $0x66666667,%rdi,%rbx
mov    %rbx,%rdi
shr    $0x3f,%rdi
shr    $0x22,%rbx
add    %edi,%ebx
mov    %rbx,0x68(%rsp)
lea    (%rdx,%rdx,8),%edi
add    %r10d,%edi
movslq %edi,%rdi
imul   $0x66666667,%rdi,%rbx
mov    %rbx,%rdi
shr    $0x3f,%rdi
shr    $0x22,%rbx
add    %edi,%ebx
mov    %rbx,0x50(%rsp)
mov    %r10d,%edi
shr    %edi
lea    0xff(%rdx),%ebp
movzwl %bp,%ebx
mov    %ebx,%ebp
shr    $0xf,%ebp
add    %ebx,%ebp
movswl %bp,%ebx
sar    %ebx
lea    (%rdx,%r10,4),%ebp
movslq %ebp,%rbp
imul   $0xffffffff99999999,%rbp,%rbp
mov    %rbp,%rax
shr    $0x3f,%rax
sar    $0x21,%rbp
add    %eax,%ebp
mov    %rbp,0x18(%rsp)
lea    (%rcx,%rdx,2),%ecx
movslq %ecx,%rcx
imul   $0xffffffff99999999,%rcx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x21,%rax
add    %ecx,%eax
mov    %rax,0x58(%rsp)
lea    (%r14,%r10,2),%eax
cltq
imul   $0xffffffff99999999,%rax,%rcx
mov    %rcx,%rax
shr    $0x3f,%rax
sar    $0x21,%rcx
add    %eax,%ecx
mov    %rcx,0x48(%rsp)
mov    %r10,0x28(%rsp)
mov    %rdx,0x40(%rsp)
lea    (%r10,%rdx,4),%eax
cltq
imul   $0xffffffff99999999,%rax,%rcx
mov    %rcx,%rax
shr    $0x3f,%rax
sar    $0x21,%rcx
add    %eax,%ecx
mov    %rcx,0x30(%rsp)
xor    %ebp,%ebp
xor    %r13d,%r13d
xor    %r14d,%r14d
jmp    1b79 <util_format_unsigned_encode_rgtc_ubyte+0xa69>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r13),%eax
movzbl %al,%eax
add    $0x1,%r13
add    $0x4,%rbp
cmp    0xc(%rsp),%eax
jge    1c68 <util_format_unsigned_encode_rgtc_ubyte+0xb58>
test   %r8d,%r8d
jle    1b60 <util_format_unsigned_encode_rgtc_ubyte+0xa50>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    (%rsp,%rax,1),%rcx
add    $0x90,%rcx
xor    %r12d,%r12d
jmp    1bb9 <util_format_unsigned_encode_rgtc_ubyte+0xaa9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movb   $0x6,(%rcx,%r12,1)
cwtl
imul   %eax,%eax
add    %eax,%r14d
add    $0x1,%r12
movzbl %r12b,%eax
cmp    %r8d,%eax
jge    1b60 <util_format_unsigned_encode_rgtc_ubyte+0xa50>
movzbl %r12b,%eax
lea    (%rsi,%r13,4),%rdx
movzbl (%rax,%rdx,1),%eax
cmp    %ax,%di
jae    1ba0 <util_format_unsigned_encode_rgtc_ubyte+0xa90>
movzwl %ax,%r10d
cmp    %r10d,%ebx
jge    1bf0 <util_format_unsigned_encode_rgtc_ubyte+0xae0>
movb   $0x7,(%rcx,%r12,1)
not    %r10b
movzbl %r10b,%eax
jmp    1ba5 <util_format_unsigned_encode_rgtc_ubyte+0xa95>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r11b,%al
jbe    1c1b <util_format_unsigned_encode_rgtc_ubyte+0xb0b>
cmp    0x10(%rsp),%r10b
jbe    1c27 <util_format_unsigned_encode_rgtc_ubyte+0xb17>
cmp    0x20(%rsp),%al
jbe    1c33 <util_format_unsigned_encode_rgtc_ubyte+0xb23>
cmp    0x68(%rsp),%r10b
jbe    1c3f <util_format_unsigned_encode_rgtc_ubyte+0xb2f>
cmp    0x50(%rsp),%al
jbe    1c4b <util_format_unsigned_encode_rgtc_ubyte+0xb3b>
movb   $0x1,(%rcx,%r12,1)
sub    0x40(%rsp),%r10d
jmp    1c60 <util_format_unsigned_encode_rgtc_ubyte+0xb50>
movb   $0x0,(%rcx,%r12,1)
sub    0x28(%rsp),%r10d
jmp    1c60 <util_format_unsigned_encode_rgtc_ubyte+0xb50>
movb   $0x2,(%rcx,%r12,1)
add    0x18(%rsp),%r10d
jmp    1c60 <util_format_unsigned_encode_rgtc_ubyte+0xb50>
movb   $0x3,(%rcx,%r12,1)
add    0x58(%rsp),%r10d
jmp    1c60 <util_format_unsigned_encode_rgtc_ubyte+0xb50>
movb   $0x4,(%rcx,%r12,1)
add    0x48(%rsp),%r10d
jmp    1c60 <util_format_unsigned_encode_rgtc_ubyte+0xb50>
movb   $0x5,(%rcx,%r12,1)
add    0x30(%rsp),%r10d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r10d,%eax
jmp    1ba5 <util_format_unsigned_encode_rgtc_ubyte+0xa95>
mov    0x38(%rsp),%rdi
mov    (%rsp),%rbx
mov    0x78(%rsp),%ebp
mov    0x8c(%rsp),%ecx
jmp    1c83 <util_format_unsigned_encode_rgtc_ubyte+0xb73>
mov    0x38(%rsp),%rdi
cmp    %r9d,%r15d
ja     1cb8 <util_format_unsigned_encode_rgtc_ubyte+0xba8>
cmp    %r14d,%r15d
ja     1cb8 <util_format_unsigned_encode_rgtc_ubyte+0xba8>
lea    0xb0(%rsp),%rcx
mov    %ebx,%esi
mov    0x80(%rsp),%rdx
xor    %eax,%eax
call   1030 <util_format_unsigned_write_rgtc_encoded_channel@plt>
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    %r14d,%r9d
jbe    1cce <util_format_unsigned_encode_rgtc_ubyte+0xbbe>
movzbl %bpl,%esi
movzbl %cl,%edx
lea    0x90(%rsp),%rcx
jmp    1c9f <util_format_unsigned_encode_rgtc_ubyte+0xb8f>
lea    0xa0(%rsp),%rcx
mov    0x60(%rsp),%rsi
mov    0x70(%rsp),%rdx
jmp    1c9f <util_format_unsigned_encode_rgtc_ubyte+0xb8f>

LLVM IR (-O0):
define void @util_format_unsigned_encode_rgtc_ubyte(i8* %0, [4 x i8]* %1, i32 %2, i32 %3) {
%5 = alloca i8*
%6 = alloca [4 x i8]*
%7 = alloca i32
%8 = alloca i32
%9 = alloca [2 x i8]
%10 = alloca [2 x i8]
%11 = alloca [2 x i16]
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8
%16 = alloca i8
%17 = alloca i8
%18 = alloca [7 x i8]
%19 = alloca [16 x i8]
%20 = alloca [16 x i8]
%21 = alloca [16 x i8]
%22 = alloca i32
%23 = alloca i32
%24 = alloca i16
%25 = alloca i16
%26 = alloca i16
%27 = alloca i8
%28 = alloca i8
store i8* %0, i8** %5
store [4 x i8]* %1, [4 x i8]** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%29 = bitcast [2 x i16]* %11 to i8*
store i32 0, i32* %22
store i32 0, i32* %23
%30 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
store i8 -1, i8* %30
%31 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
store i8 0, i8* %31
store i8 0, i8* %16
br label %32
32: ; preds = %122, %4
%33 = load i8, i8* %16
%34 = zext i8 %33 to i32
%35 = load i32, i32* %8
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %125
37: ; preds = %32
store i8 0, i8* %15
br label %38
38: ; preds = %118, %37
%39 = load i8, i8* %15
%40 = zext i8 %39 to i32
%41 = load i32, i32* %7
%42 = icmp slt i32 %40, %41
br i1 %42, label %43, label %121
43: ; preds = %38
%44 = load [4 x i8]*, [4 x i8]** %6
%45 = load i8, i8* %16
%46 = zext i8 %45 to i64
%47 = getelementptr inbounds [4 x i8], [4 x i8]* %44, i64 %46
%48 = load i8, i8* %15
%49 = zext i8 %48 to i64
%50 = getelementptr inbounds [4 x i8], [4 x i8]* %47, i64 0, i64 %49
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = icmp eq i32 %52, 0
br i1 %53, label %54, label %55
54: ; preds = %43
store i32 1, i32* %22
br label %117
55: ; preds = %43
%56 = load [4 x i8]*, [4 x i8]** %6
%57 = load i8, i8* %16
%58 = zext i8 %57 to i64
%59 = getelementptr inbounds [4 x i8], [4 x i8]* %56, i64 %58
%60 = load i8, i8* %15
%61 = zext i8 %60 to i64
%62 = getelementptr inbounds [4 x i8], [4 x i8]* %59, i64 0, i64 %61
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = icmp eq i32 %64, 255
br i1 %65, label %66, label %67
66: ; preds = %55
store i32 1, i32* %23
br label %116
67: ; preds = %55
%68 = load [4 x i8]*, [4 x i8]** %6
%69 = load i8, i8* %16
%70 = zext i8 %69 to i64
%71 = getelementptr inbounds [4 x i8], [4 x i8]* %68, i64 %70
%72 = load i8, i8* %15
%73 = zext i8 %72 to i64
%74 = getelementptr inbounds [4 x i8], [4 x i8]* %71, i64 0, i64 %73
%75 = load i8, i8* %74
%76 = zext i8 %75 to i32
%77 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%78 = load i8, i8* %77
%79 = zext i8 %78 to i32
%80 = icmp sgt i32 %76, %79
br i1 %80, label %81, label %91
81: ; preds = %67
%82 = load [4 x i8]*, [4 x i8]** %6
%83 = load i8, i8* %16
%84 = zext i8 %83 to i64
%85 = getelementptr inbounds [4 x i8], [4 x i8]* %82, i64 %84
%86 = load i8, i8* %15
%87 = zext i8 %86 to i64
%88 = getelementptr inbounds [4 x i8], [4 x i8]* %85, i64 0, i64 %87
%89 = load i8, i8* %88
%90 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
store i8 %89, i8* %90
br label %91
91: ; preds = %81, %67
%92 = load [4 x i8]*, [4 x i8]** %6
%93 = load i8, i8* %16
%94 = zext i8 %93 to i64
%95 = getelementptr inbounds [4 x i8], [4 x i8]* %92, i64 %94
%96 = load i8, i8* %15
%97 = zext i8 %96 to i64
%98 = getelementptr inbounds [4 x i8], [4 x i8]* %95, i64 0, i64 %97
%99 = load i8, i8* %98
%100 = zext i8 %99 to i32
%101 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%102 = load i8, i8* %101
%103 = zext i8 %102 to i32
%104 = icmp slt i32 %100, %103
br i1 %104, label %105, label %115
105: ; preds = %91
%106 = load [4 x i8]*, [4 x i8]** %6
%107 = load i8, i8* %16
%108 = zext i8 %107 to i64
%109 = getelementptr inbounds [4 x i8], [4 x i8]* %106, i64 %108
%110 = load i8, i8* %15
%111 = zext i8 %110 to i64
%112 = getelementptr inbounds [4 x i8], [4 x i8]* %109, i64 0, i64 %111
%113 = load i8, i8* %112
%114 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
store i8 %113, i8* %114
br label %115
115: ; preds = %105, %91
br label %116
116: ; preds = %115, %66
br label %117
117: ; preds = %116, %54
br label %118
118: ; preds = %117
%119 = load i8, i8* %15
%120 = add i8 %119, 1
store i8 %120, i8* %15
br label %38
121: ; preds = %38
br label %122
122: ; preds = %121
%123 = load i8, i8* %16
%124 = add i8 %123, 1
store i8 %124, i8* %16
br label %32
125: ; preds = %32
%126 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%127 = load i8, i8* %126
%128 = zext i8 %127 to i32
%129 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%130 = load i8, i8* %129
%131 = zext i8 %130 to i32
%132 = icmp sgt i32 %128, %131
br i1 %132, label %133, label %139
133: ; preds = %125
%134 = load i32, i32* %22
%135 = icmp ne i32 %134, 0
br i1 %135, label %136, label %153
136: ; preds = %133
%137 = load i32, i32* %23
%138 = icmp ne i32 %137, 0
br i1 %138, label %139, label %153
139: ; preds = %136, %125
%140 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%141 = load i8, i8* %140
%142 = zext i8 %141 to i32
%143 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%144 = load i8, i8* %143
%145 = zext i8 %144 to i32
%146 = icmp eq i32 %142, %145
br i1 %146, label %147, label %174
147: ; preds = %139
%148 = load i32, i32* %22
%149 = icmp ne i32 %148, 0
br i1 %149, label %174, label %150
150: ; preds = %147
%151 = load i32, i32* %23
%152 = icmp ne i32 %151, 0
br i1 %152, label %174, label %153
153: ; preds = %150, %136, %133
%154 = load [4 x i8]*, [4 x i8]** %6
%155 = getelementptr inbounds [4 x i8], [4 x i8]* %154, i64 0
%156 = getelementptr inbounds [4 x i8], [4 x i8]* %155, i64 0, i64 0
%157 = load i8, i8* %156
%158 = load i8*, i8** %5
%159 = getelementptr inbounds i8, i8* %158, i32 1
store i8* %159, i8** %5
store i8 %157, i8* %158
%160 = load i8*, i8** %5
%161 = getelementptr inbounds i8, i8* %160, i32 1
store i8* %161, i8** %5
%162 = load i8*, i8** %5
%163 = getelementptr inbounds i8, i8* %162, i32 1
store i8* %163, i8** %5
store i8 0, i8* %162
%164 = load i8*, i8** %5
%165 = getelementptr inbounds i8, i8* %164, i32 1
store i8* %165, i8** %5
store i8 0, i8* %164
%166 = load i8*, i8** %5
%167 = getelementptr inbounds i8, i8* %166, i32 1
store i8* %167, i8** %5
store i8 0, i8* %166
%168 = load i8*, i8** %5
%169 = getelementptr inbounds i8, i8* %168, i32 1
store i8* %169, i8** %5
store i8 0, i8* %168
%170 = load i8*, i8** %5
%171 = getelementptr inbounds i8, i8* %170, i32 1
store i8* %171, i8** %5
store i8 0, i8* %170
%172 = load i8*, i8** %5
%173 = getelementptr inbounds i8, i8* %172, i32 1
store i8* %173, i8** %5
store i8 0, i8* %172
br label %1949
174: ; preds = %150, %147, %139
store i32 0, i32* %12
store i32 -1, i32* %13
store i32 -1, i32* %14
%175 = load i32, i32* %22
%176 = icmp ne i32 %175, 0
br i1 %176, label %177, label %179
177: ; preds = %174
%178 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
store i8 0, i8* %178
br label %183
179: ; preds = %174
%180 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%181 = load i8, i8* %180
%182 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
store i8 %181, i8* %182
br label %183
183: ; preds = %179, %177
%184 = load i32, i32* %23
%185 = icmp ne i32 %184, 0
br i1 %185, label %186, label %188
186: ; preds = %183
%187 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
store i8 -1, i8* %187
br label %192
188: ; preds = %183
%189 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%190 = load i8, i8* %189
%191 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
store i8 %190, i8* %191
br label %192
192: ; preds = %188, %186
store i8 0, i8* %17
br label %193
193: ; preds = %221, %192
%194 = load i8, i8* %17
%195 = zext i8 %194 to i32
%196 = icmp slt i32 %195, 7
br i1 %196, label %197, label %224
197: ; preds = %193
%198 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%199 = load i8, i8* %198
%200 = zext i8 %199 to i32
%201 = load i8, i8* %17
%202 = zext i8 %201 to i32
%203 = mul nsw i32 2, %202
%204 = add nsw i32 %203, 1
%205 = mul nsw i32 %200, %204
%206 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%207 = load i8, i8* %206
%208 = zext i8 %207 to i32
%209 = load i8, i8* %17
%210 = zext i8 %209 to i32
%211 = mul nsw i32 2, %210
%212 = add nsw i32 %211, 1
%213 = sub nsw i32 14, %212
%214 = mul nsw i32 %208, %213
%215 = add nsw i32 %205, %214
%216 = sdiv i32 %215, 14
%217 = trunc i32 %216 to i8
%218 = load i8, i8* %17
%219 = zext i8 %218 to i64
%220 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 %219
store i8 %217, i8* %220
br label %221
221: ; preds = %197
%222 = load i8, i8* %17
%223 = add i8 %222, 1
store i8 %223, i8* %17
br label %193
224: ; preds = %193
store i8 0, i8* %16
br label %225
225: ; preds = %578, %224
%226 = load i8, i8* %16
%227 = zext i8 %226 to i32
%228 = load i32, i32* %8
%229 = icmp slt i32 %227, %228
br i1 %229, label %230, label %581
230: ; preds = %225
store i8 0, i8* %15
br label %231
231: ; preds = %574, %230
%232 = load i8, i8* %15
%233 = zext i8 %232 to i32
%234 = load i32, i32* %7
%235 = icmp slt i32 %233, %234
br i1 %235, label %236, label %577
236: ; preds = %231
%237 = load [4 x i8]*, [4 x i8]** %6
%238 = load i8, i8* %16
%239 = zext i8 %238 to i64
%240 = getelementptr inbounds [4 x i8], [4 x i8]* %237, i64 %239
%241 = load i8, i8* %15
%242 = zext i8 %241 to i64
%243 = getelementptr inbounds [4 x i8], [4 x i8]* %240, i64 0, i64 %242
%244 = load i8, i8* %243
%245 = zext i8 %244 to i32
%246 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 0
%247 = load i8, i8* %246
%248 = zext i8 %247 to i32
%249 = icmp sgt i32 %245, %248
br i1 %249, label %250, label %273
250: ; preds = %236
%251 = load i8, i8* %16
%252 = zext i8 %251 to i32
%253 = mul nsw i32 4, %252
%254 = load i8, i8* %15
%255 = zext i8 %254 to i32
%256 = add nsw i32 %253, %255
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %257
store i8 0, i8* %258
%259 = load [4 x i8]*, [4 x i8]** %6
%260 = load i8, i8* %16
%261 = zext i8 %260 to i64
%262 = getelementptr inbounds [4 x i8], [4 x i8]* %259, i64 %261
%263 = load i8, i8* %15
%264 = zext i8 %263 to i64
%265 = getelementptr inbounds [4 x i8], [4 x i8]* %262, i64 0, i64 %264
%266 = load i8, i8* %265
%267 = zext i8 %266 to i32
%268 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%269 = load i8, i8* %268
%270 = zext i8 %269 to i32
%271 = sub nsw i32 %267, %270
%272 = trunc i32 %271 to i16
store i16 %272, i16* %24
br label %566
273: ; preds = %236
%274 = load [4 x i8]*, [4 x i8]** %6
%275 = load i8, i8* %16
%276 = zext i8 %275 to i64
%277 = getelementptr inbounds [4 x i8], [4 x i8]* %274, i64 %276
%278 = load i8, i8* %15
%279 = zext i8 %278 to i64
%280 = getelementptr inbounds [4 x i8], [4 x i8]* %277, i64 0, i64 %279
%281 = load i8, i8* %280
%282 = zext i8 %281 to i32
%283 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 1
%284 = load i8, i8* %283
%285 = zext i8 %284 to i32
%286 = icmp sgt i32 %282, %285
br i1 %286, label %287, label %317
287: ; preds = %273
%288 = load i8, i8* %16
%289 = zext i8 %288 to i32
%290 = mul nsw i32 4, %289
%291 = load i8, i8* %15
%292 = zext i8 %291 to i32
%293 = add nsw i32 %290, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %294
store i8 2, i8* %295
%296 = load [4 x i8]*, [4 x i8]** %6
%297 = load i8, i8* %16
%298 = zext i8 %297 to i64
%299 = getelementptr inbounds [4 x i8], [4 x i8]* %296, i64 %298
%300 = load i8, i8* %15
%301 = zext i8 %300 to i64
%302 = getelementptr inbounds [4 x i8], [4 x i8]* %299, i64 0, i64 %301
%303 = load i8, i8* %302
%304 = zext i8 %303 to i32
%305 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%306 = load i8, i8* %305
%307 = zext i8 %306 to i32
%308 = mul nsw i32 %307, 6
%309 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%310 = load i8, i8* %309
%311 = zext i8 %310 to i32
%312 = mul nsw i32 %311, 1
%313 = add nsw i32 %308, %312
%314 = sdiv i32 %313, 7
%315 = sub nsw i32 %304, %314
%316 = trunc i32 %315 to i16
store i16 %316, i16* %24
br label %565
317: ; preds = %273
%318 = load [4 x i8]*, [4 x i8]** %6
%319 = load i8, i8* %16
%320 = zext i8 %319 to i64
%321 = getelementptr inbounds [4 x i8], [4 x i8]* %318, i64 %320
%322 = load i8, i8* %15
%323 = zext i8 %322 to i64
%324 = getelementptr inbounds [4 x i8], [4 x i8]* %321, i64 0, i64 %323
%325 = load i8, i8* %324
%326 = zext i8 %325 to i32
%327 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 2
%328 = load i8, i8* %327
%329 = zext i8 %328 to i32
%330 = icmp sgt i32 %326, %329
br i1 %330, label %331, label %361
331: ; preds = %317
%332 = load i8, i8* %16
%333 = zext i8 %332 to i32
%334 = mul nsw i32 4, %333
%335 = load i8, i8* %15
%336 = zext i8 %335 to i32
%337 = add nsw i32 %334, %336
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %338
store i8 3, i8* %339
%340 = load [4 x i8]*, [4 x i8]** %6
%341 = load i8, i8* %16
%342 = zext i8 %341 to i64
%343 = getelementptr inbounds [4 x i8], [4 x i8]* %340, i64 %342
%344 = load i8, i8* %15
%345 = zext i8 %344 to i64
%346 = getelementptr inbounds [4 x i8], [4 x i8]* %343, i64 0, i64 %345
%347 = load i8, i8* %346
%348 = zext i8 %347 to i32
%349 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%350 = load i8, i8* %349
%351 = zext i8 %350 to i32
%352 = mul nsw i32 %351, 5
%353 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%354 = load i8, i8* %353
%355 = zext i8 %354 to i32
%356 = mul nsw i32 %355, 2
%357 = add nsw i32 %352, %356
%358 = sdiv i32 %357, 7
%359 = sub nsw i32 %348, %358
%360 = trunc i32 %359 to i16
store i16 %360, i16* %24
br label %564
361: ; preds = %317
%362 = load [4 x i8]*, [4 x i8]** %6
%363 = load i8, i8* %16
%364 = zext i8 %363 to i64
%365 = getelementptr inbounds [4 x i8], [4 x i8]* %362, i64 %364
%366 = load i8, i8* %15
%367 = zext i8 %366 to i64
%368 = getelementptr inbounds [4 x i8], [4 x i8]* %365, i64 0, i64 %367
%369 = load i8, i8* %368
%370 = zext i8 %369 to i32
%371 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 3
%372 = load i8, i8* %371
%373 = zext i8 %372 to i32
%374 = icmp sgt i32 %370, %373
br i1 %374, label %375, label %405
375: ; preds = %361
%376 = load i8, i8* %16
%377 = zext i8 %376 to i32
%378 = mul nsw i32 4, %377
%379 = load i8, i8* %15
%380 = zext i8 %379 to i32
%381 = add nsw i32 %378, %380
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %382
store i8 4, i8* %383
%384 = load [4 x i8]*, [4 x i8]** %6
%385 = load i8, i8* %16
%386 = zext i8 %385 to i64
%387 = getelementptr inbounds [4 x i8], [4 x i8]* %384, i64 %386
%388 = load i8, i8* %15
%389 = zext i8 %388 to i64
%390 = getelementptr inbounds [4 x i8], [4 x i8]* %387, i64 0, i64 %389
%391 = load i8, i8* %390
%392 = zext i8 %391 to i32
%393 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%394 = load i8, i8* %393
%395 = zext i8 %394 to i32
%396 = mul nsw i32 %395, 4
%397 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%398 = load i8, i8* %397
%399 = zext i8 %398 to i32
%400 = mul nsw i32 %399, 3
%401 = add nsw i32 %396, %400
%402 = sdiv i32 %401, 7
%403 = sub nsw i32 %392, %402
%404 = trunc i32 %403 to i16
store i16 %404, i16* %24
br label %563
405: ; preds = %361
%406 = load [4 x i8]*, [4 x i8]** %6
%407 = load i8, i8* %16
%408 = zext i8 %407 to i64
%409 = getelementptr inbounds [4 x i8], [4 x i8]* %406, i64 %408
%410 = load i8, i8* %15
%411 = zext i8 %410 to i64
%412 = getelementptr inbounds [4 x i8], [4 x i8]* %409, i64 0, i64 %411
%413 = load i8, i8* %412
%414 = zext i8 %413 to i32
%415 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 4
%416 = load i8, i8* %415
%417 = zext i8 %416 to i32
%418 = icmp sgt i32 %414, %417
br i1 %418, label %419, label %449
419: ; preds = %405
%420 = load i8, i8* %16
%421 = zext i8 %420 to i32
%422 = mul nsw i32 4, %421
%423 = load i8, i8* %15
%424 = zext i8 %423 to i32
%425 = add nsw i32 %422, %424
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %426
store i8 5, i8* %427
%428 = load [4 x i8]*, [4 x i8]** %6
%429 = load i8, i8* %16
%430 = zext i8 %429 to i64
%431 = getelementptr inbounds [4 x i8], [4 x i8]* %428, i64 %430
%432 = load i8, i8* %15
%433 = zext i8 %432 to i64
%434 = getelementptr inbounds [4 x i8], [4 x i8]* %431, i64 0, i64 %433
%435 = load i8, i8* %434
%436 = zext i8 %435 to i32
%437 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%438 = load i8, i8* %437
%439 = zext i8 %438 to i32
%440 = mul nsw i32 %439, 3
%441 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%442 = load i8, i8* %441
%443 = zext i8 %442 to i32
%444 = mul nsw i32 %443, 4
%445 = add nsw i32 %440, %444
%446 = sdiv i32 %445, 7
%447 = sub nsw i32 %436, %446
%448 = trunc i32 %447 to i16
store i16 %448, i16* %24
br label %562
449: ; preds = %405
%450 = load [4 x i8]*, [4 x i8]** %6
%451 = load i8, i8* %16
%452 = zext i8 %451 to i64
%453 = getelementptr inbounds [4 x i8], [4 x i8]* %450, i64 %452
%454 = load i8, i8* %15
%455 = zext i8 %454 to i64
%456 = getelementptr inbounds [4 x i8], [4 x i8]* %453, i64 0, i64 %455
%457 = load i8, i8* %456
%458 = zext i8 %457 to i32
%459 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 5
%460 = load i8, i8* %459
%461 = zext i8 %460 to i32
%462 = icmp sgt i32 %458, %461
br i1 %462, label %463, label %493
463: ; preds = %449
%464 = load i8, i8* %16
%465 = zext i8 %464 to i32
%466 = mul nsw i32 4, %465
%467 = load i8, i8* %15
%468 = zext i8 %467 to i32
%469 = add nsw i32 %466, %468
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %470
store i8 6, i8* %471
%472 = load [4 x i8]*, [4 x i8]** %6
%473 = load i8, i8* %16
%474 = zext i8 %473 to i64
%475 = getelementptr inbounds [4 x i8], [4 x i8]* %472, i64 %474
%476 = load i8, i8* %15
%477 = zext i8 %476 to i64
%478 = getelementptr inbounds [4 x i8], [4 x i8]* %475, i64 0, i64 %477
%479 = load i8, i8* %478
%480 = zext i8 %479 to i32
%481 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%482 = load i8, i8* %481
%483 = zext i8 %482 to i32
%484 = mul nsw i32 %483, 2
%485 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%486 = load i8, i8* %485
%487 = zext i8 %486 to i32
%488 = mul nsw i32 %487, 5
%489 = add nsw i32 %484, %488
%490 = sdiv i32 %489, 7
%491 = sub nsw i32 %480, %490
%492 = trunc i32 %491 to i16
store i16 %492, i16* %24
br label %561
493: ; preds = %449
%494 = load [4 x i8]*, [4 x i8]** %6
%495 = load i8, i8* %16
%496 = zext i8 %495 to i64
%497 = getelementptr inbounds [4 x i8], [4 x i8]* %494, i64 %496
%498 = load i8, i8* %15
%499 = zext i8 %498 to i64
%500 = getelementptr inbounds [4 x i8], [4 x i8]* %497, i64 0, i64 %499
%501 = load i8, i8* %500
%502 = zext i8 %501 to i32
%503 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 6
%504 = load i8, i8* %503
%505 = zext i8 %504 to i32
%506 = icmp sgt i32 %502, %505
br i1 %506, label %507, label %537
507: ; preds = %493
%508 = load i8, i8* %16
%509 = zext i8 %508 to i32
%510 = mul nsw i32 4, %509
%511 = load i8, i8* %15
%512 = zext i8 %511 to i32
%513 = add nsw i32 %510, %512
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %514
store i8 7, i8* %515
%516 = load [4 x i8]*, [4 x i8]** %6
%517 = load i8, i8* %16
%518 = zext i8 %517 to i64
%519 = getelementptr inbounds [4 x i8], [4 x i8]* %516, i64 %518
%520 = load i8, i8* %15
%521 = zext i8 %520 to i64
%522 = getelementptr inbounds [4 x i8], [4 x i8]* %519, i64 0, i64 %521
%523 = load i8, i8* %522
%524 = zext i8 %523 to i32
%525 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%526 = load i8, i8* %525
%527 = zext i8 %526 to i32
%528 = mul nsw i32 %527, 1
%529 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%530 = load i8, i8* %529
%531 = zext i8 %530 to i32
%532 = mul nsw i32 %531, 6
%533 = add nsw i32 %528, %532
%534 = sdiv i32 %533, 7
%535 = sub nsw i32 %524, %534
%536 = trunc i32 %535 to i16
store i16 %536, i16* %24
br label %560
537: ; preds = %493
%538 = load i8, i8* %16
%539 = zext i8 %538 to i32
%540 = mul nsw i32 4, %539
%541 = load i8, i8* %15
%542 = zext i8 %541 to i32
%543 = add nsw i32 %540, %542
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %544
store i8 1, i8* %545
%546 = load [4 x i8]*, [4 x i8]** %6
%547 = load i8, i8* %16
%548 = zext i8 %547 to i64
%549 = getelementptr inbounds [4 x i8], [4 x i8]* %546, i64 %548
%550 = load i8, i8* %15
%551 = zext i8 %550 to i64
%552 = getelementptr inbounds [4 x i8], [4 x i8]* %549, i64 0, i64 %551
%553 = load i8, i8* %552
%554 = zext i8 %553 to i32
%555 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%556 = load i8, i8* %555
%557 = zext i8 %556 to i32
%558 = sub nsw i32 %554, %557
%559 = trunc i32 %558 to i16
store i16 %559, i16* %24
br label %560
560: ; preds = %537, %507
br label %561
561: ; preds = %560, %463
br label %562
562: ; preds = %561, %419
br label %563
563: ; preds = %562, %375
br label %564
564: ; preds = %563, %331
br label %565
565: ; preds = %564, %287
br label %566
566: ; preds = %565, %250
%567 = load i16, i16* %24
%568 = sext i16 %567 to i32
%569 = load i16, i16* %24
%570 = sext i16 %569 to i32
%571 = mul nsw i32 %568, %570
%572 = load i32, i32* %12
%573 = add i32 %572, %571
store i32 %573, i32* %12
br label %574
574: ; preds = %566
%575 = load i8, i8* %15
%576 = add i8 %575, 1
store i8 %576, i8* %15
br label %231
577: ; preds = %231
br label %578
578: ; preds = %577
%579 = load i8, i8* %16
%580 = add i8 %579, 1
store i8 %580, i8* %16
br label %225
581: ; preds = %225
%582 = load i32, i32* %12
%583 = icmp uge i32 %582, 32
br i1 %583, label %584, label %1904
584: ; preds = %581
store i32 0, i32* %13
store i8 0, i8* %17
br label %585
585: ; preds = %613, %584
%586 = load i8, i8* %17
%587 = zext i8 %586 to i32
%588 = icmp slt i32 %587, 5
br i1 %588, label %589, label %616
589: ; preds = %585
%590 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%591 = load i8, i8* %590
%592 = zext i8 %591 to i32
%593 = load i8, i8* %17
%594 = zext i8 %593 to i32
%595 = mul nsw i32 2, %594
%596 = add nsw i32 %595, 1
%597 = sub nsw i32 10, %596
%598 = mul nsw i32 %592, %597
%599 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%600 = load i8, i8* %599
%601 = zext i8 %600 to i32
%602 = load i8, i8* %17
%603 = zext i8 %602 to i32
%604 = mul nsw i32 2, %603
%605 = add nsw i32 %604, 1
%606 = mul nsw i32 %601, %605
%607 = add nsw i32 %598, %606
%608 = sdiv i32 %607, 10
%609 = trunc i32 %608 to i8
%610 = load i8, i8* %17
%611 = zext i8 %610 to i64
%612 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 %611
store i8 %609, i8* %612
br label %613
613: ; preds = %589
%614 = load i8, i8* %17
%615 = add i8 %614, 1
store i8 %615, i8* %17
br label %585
616: ; preds = %585
store i8 0, i8* %16
br label %617
617: ; preds = %922, %616
%618 = load i8, i8* %16
%619 = zext i8 %618 to i32
%620 = load i32, i32* %8
%621 = icmp slt i32 %619, %620
br i1 %621, label %622, label %925
622: ; preds = %617
store i8 0, i8* %15
br label %623
623: ; preds = %918, %622
%624 = load i8, i8* %15
%625 = zext i8 %624 to i32
%626 = load i32, i32* %7
%627 = icmp slt i32 %625, %626
br i1 %627, label %628, label %921
628: ; preds = %623
%629 = load [4 x i8]*, [4 x i8]** %6
%630 = load i8, i8* %16
%631 = zext i8 %630 to i64
%632 = getelementptr inbounds [4 x i8], [4 x i8]* %629, i64 %631
%633 = load i8, i8* %15
%634 = zext i8 %633 to i64
%635 = getelementptr inbounds [4 x i8], [4 x i8]* %632, i64 0, i64 %634
%636 = load i8, i8* %635
%637 = zext i8 %636 to i32
%638 = icmp eq i32 %637, 0
br i1 %638, label %639, label %648
639: ; preds = %628
%640 = load i8, i8* %16
%641 = zext i8 %640 to i32
%642 = mul nsw i32 4, %641
%643 = load i8, i8* %15
%644 = zext i8 %643 to i32
%645 = add nsw i32 %642, %644
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %646
store i8 6, i8* %647
store i16 0, i16* %24
br label %910
648: ; preds = %628
%649 = load [4 x i8]*, [4 x i8]** %6
%650 = load i8, i8* %16
%651 = zext i8 %650 to i64
%652 = getelementptr inbounds [4 x i8], [4 x i8]* %649, i64 %651
%653 = load i8, i8* %15
%654 = zext i8 %653 to i64
%655 = getelementptr inbounds [4 x i8], [4 x i8]* %652, i64 0, i64 %654
%656 = load i8, i8* %655
%657 = zext i8 %656 to i32
%658 = icmp eq i32 %657, 255
br i1 %658, label %659, label %668
659: ; preds = %648
%660 = load i8, i8* %16
%661 = zext i8 %660 to i32
%662 = mul nsw i32 4, %661
%663 = load i8, i8* %15
%664 = zext i8 %663 to i32
%665 = add nsw i32 %662, %664
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %666
store i8 7, i8* %667
store i16 0, i16* %24
br label %909
668: ; preds = %648
%669 = load [4 x i8]*, [4 x i8]** %6
%670 = load i8, i8* %16
%671 = zext i8 %670 to i64
%672 = getelementptr inbounds [4 x i8], [4 x i8]* %669, i64 %671
%673 = load i8, i8* %15
%674 = zext i8 %673 to i64
%675 = getelementptr inbounds [4 x i8], [4 x i8]* %672, i64 0, i64 %674
%676 = load i8, i8* %675
%677 = zext i8 %676 to i32
%678 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 0
%679 = load i8, i8* %678
%680 = zext i8 %679 to i32
%681 = icmp sle i32 %677, %680
br i1 %681, label %682, label %705
682: ; preds = %668
%683 = load i8, i8* %16
%684 = zext i8 %683 to i32
%685 = mul nsw i32 4, %684
%686 = load i8, i8* %15
%687 = zext i8 %686 to i32
%688 = add nsw i32 %685, %687
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %689
store i8 0, i8* %690
%691 = load [4 x i8]*, [4 x i8]** %6
%692 = load i8, i8* %16
%693 = zext i8 %692 to i64
%694 = getelementptr inbounds [4 x i8], [4 x i8]* %691, i64 %693
%695 = load i8, i8* %15
%696 = zext i8 %695 to i64
%697 = getelementptr inbounds [4 x i8], [4 x i8]* %694, i64 0, i64 %696
%698 = load i8, i8* %697
%699 = zext i8 %698 to i32
%700 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%701 = load i8, i8* %700
%702 = zext i8 %701 to i32
%703 = sub nsw i32 %699, %702
%704 = trunc i32 %703 to i16
store i16 %704, i16* %24
br label %908
705: ; preds = %668
%706 = load [4 x i8]*, [4 x i8]** %6
%707 = load i8, i8* %16
%708 = zext i8 %707 to i64
%709 = getelementptr inbounds [4 x i8], [4 x i8]* %706, i64 %708
%710 = load i8, i8* %15
%711 = zext i8 %710 to i64
%712 = getelementptr inbounds [4 x i8], [4 x i8]* %709, i64 0, i64 %711
%713 = load i8, i8* %712
%714 = zext i8 %713 to i32
%715 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 1
%716 = load i8, i8* %715
%717 = zext i8 %716 to i32
%718 = icmp sle i32 %714, %717
br i1 %718, label %719, label %749
719: ; preds = %705
%720 = load i8, i8* %16
%721 = zext i8 %720 to i32
%722 = mul nsw i32 4, %721
%723 = load i8, i8* %15
%724 = zext i8 %723 to i32
%725 = add nsw i32 %722, %724
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %726
store i8 2, i8* %727
%728 = load [4 x i8]*, [4 x i8]** %6
%729 = load i8, i8* %16
%730 = zext i8 %729 to i64
%731 = getelementptr inbounds [4 x i8], [4 x i8]* %728, i64 %730
%732 = load i8, i8* %15
%733 = zext i8 %732 to i64
%734 = getelementptr inbounds [4 x i8], [4 x i8]* %731, i64 0, i64 %733
%735 = load i8, i8* %734
%736 = zext i8 %735 to i32
%737 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%738 = load i8, i8* %737
%739 = zext i8 %738 to i32
%740 = mul nsw i32 %739, 4
%741 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%742 = load i8, i8* %741
%743 = zext i8 %742 to i32
%744 = mul nsw i32 %743, 1
%745 = add nsw i32 %740, %744
%746 = sdiv i32 %745, 5
%747 = sub nsw i32 %736, %746
%748 = trunc i32 %747 to i16
store i16 %748, i16* %24
br label %907
749: ; preds = %705
%750 = load [4 x i8]*, [4 x i8]** %6
%751 = load i8, i8* %16
%752 = zext i8 %751 to i64
%753 = getelementptr inbounds [4 x i8], [4 x i8]* %750, i64 %752
%754 = load i8, i8* %15
%755 = zext i8 %754 to i64
%756 = getelementptr inbounds [4 x i8], [4 x i8]* %753, i64 0, i64 %755
%757 = load i8, i8* %756
%758 = zext i8 %757 to i32
%759 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 2
%760 = load i8, i8* %759
%761 = zext i8 %760 to i32
%762 = icmp sle i32 %758, %761
br i1 %762, label %763, label %793
763: ; preds = %749
%764 = load i8, i8* %16
%765 = zext i8 %764 to i32
%766 = mul nsw i32 4, %765
%767 = load i8, i8* %15
%768 = zext i8 %767 to i32
%769 = add nsw i32 %766, %768
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %770
store i8 3, i8* %771
%772 = load [4 x i8]*, [4 x i8]** %6
%773 = load i8, i8* %16
%774 = zext i8 %773 to i64
%775 = getelementptr inbounds [4 x i8], [4 x i8]* %772, i64 %774
%776 = load i8, i8* %15
%777 = zext i8 %776 to i64
%778 = getelementptr inbounds [4 x i8], [4 x i8]* %775, i64 0, i64 %777
%779 = load i8, i8* %778
%780 = zext i8 %779 to i32
%781 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%782 = load i8, i8* %781
%783 = zext i8 %782 to i32
%784 = mul nsw i32 %783, 3
%785 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%786 = load i8, i8* %785
%787 = zext i8 %786 to i32
%788 = mul nsw i32 %787, 2
%789 = add nsw i32 %784, %788
%790 = sdiv i32 %789, 5
%791 = sub nsw i32 %780, %790
%792 = trunc i32 %791 to i16
store i16 %792, i16* %24
br label %906
793: ; preds = %749
%794 = load [4 x i8]*, [4 x i8]** %6
%795 = load i8, i8* %16
%796 = zext i8 %795 to i64
%797 = getelementptr inbounds [4 x i8], [4 x i8]* %794, i64 %796
%798 = load i8, i8* %15
%799 = zext i8 %798 to i64
%800 = getelementptr inbounds [4 x i8], [4 x i8]* %797, i64 0, i64 %799
%801 = load i8, i8* %800
%802 = zext i8 %801 to i32
%803 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 3
%804 = load i8, i8* %803
%805 = zext i8 %804 to i32
%806 = icmp sle i32 %802, %805
br i1 %806, label %807, label %837
807: ; preds = %793
%808 = load i8, i8* %16
%809 = zext i8 %808 to i32
%810 = mul nsw i32 4, %809
%811 = load i8, i8* %15
%812 = zext i8 %811 to i32
%813 = add nsw i32 %810, %812
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %814
store i8 4, i8* %815
%816 = load [4 x i8]*, [4 x i8]** %6
%817 = load i8, i8* %16
%818 = zext i8 %817 to i64
%819 = getelementptr inbounds [4 x i8], [4 x i8]* %816, i64 %818
%820 = load i8, i8* %15
%821 = zext i8 %820 to i64
%822 = getelementptr inbounds [4 x i8], [4 x i8]* %819, i64 0, i64 %821
%823 = load i8, i8* %822
%824 = zext i8 %823 to i32
%825 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%826 = load i8, i8* %825
%827 = zext i8 %826 to i32
%828 = mul nsw i32 %827, 2
%829 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%830 = load i8, i8* %829
%831 = zext i8 %830 to i32
%832 = mul nsw i32 %831, 3
%833 = add nsw i32 %828, %832
%834 = sdiv i32 %833, 5
%835 = sub nsw i32 %824, %834
%836 = trunc i32 %835 to i16
store i16 %836, i16* %24
br label %905
837: ; preds = %793
%838 = load [4 x i8]*, [4 x i8]** %6
%839 = load i8, i8* %16
%840 = zext i8 %839 to i64
%841 = getelementptr inbounds [4 x i8], [4 x i8]* %838, i64 %840
%842 = load i8, i8* %15
%843 = zext i8 %842 to i64
%844 = getelementptr inbounds [4 x i8], [4 x i8]* %841, i64 0, i64 %843
%845 = load i8, i8* %844
%846 = zext i8 %845 to i32
%847 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 4
%848 = load i8, i8* %847
%849 = zext i8 %848 to i32
%850 = icmp sle i32 %846, %849
br i1 %850, label %851, label %881
851: ; preds = %837
%852 = load i8, i8* %16
%853 = zext i8 %852 to i32
%854 = mul nsw i32 4, %853
%855 = load i8, i8* %15
%856 = zext i8 %855 to i32
%857 = add nsw i32 %854, %856
%858 = sext i32 %857 to i64
%859 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %858
store i8 5, i8* %859
%860 = load [4 x i8]*, [4 x i8]** %6
%861 = load i8, i8* %16
%862 = zext i8 %861 to i64
%863 = getelementptr inbounds [4 x i8], [4 x i8]* %860, i64 %862
%864 = load i8, i8* %15
%865 = zext i8 %864 to i64
%866 = getelementptr inbounds [4 x i8], [4 x i8]* %863, i64 0, i64 %865
%867 = load i8, i8* %866
%868 = zext i8 %867 to i32
%869 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%870 = load i8, i8* %869
%871 = zext i8 %870 to i32
%872 = mul nsw i32 %871, 1
%873 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%874 = load i8, i8* %873
%875 = zext i8 %874 to i32
%876 = mul nsw i32 %875, 4
%877 = add nsw i32 %872, %876
%878 = sdiv i32 %877, 5
%879 = sub nsw i32 %868, %878
%880 = trunc i32 %879 to i16
store i16 %880, i16* %24
br label %904
881: ; preds = %837
%882 = load i8, i8* %16
%883 = zext i8 %882 to i32
%884 = mul nsw i32 4, %883
%885 = load i8, i8* %15
%886 = zext i8 %885 to i32
%887 = add nsw i32 %884, %886
%888 = sext i32 %887 to i64
%889 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %888
store i8 1, i8* %889
%890 = load [4 x i8]*, [4 x i8]** %6
%891 = load i8, i8* %16
%892 = zext i8 %891 to i64
%893 = getelementptr inbounds [4 x i8], [4 x i8]* %890, i64 %892
%894 = load i8, i8* %15
%895 = zext i8 %894 to i64
%896 = getelementptr inbounds [4 x i8], [4 x i8]* %893, i64 0, i64 %895
%897 = load i8, i8* %896
%898 = zext i8 %897 to i32
%899 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%900 = load i8, i8* %899
%901 = zext i8 %900 to i32
%902 = sub nsw i32 %898, %901
%903 = trunc i32 %902 to i16
store i16 %903, i16* %24
br label %904
904: ; preds = %881, %851
br label %905
905: ; preds = %904, %807
br label %906
906: ; preds = %905, %763
br label %907
907: ; preds = %906, %719
br label %908
908: ; preds = %907, %682
br label %909
909: ; preds = %908, %659
br label %910
910: ; preds = %909, %639
%911 = load i16, i16* %24
%912 = sext i16 %911 to i32
%913 = load i16, i16* %24
%914 = sext i16 %913 to i32
%915 = mul nsw i32 %912, %914
%916 = load i32, i32* %13
%917 = add i32 %916, %915
store i32 %917, i32* %13
br label %918
918: ; preds = %910
%919 = load i8, i8* %15
%920 = add i8 %919, 1
store i8 %920, i8* %15
br label %623
921: ; preds = %623
br label %922
922: ; preds = %921
%923 = load i8, i8* %16
%924 = add i8 %923, 1
store i8 %924, i8* %16
br label %617
925: ; preds = %617
%926 = load i32, i32* %13
%927 = icmp ugt i32 %926, 96
br i1 %927, label %928, label %1903
928: ; preds = %925
%929 = load i32, i32* %12
%930 = icmp ugt i32 %929, 96
br i1 %930, label %931, label %1903
931: ; preds = %928
store i16 0, i16* %25
store i16 0, i16* %26
store i8 0, i8* %27
store i8 0, i8* %28
%932 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
store i16 255, i16* %932
%933 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
store i16 0, i16* %933
store i8 0, i8* %16
br label %934
934: ; preds = %1039, %931
%935 = load i8, i8* %16
%936 = zext i8 %935 to i32
%937 = load i32, i32* %8
%938 = icmp slt i32 %936, %937
br i1 %938, label %939, label %1042
939: ; preds = %934
store i8 0, i8* %15
br label %940
940: ; preds = %1035, %939
%941 = load i8, i8* %15
%942 = zext i8 %941 to i32
%943 = load i32, i32* %7
%944 = icmp slt i32 %942, %943
br i1 %944, label %945, label %1038
945: ; preds = %940
%946 = load [4 x i8]*, [4 x i8]** %6
%947 = load i8, i8* %16
%948 = zext i8 %947 to i64
%949 = getelementptr inbounds [4 x i8], [4 x i8]* %946, i64 %948
%950 = load i8, i8* %15
%951 = zext i8 %950 to i64
%952 = getelementptr inbounds [4 x i8], [4 x i8]* %949, i64 0, i64 %951
%953 = load i8, i8* %952
%954 = zext i8 %953 to i32
%955 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%956 = load i16, i16* %955
%957 = sext i16 %956 to i32
%958 = icmp sgt i32 %954, %957
br i1 %958, label %959, label %990
959: ; preds = %945
%960 = load [4 x i8]*, [4 x i8]** %6
%961 = load i8, i8* %16
%962 = zext i8 %961 to i64
%963 = getelementptr inbounds [4 x i8], [4 x i8]* %960, i64 %962
%964 = load i8, i8* %15
%965 = zext i8 %964 to i64
%966 = getelementptr inbounds [4 x i8], [4 x i8]* %963, i64 0, i64 %965
%967 = load i8, i8* %966
%968 = zext i8 %967 to i32
%969 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%970 = load i8, i8* %969
%971 = zext i8 %970 to i32
%972 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%973 = load i8, i8* %972
%974 = zext i8 %973 to i32
%975 = sub nsw i32 %971, %974
%976 = sdiv i32 %975, 28
%977 = sub nsw i32 255, %976
%978 = icmp slt i32 %968, %977
br i1 %978, label %979, label %990
979: ; preds = %959
%980 = load [4 x i8]*, [4 x i8]** %6
%981 = load i8, i8* %16
%982 = zext i8 %981 to i64
%983 = getelementptr inbounds [4 x i8], [4 x i8]* %980, i64 %982
%984 = load i8, i8* %15
%985 = zext i8 %984 to i64
%986 = getelementptr inbounds [4 x i8], [4 x i8]* %983, i64 0, i64 %985
%987 = load i8, i8* %986
%988 = zext i8 %987 to i16
%989 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
store i16 %988, i16* %989
br label %990
990: ; preds = %979, %959, %945
%991 = load [4 x i8]*, [4 x i8]** %6
%992 = load i8, i8* %16
%993 = zext i8 %992 to i64
%994 = getelementptr inbounds [4 x i8], [4 x i8]* %991, i64 %993
%995 = load i8, i8* %15
%996 = zext i8 %995 to i64
%997 = getelementptr inbounds [4 x i8], [4 x i8]* %994, i64 0, i64 %996
%998 = load i8, i8* %997
%999 = zext i8 %998 to i32
%1000 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1001 = load i16, i16* %1000
%1002 = sext i16 %1001 to i32
%1003 = icmp slt i32 %999, %1002
br i1 %1003, label %1004, label %1034
1004: ; preds = %990
%1005 = load [4 x i8]*, [4 x i8]** %6
%1006 = load i8, i8* %16
%1007 = zext i8 %1006 to i64
%1008 = getelementptr inbounds [4 x i8], [4 x i8]* %1005, i64 %1007
%1009 = load i8, i8* %15
%1010 = zext i8 %1009 to i64
%1011 = getelementptr inbounds [4 x i8], [4 x i8]* %1008, i64 0, i64 %1010
%1012 = load i8, i8* %1011
%1013 = zext i8 %1012 to i32
%1014 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%1015 = load i8, i8* %1014
%1016 = zext i8 %1015 to i32
%1017 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%1018 = load i8, i8* %1017
%1019 = zext i8 %1018 to i32
%1020 = sub nsw i32 %1016, %1019
%1021 = sdiv i32 %1020, 28
%1022 = icmp sgt i32 %1013, %1021
br i1 %1022, label %1023, label %1034
1023: ; preds = %1004
%1024 = load [4 x i8]*, [4 x i8]** %6
%1025 = load i8, i8* %16
%1026 = zext i8 %1025 to i64
%1027 = getelementptr inbounds [4 x i8], [4 x i8]* %1024, i64 %1026
%1028 = load i8, i8* %15
%1029 = zext i8 %1028 to i64
%1030 = getelementptr inbounds [4 x i8], [4 x i8]* %1027, i64 0, i64 %1029
%1031 = load i8, i8* %1030
%1032 = zext i8 %1031 to i16
%1033 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
store i16 %1032, i16* %1033
br label %1034
1034: ; preds = %1023, %1004, %990
br label %1035
1035: ; preds = %1034
%1036 = load i8, i8* %15
%1037 = add i8 %1036, 1
store i8 %1037, i8* %15
br label %940
1038: ; preds = %940
br label %1039
1039: ; preds = %1038
%1040 = load i8, i8* %16
%1041 = add i8 %1040, 1
store i8 %1041, i8* %16
br label %934
1042: ; preds = %934
%1043 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1044 = load i16, i16* %1043
%1045 = sext i16 %1044 to i32
%1046 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1047 = load i16, i16* %1046
%1048 = sext i16 %1047 to i32
%1049 = icmp sle i32 %1045, %1048
br i1 %1049, label %1050, label %1053
1050: ; preds = %1042
%1051 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
store i16 1, i16* %1051
%1052 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
store i16 254, i16* %1052
br label %1053
1053: ; preds = %1050, %1042
store i8 0, i8* %17
br label %1054
1054: ; preds = %1082, %1053
%1055 = load i8, i8* %17
%1056 = zext i8 %1055 to i32
%1057 = icmp slt i32 %1056, 5
br i1 %1057, label %1058, label %1085
1058: ; preds = %1054
%1059 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1060 = load i16, i16* %1059
%1061 = sext i16 %1060 to i32
%1062 = load i8, i8* %17
%1063 = zext i8 %1062 to i32
%1064 = mul nsw i32 2, %1063
%1065 = add nsw i32 %1064, 1
%1066 = sub nsw i32 10, %1065
%1067 = mul nsw i32 %1061, %1066
%1068 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1069 = load i16, i16* %1068
%1070 = sext i16 %1069 to i32
%1071 = load i8, i8* %17
%1072 = zext i8 %1071 to i32
%1073 = mul nsw i32 2, %1072
%1074 = add nsw i32 %1073, 1
%1075 = mul nsw i32 %1070, %1074
%1076 = add nsw i32 %1067, %1075
%1077 = sdiv i32 %1076, 10
%1078 = trunc i32 %1077 to i8
%1079 = load i8, i8* %17
%1080 = zext i8 %1079 to i64
%1081 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 %1080
store i8 %1078, i8* %1081
br label %1082
1082: ; preds = %1058
%1083 = load i8, i8* %17
%1084 = add i8 %1083, 1
store i8 %1084, i8* %17
br label %1054
1085: ; preds = %1054
store i8 0, i8* %16
br label %1086
1086: ; preds = %1483, %1085
%1087 = load i8, i8* %16
%1088 = zext i8 %1087 to i32
%1089 = load i32, i32* %8
%1090 = icmp slt i32 %1088, %1089
br i1 %1090, label %1091, label %1486
1091: ; preds = %1086
store i8 0, i8* %15
br label %1092
1092: ; preds = %1479, %1091
%1093 = load i8, i8* %15
%1094 = zext i8 %1093 to i32
%1095 = load i32, i32* %7
%1096 = icmp slt i32 %1094, %1095
br i1 %1096, label %1097, label %1482
1097: ; preds = %1092
%1098 = load [4 x i8]*, [4 x i8]** %6
%1099 = load i8, i8* %16
%1100 = zext i8 %1099 to i64
%1101 = getelementptr inbounds [4 x i8], [4 x i8]* %1098, i64 %1100
%1102 = load i8, i8* %15
%1103 = zext i8 %1102 to i64
%1104 = getelementptr inbounds [4 x i8], [4 x i8]* %1101, i64 0, i64 %1103
%1105 = load i8, i8* %1104
%1106 = zext i8 %1105 to i32
%1107 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1108 = load i16, i16* %1107
%1109 = sext i16 %1108 to i32
%1110 = sdiv i32 %1109, 2
%1111 = icmp sle i32 %1106, %1110
br i1 %1111, label %1112, label %1113
1112: ; preds = %1097
br label %1478
1113: ; preds = %1097
%1114 = load [4 x i8]*, [4 x i8]** %6
%1115 = load i8, i8* %16
%1116 = zext i8 %1115 to i64
%1117 = getelementptr inbounds [4 x i8], [4 x i8]* %1114, i64 %1116
%1118 = load i8, i8* %15
%1119 = zext i8 %1118 to i64
%1120 = getelementptr inbounds [4 x i8], [4 x i8]* %1117, i64 0, i64 %1119
%1121 = load i8, i8* %1120
%1122 = zext i8 %1121 to i32
%1123 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1124 = load i16, i16* %1123
%1125 = sext i16 %1124 to i32
%1126 = add nsw i32 255, %1125
%1127 = sdiv i32 %1126, 2
%1128 = icmp sgt i32 %1122, %1127
br i1 %1128, label %1129, label %1130
1129: ; preds = %1113
br label %1477
1130: ; preds = %1113
%1131 = load [4 x i8]*, [4 x i8]** %6
%1132 = load i8, i8* %16
%1133 = zext i8 %1132 to i64
%1134 = getelementptr inbounds [4 x i8], [4 x i8]* %1131, i64 %1133
%1135 = load i8, i8* %15
%1136 = zext i8 %1135 to i64
%1137 = getelementptr inbounds [4 x i8], [4 x i8]* %1134, i64 0, i64 %1136
%1138 = load i8, i8* %1137
%1139 = zext i8 %1138 to i32
%1140 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 0
%1141 = load i8, i8* %1140
%1142 = zext i8 %1141 to i32
%1143 = icmp sle i32 %1139, %1142
br i1 %1143, label %1144, label %1166
1144: ; preds = %1130
%1145 = load [4 x i8]*, [4 x i8]** %6
%1146 = load i8, i8* %16
%1147 = zext i8 %1146 to i64
%1148 = getelementptr inbounds [4 x i8], [4 x i8]* %1145, i64 %1147
%1149 = load i8, i8* %15
%1150 = zext i8 %1149 to i64
%1151 = getelementptr inbounds [4 x i8], [4 x i8]* %1148, i64 0, i64 %1150
%1152 = load i8, i8* %1151
%1153 = zext i8 %1152 to i32
%1154 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1155 = load i16, i16* %1154
%1156 = sext i16 %1155 to i32
%1157 = sub nsw i32 %1153, %1156
%1158 = load i16, i16* %25
%1159 = sext i16 %1158 to i32
%1160 = add nsw i32 %1159, %1157
%1161 = trunc i32 %1160 to i16
store i16 %1161, i16* %25
%1162 = load i8, i8* %27
%1163 = zext i8 %1162 to i32
%1164 = add nsw i32 %1163, 1
%1165 = trunc i32 %1164 to i8
store i8 %1165, i8* %27
br label %1476
1166: ; preds = %1130
%1167 = load [4 x i8]*, [4 x i8]** %6
%1168 = load i8, i8* %16
%1169 = zext i8 %1168 to i64
%1170 = getelementptr inbounds [4 x i8], [4 x i8]* %1167, i64 %1169
%1171 = load i8, i8* %15
%1172 = zext i8 %1171 to i64
%1173 = getelementptr inbounds [4 x i8], [4 x i8]* %1170, i64 0, i64 %1172
%1174 = load i8, i8* %1173
%1175 = zext i8 %1174 to i32
%1176 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 1
%1177 = load i8, i8* %1176
%1178 = zext i8 %1177 to i32
%1179 = icmp sle i32 %1175, %1178
br i1 %1179, label %1180, label %1237
1180: ; preds = %1166
%1181 = load [4 x i8]*, [4 x i8]** %6
%1182 = load i8, i8* %16
%1183 = zext i8 %1182 to i64
%1184 = getelementptr inbounds [4 x i8], [4 x i8]* %1181, i64 %1183
%1185 = load i8, i8* %15
%1186 = zext i8 %1185 to i64
%1187 = getelementptr inbounds [4 x i8], [4 x i8]* %1184, i64 0, i64 %1186
%1188 = load i8, i8* %1187
%1189 = zext i8 %1188 to i32
%1190 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1191 = load i16, i16* %1190
%1192 = sext i16 %1191 to i32
%1193 = mul nsw i32 %1192, 4
%1194 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1195 = load i16, i16* %1194
%1196 = sext i16 %1195 to i32
%1197 = mul nsw i32 %1196, 1
%1198 = add nsw i32 %1193, %1197
%1199 = sdiv i32 %1198, 5
%1200 = sub nsw i32 %1189, %1199
%1201 = load i16, i16* %25
%1202 = sext i16 %1201 to i32
%1203 = add nsw i32 %1202, %1200
%1204 = trunc i32 %1203 to i16
store i16 %1204, i16* %25
%1205 = load [4 x i8]*, [4 x i8]** %6
%1206 = load i8, i8* %16
%1207 = zext i8 %1206 to i64
%1208 = getelementptr inbounds [4 x i8], [4 x i8]* %1205, i64 %1207
%1209 = load i8, i8* %15
%1210 = zext i8 %1209 to i64
%1211 = getelementptr inbounds [4 x i8], [4 x i8]* %1208, i64 0, i64 %1210
%1212 = load i8, i8* %1211
%1213 = zext i8 %1212 to i32
%1214 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1215 = load i16, i16* %1214
%1216 = sext i16 %1215 to i32
%1217 = mul nsw i32 %1216, 4
%1218 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1219 = load i16, i16* %1218
%1220 = sext i16 %1219 to i32
%1221 = mul nsw i32 %1220, 1
%1222 = add nsw i32 %1217, %1221
%1223 = sdiv i32 %1222, 5
%1224 = sub nsw i32 %1213, %1223
%1225 = load i16, i16* %26
%1226 = sext i16 %1225 to i32
%1227 = add nsw i32 %1226, %1224
%1228 = trunc i32 %1227 to i16
store i16 %1228, i16* %26
%1229 = load i8, i8* %27
%1230 = zext i8 %1229 to i32
%1231 = add nsw i32 %1230, 1
%1232 = trunc i32 %1231 to i8
store i8 %1232, i8* %27
%1233 = load i8, i8* %28
%1234 = zext i8 %1233 to i32
%1235 = add nsw i32 %1234, 1
%1236 = trunc i32 %1235 to i8
store i8 %1236, i8* %28
br label %1475
1237: ; preds = %1166
%1238 = load [4 x i8]*, [4 x i8]** %6
%1239 = load i8, i8* %16
%1240 = zext i8 %1239 to i64
%1241 = getelementptr inbounds [4 x i8], [4 x i8]* %1238, i64 %1240
%1242 = load i8, i8* %15
%1243 = zext i8 %1242 to i64
%1244 = getelementptr inbounds [4 x i8], [4 x i8]* %1241, i64 0, i64 %1243
%1245 = load i8, i8* %1244
%1246 = zext i8 %1245 to i32
%1247 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 2
%1248 = load i8, i8* %1247
%1249 = zext i8 %1248 to i32
%1250 = icmp sle i32 %1246, %1249
br i1 %1250, label %1251, label %1308
1251: ; preds = %1237
%1252 = load [4 x i8]*, [4 x i8]** %6
%1253 = load i8, i8* %16
%1254 = zext i8 %1253 to i64
%1255 = getelementptr inbounds [4 x i8], [4 x i8]* %1252, i64 %1254
%1256 = load i8, i8* %15
%1257 = zext i8 %1256 to i64
%1258 = getelementptr inbounds [4 x i8], [4 x i8]* %1255, i64 0, i64 %1257
%1259 = load i8, i8* %1258
%1260 = zext i8 %1259 to i32
%1261 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1262 = load i16, i16* %1261
%1263 = sext i16 %1262 to i32
%1264 = mul nsw i32 %1263, 3
%1265 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1266 = load i16, i16* %1265
%1267 = sext i16 %1266 to i32
%1268 = mul nsw i32 %1267, 2
%1269 = add nsw i32 %1264, %1268
%1270 = sdiv i32 %1269, 5
%1271 = sub nsw i32 %1260, %1270
%1272 = load i16, i16* %25
%1273 = sext i16 %1272 to i32
%1274 = add nsw i32 %1273, %1271
%1275 = trunc i32 %1274 to i16
store i16 %1275, i16* %25
%1276 = load [4 x i8]*, [4 x i8]** %6
%1277 = load i8, i8* %16
%1278 = zext i8 %1277 to i64
%1279 = getelementptr inbounds [4 x i8], [4 x i8]* %1276, i64 %1278
%1280 = load i8, i8* %15
%1281 = zext i8 %1280 to i64
%1282 = getelementptr inbounds [4 x i8], [4 x i8]* %1279, i64 0, i64 %1281
%1283 = load i8, i8* %1282
%1284 = zext i8 %1283 to i32
%1285 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1286 = load i16, i16* %1285
%1287 = sext i16 %1286 to i32
%1288 = mul nsw i32 %1287, 3
%1289 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1290 = load i16, i16* %1289
%1291 = sext i16 %1290 to i32
%1292 = mul nsw i32 %1291, 2
%1293 = add nsw i32 %1288, %1292
%1294 = sdiv i32 %1293, 5
%1295 = sub nsw i32 %1284, %1294
%1296 = load i16, i16* %26
%1297 = sext i16 %1296 to i32
%1298 = add nsw i32 %1297, %1295
%1299 = trunc i32 %1298 to i16
store i16 %1299, i16* %26
%1300 = load i8, i8* %27
%1301 = zext i8 %1300 to i32
%1302 = add nsw i32 %1301, 1
%1303 = trunc i32 %1302 to i8
store i8 %1303, i8* %27
%1304 = load i8, i8* %28
%1305 = zext i8 %1304 to i32
%1306 = add nsw i32 %1305, 1
%1307 = trunc i32 %1306 to i8
store i8 %1307, i8* %28
br label %1474
1308: ; preds = %1237
%1309 = load [4 x i8]*, [4 x i8]** %6
%1310 = load i8, i8* %16
%1311 = zext i8 %1310 to i64
%1312 = getelementptr inbounds [4 x i8], [4 x i8]* %1309, i64 %1311
%1313 = load i8, i8* %15
%1314 = zext i8 %1313 to i64
%1315 = getelementptr inbounds [4 x i8], [4 x i8]* %1312, i64 0, i64 %1314
%1316 = load i8, i8* %1315
%1317 = zext i8 %1316 to i32
%1318 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 3
%1319 = load i8, i8* %1318
%1320 = zext i8 %1319 to i32
%1321 = icmp sle i32 %1317, %1320
br i1 %1321, label %1322, label %1379
1322: ; preds = %1308
%1323 = load [4 x i8]*, [4 x i8]** %6
%1324 = load i8, i8* %16
%1325 = zext i8 %1324 to i64
%1326 = getelementptr inbounds [4 x i8], [4 x i8]* %1323, i64 %1325
%1327 = load i8, i8* %15
%1328 = zext i8 %1327 to i64
%1329 = getelementptr inbounds [4 x i8], [4 x i8]* %1326, i64 0, i64 %1328
%1330 = load i8, i8* %1329
%1331 = zext i8 %1330 to i32
%1332 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1333 = load i16, i16* %1332
%1334 = sext i16 %1333 to i32
%1335 = mul nsw i32 %1334, 2
%1336 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1337 = load i16, i16* %1336
%1338 = sext i16 %1337 to i32
%1339 = mul nsw i32 %1338, 3
%1340 = add nsw i32 %1335, %1339
%1341 = sdiv i32 %1340, 5
%1342 = sub nsw i32 %1331, %1341
%1343 = load i16, i16* %25
%1344 = sext i16 %1343 to i32
%1345 = add nsw i32 %1344, %1342
%1346 = trunc i32 %1345 to i16
store i16 %1346, i16* %25
%1347 = load [4 x i8]*, [4 x i8]** %6
%1348 = load i8, i8* %16
%1349 = zext i8 %1348 to i64
%1350 = getelementptr inbounds [4 x i8], [4 x i8]* %1347, i64 %1349
%1351 = load i8, i8* %15
%1352 = zext i8 %1351 to i64
%1353 = getelementptr inbounds [4 x i8], [4 x i8]* %1350, i64 0, i64 %1352
%1354 = load i8, i8* %1353
%1355 = zext i8 %1354 to i32
%1356 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1357 = load i16, i16* %1356
%1358 = sext i16 %1357 to i32
%1359 = mul nsw i32 %1358, 2
%1360 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1361 = load i16, i16* %1360
%1362 = sext i16 %1361 to i32
%1363 = mul nsw i32 %1362, 3
%1364 = add nsw i32 %1359, %1363
%1365 = sdiv i32 %1364, 5
%1366 = sub nsw i32 %1355, %1365
%1367 = load i16, i16* %26
%1368 = sext i16 %1367 to i32
%1369 = add nsw i32 %1368, %1366
%1370 = trunc i32 %1369 to i16
store i16 %1370, i16* %26
%1371 = load i8, i8* %27
%1372 = zext i8 %1371 to i32
%1373 = add nsw i32 %1372, 1
%1374 = trunc i32 %1373 to i8
store i8 %1374, i8* %27
%1375 = load i8, i8* %28
%1376 = zext i8 %1375 to i32
%1377 = add nsw i32 %1376, 1
%1378 = trunc i32 %1377 to i8
store i8 %1378, i8* %28
br label %1473
1379: ; preds = %1308
%1380 = load [4 x i8]*, [4 x i8]** %6
%1381 = load i8, i8* %16
%1382 = zext i8 %1381 to i64
%1383 = getelementptr inbounds [4 x i8], [4 x i8]* %1380, i64 %1382
%1384 = load i8, i8* %15
%1385 = zext i8 %1384 to i64
%1386 = getelementptr inbounds [4 x i8], [4 x i8]* %1383, i64 0, i64 %1385
%1387 = load i8, i8* %1386
%1388 = zext i8 %1387 to i32
%1389 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 4
%1390 = load i8, i8* %1389
%1391 = zext i8 %1390 to i32
%1392 = icmp sle i32 %1388, %1391
br i1 %1392, label %1393, label %1450
1393: ; preds = %1379
%1394 = load [4 x i8]*, [4 x i8]** %6
%1395 = load i8, i8* %16
%1396 = zext i8 %1395 to i64
%1397 = getelementptr inbounds [4 x i8], [4 x i8]* %1394, i64 %1396
%1398 = load i8, i8* %15
%1399 = zext i8 %1398 to i64
%1400 = getelementptr inbounds [4 x i8], [4 x i8]* %1397, i64 0, i64 %1399
%1401 = load i8, i8* %1400
%1402 = zext i8 %1401 to i32
%1403 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1404 = load i16, i16* %1403
%1405 = sext i16 %1404 to i32
%1406 = mul nsw i32 %1405, 1
%1407 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1408 = load i16, i16* %1407
%1409 = sext i16 %1408 to i32
%1410 = mul nsw i32 %1409, 4
%1411 = add nsw i32 %1406, %1410
%1412 = sdiv i32 %1411, 5
%1413 = sub nsw i32 %1402, %1412
%1414 = load i16, i16* %25
%1415 = sext i16 %1414 to i32
%1416 = add nsw i32 %1415, %1413
%1417 = trunc i32 %1416 to i16
store i16 %1417, i16* %25
%1418 = load [4 x i8]*, [4 x i8]** %6
%1419 = load i8, i8* %16
%1420 = zext i8 %1419 to i64
%1421 = getelementptr inbounds [4 x i8], [4 x i8]* %1418, i64 %1420
%1422 = load i8, i8* %15
%1423 = zext i8 %1422 to i64
%1424 = getelementptr inbounds [4 x i8], [4 x i8]* %1421, i64 0, i64 %1423
%1425 = load i8, i8* %1424
%1426 = zext i8 %1425 to i32
%1427 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1428 = load i16, i16* %1427
%1429 = sext i16 %1428 to i32
%1430 = mul nsw i32 %1429, 1
%1431 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1432 = load i16, i16* %1431
%1433 = sext i16 %1432 to i32
%1434 = mul nsw i32 %1433, 4
%1435 = add nsw i32 %1430, %1434
%1436 = sdiv i32 %1435, 5
%1437 = sub nsw i32 %1426, %1436
%1438 = load i16, i16* %26
%1439 = sext i16 %1438 to i32
%1440 = add nsw i32 %1439, %1437
%1441 = trunc i32 %1440 to i16
store i16 %1441, i16* %26
%1442 = load i8, i8* %27
%1443 = zext i8 %1442 to i32
%1444 = add nsw i32 %1443, 1
%1445 = trunc i32 %1444 to i8
store i8 %1445, i8* %27
%1446 = load i8, i8* %28
%1447 = zext i8 %1446 to i32
%1448 = add nsw i32 %1447, 1
%1449 = trunc i32 %1448 to i8
store i8 %1449, i8* %28
br label %1472
1450: ; preds = %1379
%1451 = load [4 x i8]*, [4 x i8]** %6
%1452 = load i8, i8* %16
%1453 = zext i8 %1452 to i64
%1454 = getelementptr inbounds [4 x i8], [4 x i8]* %1451, i64 %1453
%1455 = load i8, i8* %15
%1456 = zext i8 %1455 to i64
%1457 = getelementptr inbounds [4 x i8], [4 x i8]* %1454, i64 0, i64 %1456
%1458 = load i8, i8* %1457
%1459 = zext i8 %1458 to i32
%1460 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1461 = load i16, i16* %1460
%1462 = sext i16 %1461 to i32
%1463 = sub nsw i32 %1459, %1462
%1464 = load i16, i16* %26
%1465 = sext i16 %1464 to i32
%1466 = add nsw i32 %1465, %1463
%1467 = trunc i32 %1466 to i16
store i16 %1467, i16* %26
%1468 = load i8, i8* %28
%1469 = zext i8 %1468 to i32
%1470 = add nsw i32 %1469, 1
%1471 = trunc i32 %1470 to i8
store i8 %1471, i8* %28
br label %1472
1472: ; preds = %1450, %1393
br label %1473
1473: ; preds = %1472, %1322
br label %1474
1474: ; preds = %1473, %1251
br label %1475
1475: ; preds = %1474, %1180
br label %1476
1476: ; preds = %1475, %1144
br label %1477
1477: ; preds = %1476, %1129
br label %1478
1478: ; preds = %1477, %1112
br label %1479
1479: ; preds = %1478
%1480 = load i8, i8* %15
%1481 = add i8 %1480, 1
store i8 %1481, i8* %15
br label %1092
1482: ; preds = %1092
br label %1483
1483: ; preds = %1482
%1484 = load i8, i8* %16
%1485 = add i8 %1484, 1
store i8 %1485, i8* %16
br label %1086
1486: ; preds = %1086
%1487 = load i8, i8* %27
%1488 = zext i8 %1487 to i32
%1489 = icmp eq i32 %1488, 0
br i1 %1489, label %1490, label %1491
1490: ; preds = %1486
store i8 1, i8* %27
br label %1491
1491: ; preds = %1490, %1486
%1492 = load i8, i8* %28
%1493 = zext i8 %1492 to i32
%1494 = icmp eq i32 %1493, 0
br i1 %1494, label %1495, label %1496
1495: ; preds = %1491
store i8 1, i8* %28
br label %1496
1496: ; preds = %1495, %1491
%1497 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1498 = load i16, i16* %1497
%1499 = sext i16 %1498 to i32
%1500 = load i16, i16* %25
%1501 = sext i16 %1500 to i32
%1502 = load i8, i8* %27
%1503 = zext i8 %1502 to i32
%1504 = sdiv i32 %1501, %1503
%1505 = add nsw i32 %1499, %1504
%1506 = trunc i32 %1505 to i16
%1507 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
store i16 %1506, i16* %1507
%1508 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1509 = load i16, i16* %1508
%1510 = sext i16 %1509 to i32
%1511 = icmp slt i32 %1510, 0
br i1 %1511, label %1512, label %1514
1512: ; preds = %1496
%1513 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
store i16 0, i16* %1513
br label %1514
1514: ; preds = %1512, %1496
%1515 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1516 = load i16, i16* %1515
%1517 = sext i16 %1516 to i32
%1518 = load i16, i16* %26
%1519 = sext i16 %1518 to i32
%1520 = load i8, i8* %28
%1521 = zext i8 %1520 to i32
%1522 = sdiv i32 %1519, %1521
%1523 = add nsw i32 %1517, %1522
%1524 = trunc i32 %1523 to i16
%1525 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
store i16 %1524, i16* %1525
%1526 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1527 = load i16, i16* %1526
%1528 = sext i16 %1527 to i32
%1529 = icmp sgt i32 %1528, 255
br i1 %1529, label %1530, label %1532
1530: ; preds = %1514
%1531 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
store i16 255, i16* %1531
br label %1532
1532: ; preds = %1530, %1514
store i32 0, i32* %14
store i8 0, i8* %17
br label %1533
1533: ; preds = %1561, %1532
%1534 = load i8, i8* %17
%1535 = zext i8 %1534 to i32
%1536 = icmp slt i32 %1535, 5
br i1 %1536, label %1537, label %1564
1537: ; preds = %1533
%1538 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1539 = load i16, i16* %1538
%1540 = sext i16 %1539 to i32
%1541 = load i8, i8* %17
%1542 = zext i8 %1541 to i32
%1543 = mul nsw i32 2, %1542
%1544 = add nsw i32 %1543, 1
%1545 = sub nsw i32 10, %1544
%1546 = mul nsw i32 %1540, %1545
%1547 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1548 = load i16, i16* %1547
%1549 = sext i16 %1548 to i32
%1550 = load i8, i8* %17
%1551 = zext i8 %1550 to i32
%1552 = mul nsw i32 2, %1551
%1553 = add nsw i32 %1552, 1
%1554 = mul nsw i32 %1549, %1553
%1555 = add nsw i32 %1546, %1554
%1556 = sdiv i32 %1555, 10
%1557 = trunc i32 %1556 to i8
%1558 = load i8, i8* %17
%1559 = zext i8 %1558 to i64
%1560 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 %1559
store i8 %1557, i8* %1560
br label %1561
1561: ; preds = %1537
%1562 = load i8, i8* %17
%1563 = add i8 %1562, 1
store i8 %1563, i8* %17
br label %1533
1564: ; preds = %1533
store i8 0, i8* %16
br label %1565
1565: ; preds = %1899, %1564
%1566 = load i8, i8* %16
%1567 = zext i8 %1566 to i32
%1568 = load i32, i32* %8
%1569 = icmp slt i32 %1567, %1568
br i1 %1569, label %1570, label %1902
1570: ; preds = %1565
store i8 0, i8* %15
br label %1571
1571: ; preds = %1895, %1570
%1572 = load i8, i8* %15
%1573 = zext i8 %1572 to i32
%1574 = load i32, i32* %7
%1575 = icmp slt i32 %1573, %1574
br i1 %1575, label %1576, label %1898
1576: ; preds = %1571
%1577 = load [4 x i8]*, [4 x i8]** %6
%1578 = load i8, i8* %16
%1579 = zext i8 %1578 to i64
%1580 = getelementptr inbounds [4 x i8], [4 x i8]* %1577, i64 %1579
%1581 = load i8, i8* %15
%1582 = zext i8 %1581 to i64
%1583 = getelementptr inbounds [4 x i8], [4 x i8]* %1580, i64 0, i64 %1582
%1584 = load i8, i8* %1583
%1585 = zext i8 %1584 to i32
%1586 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1587 = load i16, i16* %1586
%1588 = sext i16 %1587 to i32
%1589 = sdiv i32 %1588, 2
%1590 = icmp sle i32 %1585, %1589
br i1 %1590, label %1591, label %1609
1591: ; preds = %1576
%1592 = load i8, i8* %16
%1593 = zext i8 %1592 to i32
%1594 = mul nsw i32 4, %1593
%1595 = load i8, i8* %15
%1596 = zext i8 %1595 to i32
%1597 = add nsw i32 %1594, %1596
%1598 = sext i32 %1597 to i64
%1599 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %1598
store i8 6, i8* %1599
%1600 = load [4 x i8]*, [4 x i8]** %6
%1601 = load i8, i8* %16
%1602 = zext i8 %1601 to i64
%1603 = getelementptr inbounds [4 x i8], [4 x i8]* %1600, i64 %1602
%1604 = load i8, i8* %15
%1605 = zext i8 %1604 to i64
%1606 = getelementptr inbounds [4 x i8], [4 x i8]* %1603, i64 0, i64 %1605
%1607 = load i8, i8* %1606
%1608 = zext i8 %1607 to i16
store i16 %1608, i16* %24
br label %1887
1609: ; preds = %1576
%1610 = load [4 x i8]*, [4 x i8]** %6
%1611 = load i8, i8* %16
%1612 = zext i8 %1611 to i64
%1613 = getelementptr inbounds [4 x i8], [4 x i8]* %1610, i64 %1612
%1614 = load i8, i8* %15
%1615 = zext i8 %1614 to i64
%1616 = getelementptr inbounds [4 x i8], [4 x i8]* %1613, i64 0, i64 %1615
%1617 = load i8, i8* %1616
%1618 = zext i8 %1617 to i32
%1619 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1620 = load i16, i16* %1619
%1621 = sext i16 %1620 to i32
%1622 = add nsw i32 255, %1621
%1623 = sdiv i32 %1622, 2
%1624 = icmp sgt i32 %1618, %1623
br i1 %1624, label %1625, label %1645
1625: ; preds = %1609
%1626 = load i8, i8* %16
%1627 = zext i8 %1626 to i32
%1628 = mul nsw i32 4, %1627
%1629 = load i8, i8* %15
%1630 = zext i8 %1629 to i32
%1631 = add nsw i32 %1628, %1630
%1632 = sext i32 %1631 to i64
%1633 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %1632
store i8 7, i8* %1633
%1634 = load [4 x i8]*, [4 x i8]** %6
%1635 = load i8, i8* %16
%1636 = zext i8 %1635 to i64
%1637 = getelementptr inbounds [4 x i8], [4 x i8]* %1634, i64 %1636
%1638 = load i8, i8* %15
%1639 = zext i8 %1638 to i64
%1640 = getelementptr inbounds [4 x i8], [4 x i8]* %1637, i64 0, i64 %1639
%1641 = load i8, i8* %1640
%1642 = zext i8 %1641 to i32
%1643 = sub nsw i32 255, %1642
%1644 = trunc i32 %1643 to i16
store i16 %1644, i16* %24
br label %1886
1645: ; preds = %1609
%1646 = load [4 x i8]*, [4 x i8]** %6
%1647 = load i8, i8* %16
%1648 = zext i8 %1647 to i64
%1649 = getelementptr inbounds [4 x i8], [4 x i8]* %1646, i64 %1648
%1650 = load i8, i8* %15
%1651 = zext i8 %1650 to i64
%1652 = getelementptr inbounds [4 x i8], [4 x i8]* %1649, i64 0, i64 %1651
%1653 = load i8, i8* %1652
%1654 = zext i8 %1653 to i32
%1655 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 0
%1656 = load i8, i8* %1655
%1657 = zext i8 %1656 to i32
%1658 = icmp sle i32 %1654, %1657
br i1 %1658, label %1659, label %1682
1659: ; preds = %1645
%1660 = load i8, i8* %16
%1661 = zext i8 %1660 to i32
%1662 = mul nsw i32 4, %1661
%1663 = load i8, i8* %15
%1664 = zext i8 %1663 to i32
%1665 = add nsw i32 %1662, %1664
%1666 = sext i32 %1665 to i64
%1667 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %1666
store i8 0, i8* %1667
%1668 = load [4 x i8]*, [4 x i8]** %6
%1669 = load i8, i8* %16
%1670 = zext i8 %1669 to i64
%1671 = getelementptr inbounds [4 x i8], [4 x i8]* %1668, i64 %1670
%1672 = load i8, i8* %15
%1673 = zext i8 %1672 to i64
%1674 = getelementptr inbounds [4 x i8], [4 x i8]* %1671, i64 0, i64 %1673
%1675 = load i8, i8* %1674
%1676 = zext i8 %1675 to i32
%1677 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1678 = load i16, i16* %1677
%1679 = sext i16 %1678 to i32
%1680 = sub nsw i32 %1676, %1679
%1681 = trunc i32 %1680 to i16
store i16 %1681, i16* %24
br label %1885
1682: ; preds = %1645
%1683 = load [4 x i8]*, [4 x i8]** %6
%1684 = load i8, i8* %16
%1685 = zext i8 %1684 to i64
%1686 = getelementptr inbounds [4 x i8], [4 x i8]* %1683, i64 %1685
%1687 = load i8, i8* %15
%1688 = zext i8 %1687 to i64
%1689 = getelementptr inbounds [4 x i8], [4 x i8]* %1686, i64 0, i64 %1688
%1690 = load i8, i8* %1689
%1691 = zext i8 %1690 to i32
%1692 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 1
%1693 = load i8, i8* %1692
%1694 = zext i8 %1693 to i32
%1695 = icmp sle i32 %1691, %1694
br i1 %1695, label %1696, label %1726
1696: ; preds = %1682
%1697 = load i8, i8* %16
%1698 = zext i8 %1697 to i32
%1699 = mul nsw i32 4, %1698
%1700 = load i8, i8* %15
%1701 = zext i8 %1700 to i32
%1702 = add nsw i32 %1699, %1701
%1703 = sext i32 %1702 to i64
%1704 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %1703
store i8 2, i8* %1704
%1705 = load [4 x i8]*, [4 x i8]** %6
%1706 = load i8, i8* %16
%1707 = zext i8 %1706 to i64
%1708 = getelementptr inbounds [4 x i8], [4 x i8]* %1705, i64 %1707
%1709 = load i8, i8* %15
%1710 = zext i8 %1709 to i64
%1711 = getelementptr inbounds [4 x i8], [4 x i8]* %1708, i64 0, i64 %1710
%1712 = load i8, i8* %1711
%1713 = zext i8 %1712 to i32
%1714 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1715 = load i16, i16* %1714
%1716 = sext i16 %1715 to i32
%1717 = mul nsw i32 %1716, 4
%1718 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1719 = load i16, i16* %1718
%1720 = sext i16 %1719 to i32
%1721 = mul nsw i32 %1720, 1
%1722 = add nsw i32 %1717, %1721
%1723 = sdiv i32 %1722, 5
%1724 = sub nsw i32 %1713, %1723
%1725 = trunc i32 %1724 to i16
store i16 %1725, i16* %24
br label %1884
1726: ; preds = %1682
%1727 = load [4 x i8]*, [4 x i8]** %6
%1728 = load i8, i8* %16
%1729 = zext i8 %1728 to i64
%1730 = getelementptr inbounds [4 x i8], [4 x i8]* %1727, i64 %1729
%1731 = load i8, i8* %15
%1732 = zext i8 %1731 to i64
%1733 = getelementptr inbounds [4 x i8], [4 x i8]* %1730, i64 0, i64 %1732
%1734 = load i8, i8* %1733
%1735 = zext i8 %1734 to i32
%1736 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 2
%1737 = load i8, i8* %1736
%1738 = zext i8 %1737 to i32
%1739 = icmp sle i32 %1735, %1738
br i1 %1739, label %1740, label %1770
1740: ; preds = %1726
%1741 = load i8, i8* %16
%1742 = zext i8 %1741 to i32
%1743 = mul nsw i32 4, %1742
%1744 = load i8, i8* %15
%1745 = zext i8 %1744 to i32
%1746 = add nsw i32 %1743, %1745
%1747 = sext i32 %1746 to i64
%1748 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %1747
store i8 3, i8* %1748
%1749 = load [4 x i8]*, [4 x i8]** %6
%1750 = load i8, i8* %16
%1751 = zext i8 %1750 to i64
%1752 = getelementptr inbounds [4 x i8], [4 x i8]* %1749, i64 %1751
%1753 = load i8, i8* %15
%1754 = zext i8 %1753 to i64
%1755 = getelementptr inbounds [4 x i8], [4 x i8]* %1752, i64 0, i64 %1754
%1756 = load i8, i8* %1755
%1757 = zext i8 %1756 to i32
%1758 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1759 = load i16, i16* %1758
%1760 = sext i16 %1759 to i32
%1761 = mul nsw i32 %1760, 3
%1762 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1763 = load i16, i16* %1762
%1764 = sext i16 %1763 to i32
%1765 = mul nsw i32 %1764, 2
%1766 = add nsw i32 %1761, %1765
%1767 = sdiv i32 %1766, 5
%1768 = sub nsw i32 %1757, %1767
%1769 = trunc i32 %1768 to i16
store i16 %1769, i16* %24
br label %1883
1770: ; preds = %1726
%1771 = load [4 x i8]*, [4 x i8]** %6
%1772 = load i8, i8* %16
%1773 = zext i8 %1772 to i64
%1774 = getelementptr inbounds [4 x i8], [4 x i8]* %1771, i64 %1773
%1775 = load i8, i8* %15
%1776 = zext i8 %1775 to i64
%1777 = getelementptr inbounds [4 x i8], [4 x i8]* %1774, i64 0, i64 %1776
%1778 = load i8, i8* %1777
%1779 = zext i8 %1778 to i32
%1780 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 3
%1781 = load i8, i8* %1780
%1782 = zext i8 %1781 to i32
%1783 = icmp sle i32 %1779, %1782
br i1 %1783, label %1784, label %1814
1784: ; preds = %1770
%1785 = load i8, i8* %16
%1786 = zext i8 %1785 to i32
%1787 = mul nsw i32 4, %1786
%1788 = load i8, i8* %15
%1789 = zext i8 %1788 to i32
%1790 = add nsw i32 %1787, %1789
%1791 = sext i32 %1790 to i64
%1792 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %1791
store i8 4, i8* %1792
%1793 = load [4 x i8]*, [4 x i8]** %6
%1794 = load i8, i8* %16
%1795 = zext i8 %1794 to i64
%1796 = getelementptr inbounds [4 x i8], [4 x i8]* %1793, i64 %1795
%1797 = load i8, i8* %15
%1798 = zext i8 %1797 to i64
%1799 = getelementptr inbounds [4 x i8], [4 x i8]* %1796, i64 0, i64 %1798
%1800 = load i8, i8* %1799
%1801 = zext i8 %1800 to i32
%1802 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1803 = load i16, i16* %1802
%1804 = sext i16 %1803 to i32
%1805 = mul nsw i32 %1804, 2
%1806 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1807 = load i16, i16* %1806
%1808 = sext i16 %1807 to i32
%1809 = mul nsw i32 %1808, 3
%1810 = add nsw i32 %1805, %1809
%1811 = sdiv i32 %1810, 5
%1812 = sub nsw i32 %1801, %1811
%1813 = trunc i32 %1812 to i16
store i16 %1813, i16* %24
br label %1882
1814: ; preds = %1770
%1815 = load [4 x i8]*, [4 x i8]** %6
%1816 = load i8, i8* %16
%1817 = zext i8 %1816 to i64
%1818 = getelementptr inbounds [4 x i8], [4 x i8]* %1815, i64 %1817
%1819 = load i8, i8* %15
%1820 = zext i8 %1819 to i64
%1821 = getelementptr inbounds [4 x i8], [4 x i8]* %1818, i64 0, i64 %1820
%1822 = load i8, i8* %1821
%1823 = zext i8 %1822 to i32
%1824 = getelementptr inbounds [7 x i8], [7 x i8]* %18, i64 0, i64 4
%1825 = load i8, i8* %1824
%1826 = zext i8 %1825 to i32
%1827 = icmp sle i32 %1823, %1826
br i1 %1827, label %1828, label %1858
1828: ; preds = %1814
%1829 = load i8, i8* %16
%1830 = zext i8 %1829 to i32
%1831 = mul nsw i32 4, %1830
%1832 = load i8, i8* %15
%1833 = zext i8 %1832 to i32
%1834 = add nsw i32 %1831, %1833
%1835 = sext i32 %1834 to i64
%1836 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %1835
store i8 5, i8* %1836
%1837 = load [4 x i8]*, [4 x i8]** %6
%1838 = load i8, i8* %16
%1839 = zext i8 %1838 to i64
%1840 = getelementptr inbounds [4 x i8], [4 x i8]* %1837, i64 %1839
%1841 = load i8, i8* %15
%1842 = zext i8 %1841 to i64
%1843 = getelementptr inbounds [4 x i8], [4 x i8]* %1840, i64 0, i64 %1842
%1844 = load i8, i8* %1843
%1845 = zext i8 %1844 to i32
%1846 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1847 = load i16, i16* %1846
%1848 = sext i16 %1847 to i32
%1849 = mul nsw i32 %1848, 1
%1850 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1851 = load i16, i16* %1850
%1852 = sext i16 %1851 to i32
%1853 = mul nsw i32 %1852, 4
%1854 = add nsw i32 %1849, %1853
%1855 = sdiv i32 %1854, 5
%1856 = sub nsw i32 %1845, %1855
%1857 = trunc i32 %1856 to i16
store i16 %1857, i16* %24
br label %1881
1858: ; preds = %1814
%1859 = load i8, i8* %16
%1860 = zext i8 %1859 to i32
%1861 = mul nsw i32 4, %1860
%1862 = load i8, i8* %15
%1863 = zext i8 %1862 to i32
%1864 = add nsw i32 %1861, %1863
%1865 = sext i32 %1864 to i64
%1866 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %1865
store i8 1, i8* %1866
%1867 = load [4 x i8]*, [4 x i8]** %6
%1868 = load i8, i8* %16
%1869 = zext i8 %1868 to i64
%1870 = getelementptr inbounds [4 x i8], [4 x i8]* %1867, i64 %1869
%1871 = load i8, i8* %15
%1872 = zext i8 %1871 to i64
%1873 = getelementptr inbounds [4 x i8], [4 x i8]* %1870, i64 0, i64 %1872
%1874 = load i8, i8* %1873
%1875 = zext i8 %1874 to i32
%1876 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1877 = load i16, i16* %1876
%1878 = sext i16 %1877 to i32
%1879 = sub nsw i32 %1875, %1878
%1880 = trunc i32 %1879 to i16
store i16 %1880, i16* %24
br label %1881
1881: ; preds = %1858, %1828
br label %1882
1882: ; preds = %1881, %1784
br label %1883
1883: ; preds = %1882, %1740
br label %1884
1884: ; preds = %1883, %1696
br label %1885
1885: ; preds = %1884, %1659
br label %1886
1886: ; preds = %1885, %1625
br label %1887
1887: ; preds = %1886, %1591
%1888 = load i16, i16* %24
%1889 = sext i16 %1888 to i32
%1890 = load i16, i16* %24
%1891 = sext i16 %1890 to i32
%1892 = mul nsw i32 %1889, %1891
%1893 = load i32, i32* %14
%1894 = add i32 %1893, %1892
store i32 %1894, i32* %14
br label %1895
1895: ; preds = %1887
%1896 = load i8, i8* %15
%1897 = add i8 %1896, 1
store i8 %1897, i8* %15
br label %1571
1898: ; preds = %1571
br label %1899
1899: ; preds = %1898
%1900 = load i8, i8* %16
%1901 = add i8 %1900, 1
store i8 %1901, i8* %16
br label %1565
1902: ; preds = %1565
br label %1903
1903: ; preds = %1902, %928, %925
br label %1904
1904: ; preds = %1903, %581
%1905 = load i32, i32* %12
%1906 = load i32, i32* %13
%1907 = icmp ule i32 %1905, %1906
br i1 %1907, label %1908, label %1922
1908: ; preds = %1904
%1909 = load i32, i32* %12
%1910 = load i32, i32* %14
%1911 = icmp ule i32 %1909, %1910
br i1 %1911, label %1912, label %1922
1912: ; preds = %1908
%1913 = load i8*, i8** %5
%1914 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 1
%1915 = load i8, i8* %1914
%1916 = zext i8 %1915 to i32
%1917 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%1918 = load i8, i8* %1917
%1919 = zext i8 %1918 to i32
%1920 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 0
%1921 = call i32 (i8*, i32, i32, i8*, ...) bitcast (i32 (...)* @util_format_unsigned_write_rgtc_encoded_channel to i32 (i8*, i32, i32, i8*, ...)*)(i8* %1913, i32 %1916, i32 %1919, i8* %1920)
br label %1949
1922: ; preds = %1908, %1904
%1923 = load i32, i32* %13
%1924 = load i32, i32* %14
%1925 = icmp ule i32 %1923, %1924
br i1 %1925, label %1926, label %1936
1926: ; preds = %1922
%1927 = load i8*, i8** %5
%1928 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 0
%1929 = load i8, i8* %1928
%1930 = zext i8 %1929 to i32
%1931 = getelementptr inbounds [2 x i8], [2 x i8]* %9, i64 0, i64 1
%1932 = load i8, i8* %1931
%1933 = zext i8 %1932 to i32
%1934 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 0
%1935 = call i32 (i8*, i32, i32, i8*, ...) bitcast (i32 (...)* @util_format_unsigned_write_rgtc_encoded_channel to i32 (i8*, i32, i32, i8*, ...)*)(i8* %1927, i32 %1930, i32 %1933, i8* %1934)
br label %1948
1936: ; preds = %1922
%1937 = load i8*, i8** %5
%1938 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 0
%1939 = load i16, i16* %1938
%1940 = trunc i16 %1939 to i8
%1941 = zext i8 %1940 to i32
%1942 = getelementptr inbounds [2 x i16], [2 x i16]* %11, i64 0, i64 1
%1943 = load i16, i16* %1942
%1944 = trunc i16 %1943 to i8
%1945 = zext i8 %1944 to i32
%1946 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 0
%1947 = call i32 (i8*, i32, i32, i8*, ...) bitcast (i32 (...)* @util_format_unsigned_write_rgtc_encoded_channel to i32 (i8*, i32, i32, i8*, ...)*)(i8* %1937, i32 %1941, i32 %1945, i8* %1946)
br label %1948
1948: ; preds = %1936, %1926
br label %1949
1949: ; preds = %153, %1948, %1912
ret void
}

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