#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ sprintf(char *, char *, ...);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
int /*<<< orphan*/ strncpy(char *, char *, int);
void sg_get_sense_descriptors_str(const unsigned char *sense_buffer, int sb_len,
                                  int buff_len, char *buff) {
  int add_sen_len, add_len, desc_len, k, j, sense_key, processed;
  int n, progress;
  const unsigned char *descp;
  char b[256];
  if ((NULL == buff) || (buff_len <= 0))
    return;
  buff[0] = '\0';
  if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7])))
    return;
  add_sen_len = (add_sen_len < (sb_len - 8)) ? add_sen_len : (sb_len - 8);
  descp = &sense_buffer[8];
  sense_key = (sense_buffer[1] & 0xf);
  for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) {
    descp += desc_len;
    add_len = (k < (add_sen_len - 1)) ? descp[1] : -1;
    desc_len = add_len + 2;
    n = 0;
    n += sprintf(b + n, "  Descriptor type: ");
    processed = 1;
    switch (descp[0]) {
    case 0:
      n += sprintf(b + n, "Information\n");
      if ((add_len >= 10) && (0x80 & descp[2])) {
        n += sprintf(b + n, "    0x");
        for (j = 0; j < 8; ++j)
          n += sprintf(b + n, "%02x", descp[4 + j]);
        n += sprintf(b + n, "\n");
      } else
        processed = 0;
      break;
    case 1:
      n += sprintf(b + n, "Command specific\n");
      if (add_len >= 10) {
        n += sprintf(b + n, "    0x");
        for (j = 0; j < 8; ++j)
          n += sprintf(b + n, "%02x", descp[4 + j]);
        n += sprintf(b + n, "\n");
      } else
        processed = 0;
      break;
    case 2:
      n += sprintf(b + n, "Sense key specific:");
      switch (sense_key) {
      case 0x5:
        n += sprintf(b + n, " Field pointer\n");
        if (add_len < 6) {
          processed = 0;
          break;
        }
        n += sprintf(b + n, "    Error in %s byte %d",
                     (descp[4] & 0x40) ? "Command" : "Data",
                     (descp[5] << 8) | descp[6]);
        if (descp[4] & 0x08) {
          n += sprintf(b + n, " bit %d\n", descp[4] & 0x07);
        } else
          n += sprintf(b + n, "\n");
        break;
      case 0x4:
      case 0x3:
      case 0x1:
        n += sprintf(b + n, " Actual retry count\n");
        if (add_len < 6) {
          processed = 0;
          break;
        }
        n += sprintf(b + n, "    0x%02x%02x\n", descp[5], descp[6]);
        break;
      case 0x0:
      case 0x2:
        n += sprintf(b + n, " Progress indication: ");
        if (add_len < 6) {
          processed = 0;
          n += sprintf(b + n, " field too short\n");
          break;
        }
        progress = (descp[5] << 8) + descp[6];
        n += sprintf(b + n, "%d %%\n", (progress * 100) / 0x10000);
        break;
      case 0xa:
        n += sprintf(b + n, " Segment pointer\n");
        if (add_len < 6) {
          processed = 0;
          break;
        }
        n +=
            sprintf(b + n, " Relative to start of %s, byte %d",
                    (descp[4] & 0x20) ? "segment descriptor" : "parameter list",
                    (descp[5] << 8) | descp[6]);
        if (descp[4] & 0x08)
          n += sprintf(b + n, " bit %d\n", descp[4] & 0x07);
        else
          n += sprintf(b + n, "\n");
        break;
      case 0x6:
        n += sprintf(b + n, " Unit attention condition queue: ");
        n += sprintf(b + n, "overflow flag is %d\n", !!(descp[4] & 0x1));
        break;
      default:
        n += sprintf(b + n, " Sense_key: 0x%x unexpected\n", sense_key);
        processed = 0;
        break;
      }
      break;
    case 3:
      n += sprintf(b + n, "Field replaceable unit\n");
      if (add_len >= 2)
        n += sprintf(b + n, "    code=0x%x\n", descp[3]);
      else
        processed = 0;
      break;
    case 4:
      n += sprintf(b + n, "Stream commands\n");
      if (add_len >= 2) {
        if (descp[3] & 0x80)
          n += sprintf(b + n, "    FILEMARK");
        if (descp[3] & 0x40)
          n += sprintf(b + n, "    End Of Medium (EOM)");
        if (descp[3] & 0x20)
          n += sprintf(b + n, "    Incorrect Length Indicator "
                              "(ILI)");
        n += sprintf(b + n, "\n");
      } else
        processed = 0;
      break;
    case 5:
      n += sprintf(b + n, "Block commands\n");
      if (add_len >= 2)
        n += sprintf(b + n,
                     "    Incorrect Length Indicator "
                     "(ILI) %s\n",
                     (descp[3] & 0x20) ? "set" : "clear");
      else
        processed = 0;
      break;
    case 6:
      n += sprintf(b + n, "OSD object identification\n");
      processed = 0;
      break;
    case 7:
      n += sprintf(b + n, "OSD response integrity check value\n");
      processed = 0;
      break;
    case 8:
      n += sprintf(b + n, "OSD attribute identification\n");
      processed = 0;
      break;
    case 9:
      n += sprintf(b + n, "ATA Status Return\n");
      if (add_len >= 12) {
        int extended, sector_count;
        extended = descp[2] & 1;
        sector_count = descp[5] + (extended ? (descp[4] << 8) : 0);
        n += sprintf(b + n,
                     "    extended=%d  error=0x%x "
                     " sector_count=0x%x\n",
                     extended, descp[3], sector_count);
        if (extended)
          n += sprintf(b + n, "    lba=0x%02x%02x%02x%02x%02x%02x\n", descp[10],
                       descp[8], descp[6], descp[11], descp[9], descp[7]);
        else
          n += sprintf(b + n, "    lba=0x%02x%02x%02x\n", descp[11], descp[9],
                       descp[7]);
        n += sprintf(b + n, "    device=0x%x  status=0x%x\n", descp[12],
                     descp[13]);
      } else
        processed = 0;
      break;
    case 0xa:
      n += sprintf(b + n, "Progress indication\n");
      if (add_len < 6) {
        processed = 0;
        n += sprintf(b + n, " field too short\n");
        break;
      }
      progress = (descp[6] << 8) + descp[7];
      n += sprintf(b + n, "    %d %%", (progress * 100) / 0x10000);
      n += sprintf(b + n, " [sense_key=0x%x asc,ascq=0x%x,0x%x]\n", descp[2],
                   descp[3], descp[4]);
      break;
    default:
      n += sprintf(b + n, "Unknown or vendor specific [0x%x]\n", descp[0]);
      processed = 0;
      break;
    }
    if (!processed) {
      if (add_len > 0) {
        n += sprintf(b + n, "    ");
        for (j = 0; (j < add_len) && ((k + j + 2) < add_sen_len); ++j) {
          if ((j > 0) && (0 == (j % 24)))
            n += sprintf(b + n, "\n    ");
          n += sprintf(b + n, "%02x ", descp[j + 2]);
        }
        n += sprintf(b + n, "\n");
      }
    }
    if (add_len < 0)
      n += sprintf(b + n, "    short descriptor\n");
    j = strlen(buff);
    if ((n + j) >= buff_len) {
      strncpy(buff + j, b, buff_len - j);
      buff[buff_len - 1] = '\0';
      break;
    }
    strcpy(buff + j, b);
    if (add_len < 0)
      break;
  }
}


x86 assembly (clang, -O0):
<sg_get_sense_descriptors_str>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
xor    %eax,%eax
cmp    -0x18(%rbp),%rax
je     116f <sg_get_sense_descriptors_str+0x2f>
cmpl   $0x0,-0x10(%rbp)
jg     1174 <sg_get_sense_descriptors_str+0x34>
jmp    20e0 <sg_get_sense_descriptors_str+0xfa0>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
cmpl   $0x8,-0xc(%rbp)
jl     119a <sg_get_sense_descriptors_str+0x5a>
mov    -0x8(%rbp),%rax
movzbl 0x7(%rax),%ecx
mov    %ecx,-0x1c(%rbp)
xor    %eax,%eax
cmp    %ecx,%eax
jne    119f <sg_get_sense_descriptors_str+0x5f>
jmp    20e0 <sg_get_sense_descriptors_str+0xfa0>
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x8,%ecx
cmp    %ecx,%eax
jge    11be <sg_get_sense_descriptors_str+0x7e>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x15c(%rbp)
jmp    11ca <sg_get_sense_descriptors_str+0x8a>
mov    -0xc(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xf,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    20e0 <sg_get_sense_descriptors_str+0xfa0>
mov    -0x24(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    123c <sg_get_sense_descriptors_str+0xfc>
mov    -0x48(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0x160(%rbp)
jmp    124c <sg_get_sense_descriptors_str+0x10c>
mov    $0xffffffff,%eax
mov    %eax,-0x160(%rbp)
jmp    124c <sg_get_sense_descriptors_str+0x10c>
mov    -0x160(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
lea    -0x150(%rbp,%rax,1),%rdi
ff
lea    0x1de0(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x48(%rbp),%rax
movzbl (%rax),%eax
mov    %rax,-0x168(%rbp)
sub    $0xa,%rax
ja     1eb1 <sg_get_sense_descriptors_str+0xd71>
mov    -0x168(%rbp),%rax
lea    0x1d49(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1d97(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0xa,-0x20(%rbp)
jl     13b9 <sg_get_sense_descriptors_str+0x279>
mov    -0x48(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     13b9 <sg_get_sense_descriptors_str+0x279>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1d5b(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    138b <sg_get_sense_descriptors_str+0x24b>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
lea    0x1d17(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1339 <sg_get_sense_descriptors_str+0x1f9>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1d9c(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    13c0 <sg_get_sense_descriptors_str+0x280>
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1cab(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0xa,-0x20(%rbp)
jl     14a8 <sg_get_sense_descriptors_str+0x368>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1c6c(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    147a <sg_get_sense_descriptors_str+0x33a>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
lea    0x1c28(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1428 <sg_get_sense_descriptors_str+0x2e8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1cad(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    14af <sg_get_sense_descriptors_str+0x36f>
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
movslq -0x38(%rbp),%rax
lea    -0x150(%rbp,%rax,1),%rdi
ff
lea    0x1bd0(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
mov    %rax,-0x170(%rbp)
sub    $0xa,%rax
ja     18de <sg_get_sense_descriptors_str+0x79e>
mov    -0x170(%rbp),%rax
lea    0x1b31(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1b92(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    1543 <sg_get_sense_descriptors_str+0x403>
movl   $0x0,-0x34(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%ecx
and    $0x40,%ecx
lea    0x1b78(%rip),%rdx
lea    0x1b69(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdx
mov    -0x48(%rbp),%rax
movzbl 0x5(%rax),%ecx
shl    $0x8,%ecx
mov    -0x48(%rbp),%rax
movzbl 0x6(%rax),%eax
or     %eax,%ecx
lea    0x1b2e(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     15ee <sg_get_sense_descriptors_str+0x4ae>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%edx
and    $0x7,%edx
lea    0x1b0b(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1617 <sg_get_sense_descriptors_str+0x4d7>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1b39(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1ab8(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    165b <sg_get_sense_descriptors_str+0x51b>
movl   $0x0,-0x34(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x5(%rax),%edx
mov    -0x48(%rbp),%rax
movzbl 0x6(%rax),%ecx
lea    0x1a7e(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1a60(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    1701 <sg_get_sense_descriptors_str+0x5c1>
movl   $0x0,-0x34(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1a3d(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
mov    -0x48(%rbp),%rax
movzbl 0x5(%rax),%eax
shl    $0x8,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
imul   $0x64,-0x3c(%rbp),%eax
mov    $0x10000,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0x19fb(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x19d4(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    1794 <sg_get_sense_descriptors_str+0x654>
movl   $0x0,-0x34(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%ecx
and    $0x20,%ecx
lea    0x19d1(%rip),%rdx
lea    0x19b7(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdx
mov    -0x48(%rbp),%rax
movzbl 0x5(%rax),%ecx
shl    $0x8,%ecx
mov    -0x48(%rbp),%rax
movzbl 0x6(%rax),%eax
or     %eax,%ecx
lea    0x1972(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     183f <sg_get_sense_descriptors_str+0x6ff>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%edx
and    $0x7,%edx
lea    0x18ba(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1868 <sg_get_sense_descriptors_str+0x728>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x18e8(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1912(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
lea    0x18f1(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1911 <sg_get_sense_descriptors_str+0x7d1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x30(%rbp),%edx
lea    0x18d5(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x18bd(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x2,-0x20(%rbp)
jl     197f <sg_get_sense_descriptors_str+0x83f>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%edx
lea    0x189a(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1986 <sg_get_sense_descriptors_str+0x846>
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x186f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x2,-0x20(%rbp)
jl     1aa5 <sg_get_sense_descriptors_str+0x965>
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     19fd <sg_get_sense_descriptors_str+0x8bd>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1837(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     1a3a <sg_get_sense_descriptors_str+0x8fa>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1807(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     1a77 <sg_get_sense_descriptors_str+0x937>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x17e2(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x16b0(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1aac <sg_get_sense_descriptors_str+0x96c>
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x17a4(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x2,-0x20(%rbp)
jl     1b32 <sg_get_sense_descriptors_str+0x9f2>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%ecx
and    $0x20,%ecx
lea    0x17a3(%rip),%rdx
lea    0x1798(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdx
lea    0x1761(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1b39 <sg_get_sense_descriptors_str+0x9f9>
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x175a(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1740(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x172f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1718(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0xc,-0x20(%rbp)
jl     1da7 <sg_get_sense_descriptors_str+0xc67>
mov    -0x48(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x1,%eax
mov    %eax,-0x154(%rbp)
mov    -0x48(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    %eax,-0x174(%rbp)
cmpl   $0x0,-0x154(%rbp)
je     1c52 <sg_get_sense_descriptors_str+0xb12>
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x8,%eax
mov    %eax,-0x178(%rbp)
jmp    1c5f <sg_get_sense_descriptors_str+0xb1f>
xor    %eax,%eax
mov    %eax,-0x178(%rbp)
jmp    1c5f <sg_get_sense_descriptors_str+0xb1f>
mov    -0x174(%rbp),%eax
mov    -0x178(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x158(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x154(%rbp),%edx
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%ecx
mov    -0x158(%rbp),%r8d
lea    0x1680(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x154(%rbp)
je     1d27 <sg_get_sense_descriptors_str+0xbe7>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0xa(%rax),%edx
mov    -0x48(%rbp),%rax
movzbl 0x8(%rax),%ecx
mov    -0x48(%rbp),%rax
movzbl 0x6(%rax),%r8d
mov    -0x48(%rbp),%rax
movzbl 0xb(%rax),%r9d
mov    -0x48(%rbp),%rax
movzbl 0x9(%rax),%r10d
mov    -0x48(%rbp),%rax
movzbl 0x7(%rax),%eax
lea    0x1647(%rip),%rsi
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1d69 <sg_get_sense_descriptors_str+0xc29>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0xb(%rax),%edx
mov    -0x48(%rbp),%rax
movzbl 0x9(%rax),%ecx
mov    -0x48(%rbp),%rax
movzbl 0x7(%rax),%r8d
lea    0x161c(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0xc(%rax),%edx
mov    -0x48(%rbp),%rax
movzbl 0xd(%rax),%ecx
lea    0x15fb(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1dae <sg_get_sense_descriptors_str+0xc6e>
movl   $0x0,-0x34(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x15df(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    1e1b <sg_get_sense_descriptors_str+0xcdb>
movl   $0x0,-0x34(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1323(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
mov    -0x48(%rbp),%rax
movzbl 0x6(%rax),%eax
shl    $0x8,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
imul   $0x64,-0x3c(%rbp),%eax
mov    $0x10000,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0x1566(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x2(%rax),%edx
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%ecx
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%r8d
lea    0x152e(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1ee8 <sg_get_sense_descriptors_str+0xda8>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl (%rax),%edx
lea    0x151f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    2026 <sg_get_sense_descriptors_str+0xee6>
cmpl   $0x0,-0x20(%rbp)
jle    2021 <sg_get_sense_descriptors_str+0xee1>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x14ff(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x20(%rbp),%ecx
mov    %al,-0x179(%rbp)
jge    1f55 <sg_get_sense_descriptors_str+0xe15>
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
add    $0x2,%eax
cmp    -0x1c(%rbp),%eax
setl   %al
mov    %al,-0x179(%rbp)
mov    -0x179(%rbp),%al
test   $0x1,%al
jne    1f68 <sg_get_sense_descriptors_str+0xe28>
jmp    1ff8 <sg_get_sense_descriptors_str+0xeb8>
cmpl   $0x0,-0x2c(%rbp)
jle    1fb0 <sg_get_sense_descriptors_str+0xe70>
mov    -0x2c(%rbp),%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
xor    %eax,%eax
cmp    %edx,%eax
jne    1fb0 <sg_get_sense_descriptors_str+0xe70>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x1473(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
lea    0x143f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1f2c <sg_get_sense_descriptors_str+0xdec>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x112f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    2026 <sg_get_sense_descriptors_str+0xee6>
cmpl   $0x0,-0x20(%rbp)
jge    2059 <sg_get_sense_descriptors_str+0xf19>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x13d6(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%eax
add    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     20a7 <sg_get_sense_descriptors_str+0xf67>
mov    -0x18(%rbp),%rdi
movslq -0x2c(%rbp),%rax
add    %rax,%rdi
lea    -0x150(%rbp),%rsi
mov    -0x10(%rbp),%edx
sub    -0x2c(%rbp),%edx
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    20e0 <sg_get_sense_descriptors_str+0xfa0>
mov    -0x18(%rbp),%rdi
movslq -0x2c(%rbp),%rax
add    %rax,%rdi
lea    -0x150(%rbp),%rsi
call   1040 <strcpy@plt>
cmpl   $0x0,-0x20(%rbp)
jge    20cd <sg_get_sense_descriptors_str+0xf8d>
jmp    20e0 <sg_get_sense_descriptors_str+0xfa0>
jmp    20d2 <sg_get_sense_descriptors_str+0xf92>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    11fb <sg_get_sense_descriptors_str+0xbb>
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sg_get_sense_descriptors_str>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %rdx,0x38(%rsp)
test   %edx,%edx
jle    1c6b <sg_get_sense_descriptors_str+0xb2b>
mov    %rcx,%r15
test   %rcx,%rcx
je     1c6b <sg_get_sense_descriptors_str+0xb2b>
movb   $0x0,(%r15)
cmp    $0x8,%esi
jl     1c6b <sg_get_sense_descriptors_str+0xb2b>
mov    %rdi,%r12
movzbl 0x7(%rdi),%eax
test   %eax,%eax
je     1c6b <sg_get_sense_descriptors_str+0xb2b>
add    $0xfffffff8,%esi
cmp    %eax,%esi
cmova  %eax,%esi
mov    %rsi,0x28(%rsp)
test   %esi,%esi
je     1c6b <sg_get_sense_descriptors_str+0xb2b>
movzbl 0x1(%r12),%eax
and    $0xf,%eax
mov    %eax,0x30(%rsp)
add    $0x8,%r12
mov    0x28(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x34(%rsp)
lea    0x40(%rsp),%rbp
xor    %r13d,%r13d
xor    %ebx,%ebx
mov    %r15,0x18(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %r13d,%eax
mov    %rax,%r15
lea    (%r12,%rax,1),%r13
movl   $0xffffffff,0xc(%rsp)
ff
mov    %rbx,0x10(%rsp)
cmp    0x34(%rsp),%ebx
jge    11f6 <sg_get_sense_descriptors_str+0xb6>
movzbl 0x1(%r13),%eax
mov    %eax,0xc(%rsp)
mov    %rbp,%rdi
lea    0xe58(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r14
movzbl 0x0(%r13),%edx
cmp    $0xa,%rdx
mov    %r13,0x20(%rsp)
ja     1546 <sg_get_sense_descriptors_str+0x406>
lea    0xddb(%rip),%rcx
movslq (%rcx,%rdx,4),%rax
add    %rcx,%rax
jmp    *%rax
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xe2c(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0xa,0xc(%rsp)
jl     17f9 <sg_get_sense_descriptors_str+0x6b9>
cmpb   $0x0,0x2(%r13)
mov    0xc(%rsp),%r13d
jns    1807 <sg_get_sense_descriptors_str+0x6c7>
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xdff(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r14
add    %rbp,%r14
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
mov    0x20(%rsp),%r15
movzbl 0x4(%r15),%edx
lea    0xddd(%rip),%r12
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x5(%r15),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r14
add    %rbp,%r14
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x6(%r15),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x7(%r15),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r14
add    %rbp,%r14
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x8(%r15),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x9(%r15),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %rbp,%rax
movslq %eax,%rbx
lea    (%rsp,%rbx,1),%rdi
add    $0x40,%rdi
movzbl 0xa(%r15),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebx
movslq %ebx,%rbx
lea    (%rsp,%rbx,1),%rdi
add    $0x40,%rdi
movzbl 0xb(%r15),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %rbx,%rax
movslq %eax,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xda1(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    $0x1,%r14b
jmp    1906 <sg_get_sense_descriptors_str+0x7c6>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xcd9(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbx
add    %r14,%rbx
mov    0x30(%rsp),%edx
cmp    $0xa,%edx
ja     1b8d <sg_get_sense_descriptors_str+0xa4d>
mov    %edx,%eax
lea    0xc4b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xced(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %rbx,%rbp
cmpl   $0x5,0xc(%rsp)
jle    17f9 <sg_get_sense_descriptors_str+0x6b9>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl 0x5(%r13),%edx
movzbl 0x6(%r13),%ecx
lea    0xcce(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    1961 <sg_get_sense_descriptors_str+0x821>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xdc1(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0x2,0xc(%rsp)
jl     17f9 <sg_get_sense_descriptors_str+0x6b9>
mov    0x3(%r13),%al
test   %al,%al
jns    148d <sg_get_sense_descriptors_str+0x34d>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xda0(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    0x3(%r13),%al
test   $0x40,%al
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%r13d
mov    0x18(%rsp),%r15
je     14c3 <sg_get_sense_descriptors_str+0x383>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xd7b(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    0x20(%rsp),%rax
mov    0x3(%rax),%al
test   $0x20,%al
je     14e2 <sg_get_sense_descriptors_str+0x3a2>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xd6c(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xc48(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    1ab8 <sg_get_sense_descriptors_str+0x978>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xdf8(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0xc,0xc(%rsp)
jl     17f9 <sg_get_sense_descriptors_str+0x6b9>
movzbl 0x2(%r13),%r14d
and    $0x1,%r14d
je     19ec <sg_get_sense_descriptors_str+0x8ac>
movzbl 0x4(%r13),%eax
shl    $0x8,%eax
jmp    19ee <sg_get_sense_descriptors_str+0x8ae>
movslq %r14d,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xe94(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    17f7 <sg_get_sense_descriptors_str+0x6b7>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xb0f(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0xa,0xc(%rsp)
jl     17f9 <sg_get_sense_descriptors_str+0x6b9>
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xad9(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r14
add    %rbp,%r14
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x4(%r13),%edx
lea    0xabc(%rip),%r12
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x5(%r13),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r14
add    %rbp,%r14
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x6(%r13),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x7(%r13),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r14
add    %rbp,%r14
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x8(%r13),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x9(%r13),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %rbp,%rax
movslq %eax,%rbx
lea    (%rsp,%rbx,1),%rdi
add    $0x40,%rdi
movzbl 0xa(%r13),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebx
movslq %ebx,%rbx
lea    (%rsp,%rbx,1),%rdi
add    $0x40,%rdi
movzbl 0xb(%r13),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %rbx,%rax
movslq %eax,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xa80(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    1961 <sg_get_sense_descriptors_str+0x821>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xb0e(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0x2,0xc(%rsp)
jl     17f9 <sg_get_sense_descriptors_str+0x6b9>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl 0x3(%r13),%edx
lea    0xaf7(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    1961 <sg_get_sense_descriptors_str+0x821>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xb43(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0x2,0xc(%rsp)
jl     17f9 <sg_get_sense_descriptors_str+0x6b9>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
testb  $0x20,0x3(%r13)
lea    0xb4d(%rip),%rdx
lea    0xb4a(%rip),%rax
cmove  %rax,%rdx
lea    0xb12(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    1961 <sg_get_sense_descriptors_str+0x821>
movslq %r14d,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xb27(%rip),%rsi
jmp    17f0 <sg_get_sense_descriptors_str+0x6b0>
movslq %r14d,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xb2e(%rip),%rsi
jmp    17f0 <sg_get_sense_descriptors_str+0x6b0>
movslq %r14d,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xb3e(%rip),%rsi
jmp    17f0 <sg_get_sense_descriptors_str+0x6b0>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xbe5(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0x5,0xc(%rsp)
jg     190d <sg_get_sense_descriptors_str+0x7cd>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0x939(%rip),%rsi
nopl   0x0(%rax)
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    0xc(%rsp),%r13d
test   %r13d,%r13d
jle    18e0 <sg_get_sense_descriptors_str+0x7a0>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
xor    %ebx,%ebx
lea    0xbf5(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    %r13d,%r14d
mov    0x10(%rsp),%rax
lea    0x2(%rax),%r13d
add    %r15,%r12
add    $0x2,%r12
xor    %r15d,%r15d
jmp    186c <sg_get_sense_descriptors_str+0x72c>
nopl   0x0(%rax)
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl (%r12,%r15,1),%edx
lea    0xbbe(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
add    $0x1,%r15
add    $0xffffffff,%ebx
cmp    %r15,%r14
je     18c0 <sg_get_sense_descriptors_str+0x780>
lea    (%r15,%r13,1),%eax
cmp    0x28(%rsp),%eax
jge    18c0 <sg_get_sense_descriptors_str+0x780>
test   %r15,%r15
je     1840 <sg_get_sense_descriptors_str+0x700>
mov    %r15d,%eax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x24,%rax
lea    (%rax,%rax,2),%eax
lea    (%rbx,%rax,8),%eax
test   %eax,%eax
jne    1840 <sg_get_sense_descriptors_str+0x700>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xb68(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
jmp    1840 <sg_get_sense_descriptors_str+0x700>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0x86a(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    0xc(%rsp),%r13d
mov    $0x1,%r14b
test   %r13d,%r13d
jns    1906 <sg_get_sense_descriptors_str+0x7c6>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
xor    %r14d,%r14d
lea    0xb1e(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    0x10(%rsp),%rbx
jmp    1970 <sg_get_sense_descriptors_str+0x830>
movzwl 0x6(%r13),%eax
shl    $0x10,%eax
bswap  %eax
movslq %ebp,%rcx
lea    (%rsp,%rcx,1),%rdi
add    $0x40,%rdi
imul   $0x64,%eax,%edx
shr    $0x10,%edx
lea    0xa8d(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %rbp,%rax
movslq %eax,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl 0x2(%r13),%edx
movzbl 0x3(%r13),%ecx
movzbl 0x4(%r13),%r8d
lea    0xa6c(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    $0x1,%r14b
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%r13d
mov    0x18(%rsp),%r15
mov    %r15,%rdi
call   1050 <strlen@plt>
add    %eax,%ebp
movslq %eax,%rdi
add    %r15,%rdi
cmp    0x38(%rsp),%ebp
jge    1c50 <sg_get_sense_descriptors_str+0xb10>
add    $0x2,%r13d
lea    0x40(%rsp),%rbp
mov    %rbp,%rsi
call   1040 <strcpy@plt>
add    %r13d,%ebx
cmp    0x28(%rsp),%ebx
setl   %al
mov    0x20(%rsp),%r12
test   %al,%r14b
jne    11d0 <sg_get_sense_descriptors_str+0x90>
jmp    1c6b <sg_get_sense_descriptors_str+0xb2b>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x73f(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %rbx,%rax
cmpl   $0x5,0xc(%rsp)
jg     1b66 <sg_get_sense_descriptors_str+0xa26>
movslq %eax,%rbp
jmp    17dd <sg_get_sense_descriptors_str+0x69d>
xor    %eax,%eax
mov    0x18(%rsp),%r15
movzbl 0x5(%r13),%r8d
or     %eax,%r8d
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzbl 0x3(%r13),%ecx
lea    0x90b(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r12
add    %rbp,%r12
movslq %r12d,%rbx
lea    (%rsp,%rbx,1),%rdi
add    $0x40,%rdi
test   %r14b,%r14b
je     1a6a <sg_get_sense_descriptors_str+0x92a>
movzbl 0xa(%r13),%edx
movzbl 0x8(%r13),%ecx
movzbl 0x6(%r13),%r8d
movzbl 0xb(%r13),%r9d
movzbl 0x9(%r13),%r10d
movzbl 0x7(%r13),%ebp
lea    0x8f6(%rip),%rsi
xor    %eax,%eax
push   %rbp
push   %r10
call   1060 <sprintf@plt>
add    $0x10,%rsp
add    %rbx,%rax
jmp    1a8a <sg_get_sense_descriptors_str+0x94a>
movzbl 0xb(%r13),%edx
movzbl 0x9(%r13),%ecx
movzbl 0x7(%r13),%r8d
lea    0x8f1(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %r12,%rax
mov    0x10(%rsp),%rbx
mov    %r13,%rcx
mov    0xc(%rsp),%r13d
movslq %eax,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl 0xc(%rcx),%edx
movzbl 0xd(%rcx),%ecx
lea    0x8d8(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    $0x1,%r14b
jmp    1975 <sg_get_sense_descriptors_str+0x835>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x5d7(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %rbx,%rbp
cmpl   $0x5,0xc(%rsp)
jle    17f9 <sg_get_sense_descriptors_str+0x6b9>
movslq %ebp,%rax
testb  $0x40,0x4(%r13)
lea    0x5d8(%rip),%rdx
lea    0x5d9(%rip),%rcx
cmove  %rcx,%rdx
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzwl 0x5(%r13),%ecx
shl    $0x10,%ecx
bswap  %ecx
lea    0x59c(%rip),%rsi
jmp    1c01 <sg_get_sense_descriptors_str+0xac1>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x65e(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %rbx,%rax
movslq %eax,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl 0x4(%r13),%edx
and    $0x1,%edx
lea    0x65c(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    18d9 <sg_get_sense_descriptors_str+0x799>
movzwl 0x5(%r13),%ecx
shl    $0x10,%ecx
bswap  %ecx
movslq %eax,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
imul   $0x64,%ecx,%edx
shr    $0x10,%edx
lea    0x5af(%rip),%rsi
jmp    1709 <sg_get_sense_descriptors_str+0x5c9>
movslq %ebx,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0x62c(%rip),%rsi
jmp    1558 <sg_get_sense_descriptors_str+0x418>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x588(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %rbx,%rbp
cmpl   $0x5,0xc(%rsp)
jle    17f9 <sg_get_sense_descriptors_str+0x6b9>
movslq %ebp,%rax
testb  $0x20,0x4(%r13)
lea    0x595(%rip),%rdx
lea    0x5a1(%rip),%rcx
cmove  %rcx,%rdx
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzwl 0x5(%r13),%ecx
shl    $0x10,%ecx
bswap  %ecx
lea    0x54f(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbx
add    %rbp,%rbx
movzbl 0x4(%r13),%edx
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
test   $0x8,%dl
jne    1c33 <sg_get_sense_descriptors_str+0xaf3>
lea    0x512(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    1c44 <sg_get_sense_descriptors_str+0xb04>
and    $0x7,%edx
lea    0x4a3(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebx
mov    $0x1,%r14b
mov    %ebx,%ebp
jmp    1966 <sg_get_sense_descriptors_str+0x826>
mov    0x38(%rsp),%rbx
mov    %ebx,%edx
sub    %eax,%edx
lea    0x40(%rsp),%rsi
call   1030 <strncpy@plt>
add    $0xffffffff,%ebx
movb   $0x0,(%r15,%rbx,1)
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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