#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;
      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 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;
    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    1f71 <sg_get_sense_descriptors_str+0xe31>
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    1f71 <sg_get_sense_descriptors_str+0xe31>
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    1f71 <sg_get_sense_descriptors_str+0xe31>
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    0xddc(%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    $0x9,%rax
ja     1d42 <sg_get_sense_descriptors_str+0xc02>
mov    -0x168(%rbp),%rax
lea    0xd49(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0xd93(%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    0xd57(%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    0xd13(%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    0xd98(%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    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0xca7(%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    0xc68(%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    0xc24(%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    0xca9(%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    1d79 <sg_get_sense_descriptors_str+0xc39>
movslq -0x38(%rbp),%rax
lea    -0x150(%rbp,%rax,1),%rdi
ff
lea    0xbcc(%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     186d <sg_get_sense_descriptors_str+0x72d>
mov    -0x170(%rbp),%rax
lea    0xb2d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0xb8e(%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    18a0 <sg_get_sense_descriptors_str+0x760>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%ecx
and    $0x40,%ecx
lea    0xb74(%rip),%rdx
lea    0xb65(%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    0xb2a(%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    0xb07(%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    0xb35(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    18a0 <sg_get_sense_descriptors_str+0x760>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0xab4(%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    18a0 <sg_get_sense_descriptors_str+0x760>
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    0xa7a(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    18a0 <sg_get_sense_descriptors_str+0x760>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0xa5c(%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    0xa39(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    18a0 <sg_get_sense_descriptors_str+0x760>
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    0x9f7(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    18a0 <sg_get_sense_descriptors_str+0x760>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x9d0(%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    18a0 <sg_get_sense_descriptors_str+0x760>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%ecx
and    $0x20,%ecx
lea    0x9d0(%rip),%rdx
lea    0x9b6(%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    0x96e(%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    0x8b6(%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    0x8e4(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    18a0 <sg_get_sense_descriptors_str+0x760>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x30(%rbp),%edx
lea    0x90e(%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    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x8f6(%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     190e <sg_get_sense_descriptors_str+0x7ce>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%edx
lea    0x8d3(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1915 <sg_get_sense_descriptors_str+0x7d5>
movl   $0x0,-0x34(%rbp)
jmp    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x8a8(%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     1a34 <sg_get_sense_descriptors_str+0x8f4>
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     198c <sg_get_sense_descriptors_str+0x84c>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x870(%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     19c9 <sg_get_sense_descriptors_str+0x889>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x840(%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     1a06 <sg_get_sense_descriptors_str+0x8c6>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x81b(%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    0x71d(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1a3b <sg_get_sense_descriptors_str+0x8fb>
movl   $0x0,-0x34(%rbp)
jmp    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x7dd(%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     1ac1 <sg_get_sense_descriptors_str+0x981>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl 0x3(%rax),%ecx
and    $0x20,%ecx
lea    0x7dc(%rip),%rdx
lea    0x7d1(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdx
lea    0x79a(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1ac8 <sg_get_sense_descriptors_str+0x988>
movl   $0x0,-0x34(%rbp)
jmp    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x793(%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    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x779(%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    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x768(%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    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x751(%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     1d36 <sg_get_sense_descriptors_str+0xbf6>
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     1be1 <sg_get_sense_descriptors_str+0xaa1>
mov    -0x48(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x8,%eax
mov    %eax,-0x178(%rbp)
jmp    1bee <sg_get_sense_descriptors_str+0xaae>
xor    %eax,%eax
mov    %eax,-0x178(%rbp)
jmp    1bee <sg_get_sense_descriptors_str+0xaae>
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    0x6b2(%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     1cb6 <sg_get_sense_descriptors_str+0xb76>
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    0x679(%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    1cf8 <sg_get_sense_descriptors_str+0xbb8>
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    0x64e(%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    0x62d(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1d3d <sg_get_sense_descriptors_str+0xbfd>
movl   $0x0,-0x34(%rbp)
jmp    1d79 <sg_get_sense_descriptors_str+0xc39>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rax
movzbl (%rax),%edx
lea    0x60a(%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    1eb7 <sg_get_sense_descriptors_str+0xd77>
cmpl   $0x0,-0x20(%rbp)
jle    1eb2 <sg_get_sense_descriptors_str+0xd72>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x5ea(%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    1de6 <sg_get_sense_descriptors_str+0xca6>
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    1df9 <sg_get_sense_descriptors_str+0xcb9>
jmp    1e89 <sg_get_sense_descriptors_str+0xd49>
cmpl   $0x0,-0x2c(%rbp)
jle    1e41 <sg_get_sense_descriptors_str+0xd01>
mov    -0x2c(%rbp),%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
xor    %eax,%eax
cmp    %edx,%eax
jne    1e41 <sg_get_sense_descriptors_str+0xd01>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x55e(%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    0x52a(%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    1dbd <sg_get_sense_descriptors_str+0xc7d>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x29a(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    %rax,%rcx
movslq -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
jmp    1eb7 <sg_get_sense_descriptors_str+0xd77>
cmpl   $0x0,-0x20(%rbp)
jge    1eea <sg_get_sense_descriptors_str+0xdaa>
lea    -0x150(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
lea    0x4c1(%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     1f38 <sg_get_sense_descriptors_str+0xdf8>
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    1f71 <sg_get_sense_descriptors_str+0xe31>
mov    -0x18(%rbp),%rdi
movslq -0x2c(%rbp),%rax
add    %rax,%rdi
lea    -0x150(%rbp),%rsi
call   1040 <strcpy@plt>
cmpl   $0x0,-0x20(%rbp)
jge    1f5e <sg_get_sense_descriptors_str+0xe1e>
jmp    1f71 <sg_get_sense_descriptors_str+0xe31>
jmp    1f63 <sg_get_sense_descriptors_str+0xe23>
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    1ba0 <sg_get_sense_descriptors_str+0xa60>
mov    %rcx,%r15
test   %rcx,%rcx
je     1ba0 <sg_get_sense_descriptors_str+0xa60>
movb   $0x0,(%r15)
cmp    $0x8,%esi
jl     1ba0 <sg_get_sense_descriptors_str+0xa60>
mov    %rdi,%r12
movzbl 0x7(%rdi),%eax
test   %eax,%eax
je     1ba0 <sg_get_sense_descriptors_str+0xa60>
add    $0xfffffff8,%esi
cmp    %eax,%esi
cmova  %eax,%esi
mov    %rsi,0x28(%rsp)
test   %esi,%esi
je     1ba0 <sg_get_sense_descriptors_str+0xa60>
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    0xe54(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%r14
movzbl 0x0(%r13),%edx
cmp    $0x9,%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    0xe28(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0xa,0xc(%rsp)
jl     17c3 <sg_get_sense_descriptors_str+0x683>
cmpb   $0x0,0x2(%r13)
mov    0xc(%rsp),%r13d
jns    17d1 <sg_get_sense_descriptors_str+0x691>
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xdfb(%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    0xdd9(%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    0xd9d(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    $0x1,%r14b
jmp    18d6 <sg_get_sense_descriptors_str+0x796>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xcd5(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbx
add    %r14,%rbx
mov    0x30(%rsp),%edx
cmp    $0xa,%edx
ja     1a9b <sg_get_sense_descriptors_str+0x95b>
mov    %edx,%eax
lea    0xc47(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xce9(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %rbx,%rbp
cmpl   $0x5,0xc(%rsp)
jle    17c3 <sg_get_sense_descriptors_str+0x683>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl 0x5(%r13),%edx
movzbl 0x6(%r13),%ecx
lea    0xcca(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    176c <sg_get_sense_descriptors_str+0x62c>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xd89(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0x2,0xc(%rsp)
jl     17c3 <sg_get_sense_descriptors_str+0x683>
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    0xd68(%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    0xd43(%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    0xd34(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xc44(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    1a32 <sg_get_sense_descriptors_str+0x8f2>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xdc0(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0xc,0xc(%rsp)
jl     17c3 <sg_get_sense_descriptors_str+0x683>
movzbl 0x2(%r13),%r14d
and    $0x1,%r14d
je     1966 <sg_get_sense_descriptors_str+0x826>
movzbl 0x4(%r13),%eax
shl    $0x8,%eax
jmp    1968 <sg_get_sense_descriptors_str+0x828>
movslq %r14d,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xe10(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    17c1 <sg_get_sense_descriptors_str+0x681>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xb0b(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0xa,0xc(%rsp)
jl     17c3 <sg_get_sense_descriptors_str+0x683>
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xad5(%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    0xab8(%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    0xa7c(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    176c <sg_get_sense_descriptors_str+0x62c>
movslq %r14d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0xad6(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmpl   $0x2,0xc(%rsp)
jl     17c3 <sg_get_sense_descriptors_str+0x683>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl 0x3(%r13),%edx
lea    0xabf(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    176c <sg_get_sense_descriptors_str+0x62c>
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     17c3 <sg_get_sense_descriptors_str+0x683>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
testb  $0x20,0x3(%r13)
lea    0xb18(%rip),%rdx
lea    0xb15(%rip),%rax
cmove  %rax,%rdx
lea    0xadd(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    $0x1,%r14b
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%r13d
jmp    18db <sg_get_sense_descriptors_str+0x79b>
movslq %r14d,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xae3(%rip),%rsi
jmp    17ba <sg_get_sense_descriptors_str+0x67a>
movslq %r14d,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xaea(%rip),%rsi
jmp    17ba <sg_get_sense_descriptors_str+0x67a>
movslq %r14d,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xafa(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    0xc(%rsp),%r13d
test   %r13d,%r13d
jle    18b0 <sg_get_sense_descriptors_str+0x770>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
xor    %ebx,%ebx
lea    0xba7(%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    183c <sg_get_sense_descriptors_str+0x6fc>
cs nopw 0x0(%rax,%rax,1)
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
movzbl (%r12,%r15,1),%edx
lea    0xb6a(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
add    $0x1,%r15
add    $0xffffffff,%ebx
cmp    %r15,%r14
je     1890 <sg_get_sense_descriptors_str+0x750>
lea    (%r15,%r13,1),%eax
cmp    0x28(%rsp),%eax
jge    1890 <sg_get_sense_descriptors_str+0x750>
test   %r15,%r15
je     1810 <sg_get_sense_descriptors_str+0x6d0>
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    1810 <sg_get_sense_descriptors_str+0x6d0>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0xb14(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
jmp    1810 <sg_get_sense_descriptors_str+0x6d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0x896(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    0xc(%rsp),%r13d
mov    $0x1,%r14b
test   %r13d,%r13d
jns    18d6 <sg_get_sense_descriptors_str+0x796>
movslq %ebp,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
xor    %r14d,%r14d
lea    0xaca(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    0x10(%rsp),%rbx
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    1b85 <sg_get_sense_descriptors_str+0xa45>
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    1ba0 <sg_get_sense_descriptors_str+0xa60>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x7d0(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %rbx,%rax
cmpl   $0x5,0xc(%rsp)
jg     1b41 <sg_get_sense_descriptors_str+0xa01>
movslq %eax,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0x7c0(%rip),%rsi
jmp    17ba <sg_get_sense_descriptors_str+0x67a>
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    0x952(%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     19e4 <sg_get_sense_descriptors_str+0x8a4>
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    0x93d(%rip),%rsi
xor    %eax,%eax
push   %rbp
push   %r10
call   1060 <sprintf@plt>
add    $0x10,%rsp
add    %rbx,%rax
jmp    1a04 <sg_get_sense_descriptors_str+0x8c4>
movzbl 0xb(%r13),%edx
movzbl 0x9(%r13),%ecx
movzbl 0x7(%r13),%r8d
lea    0x938(%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    0x91f(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebp
mov    $0x1,%r14b
jmp    18e0 <sg_get_sense_descriptors_str+0x7a0>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x659(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %rbx,%rbp
cmpl   $0x5,0xc(%rsp)
jle    17c3 <sg_get_sense_descriptors_str+0x683>
movslq %ebp,%rax
testb  $0x40,0x4(%r13)
lea    0x65a(%rip),%rdx
lea    0x65b(%rip),%rcx
cmove  %rcx,%rdx
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzwl 0x5(%r13),%ecx
shl    $0x10,%ecx
bswap  %ecx
lea    0x61e(%rip),%rsi
jmp    1b0f <sg_get_sense_descriptors_str+0x9cf>
movslq %ebx,%rbp
lea    (%rsp,%rbp,1),%rdi
add    $0x40,%rdi
lea    0x6e6(%rip),%rsi
jmp    1558 <sg_get_sense_descriptors_str+0x418>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x676(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
mov    %rax,%rbp
add    %rbx,%rbp
cmpl   $0x5,0xc(%rsp)
jle    17c3 <sg_get_sense_descriptors_str+0x683>
movslq %ebp,%rax
testb  $0x20,0x4(%r13)
lea    0x686(%rip),%rdx
lea    0x692(%rip),%rcx
cmove  %rcx,%rdx
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
movzwl 0x5(%r13),%ecx
shl    $0x10,%ecx
bswap  %ecx
lea    0x63d(%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    1b68 <sg_get_sense_descriptors_str+0xa28>
lea    0x600(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
jmp    1b79 <sg_get_sense_descriptors_str+0xa39>
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    0x5d0(%rip),%rsi
jmp    1709 <sg_get_sense_descriptors_str+0x5c9>
and    $0x7,%edx
lea    0x56a(%rip),%rsi
xor    %eax,%eax
call   1060 <sprintf@plt>
add    %eax,%ebx
mov    $0x1,%r14b
mov    %ebx,%ebp
jmp    1771 <sg_get_sense_descriptors_str+0x631>
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 = [37 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 = [29 x i8] c" Sense_key: 0x%x unexpected\0A\00"
@.str.22 = [24 x i8] c"Field replaceable unit\0A\00"
@.str.23 = [15 x i8] c" code=0x%x\0A\00"
@.str.24 = [17 x i8] c"Stream commands\0A\00"
@.str.25 = [13 x i8] c" FILEMARK\00"
@.str.26 = [24 x i8] c" End Of Medium (EOM)\00"
@.str.27 = [37 x i8] c" Incorrect Length Indicator (ILI)\00"
@.str.28 = [16 x i8] c"Block commands\0A\00"
@.str.29 = [41 x i8] c" Incorrect Length Indicator (ILI) %s\0A\00"
@.str.30 = [4 x i8] c"set\00"
@.str.31 = [6 x i8] c"clear\00"
@.str.32 = [27 x i8] c"OSD object identification\0A\00"
@.str.33 = [36 x i8] c"OSD response integrity check value\0A\00"
@.str.34 = [30 x i8] c"OSD attribute identification\0A\00"
@.str.35 = [12 x i8] c"ATA Return\0A\00"
@.str.36 = [48 x i8] c" extended=%d error=0x%x sector_count=0x%x\0A\00"
@.str.37 = [36 x i8] c" lba=0x%02x%02x%02x%02x%02x%02x\0A\00"
@.str.38 = [24 x i8] c" lba=0x%02x%02x%02x\0A\00"
@.str.39 = [30 x i8] c" device=0x%x status=0x%x\0A\00"
@.str.40 = [35 x i8] c"Unknown or vendor specific [0x%x]\0A\00"
@.str.41 = [5 x i8] c" \00"
@.str.42 = [6 x i8] c"\0A \00"
@.str.43 = [6 x i8] c"%02x \00"
@.str.44 = [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 %895
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 %895
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 = %891, %50
%60 = load i32, i32* %12
%61 = load i32, i32* %9
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %895
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 %753 [
i32 0, label %95
i32 1, label %159
i32 2, label %216
i32 3, label %461
i32 4, label %489
i32 5, label %564
i32 6, label %596
i32 7, label %606
i32 8, label %616
i32 9, label %626
]
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 %767
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 %767
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 %449 [
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
]
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 %460
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 %460
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 %460
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 %460
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 %460
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 %460
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 %460
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 ([37 x i8], [37 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 %460
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 = load i32, i32* %14
%455 = call i64 (i8*, i8*, ...) @sprintf(i8* %453, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.21, i64 0, i64 0), i32 %454)
%456 = load i32, i32* %16
%457 = sext i32 %456 to i64
%458 = add nsw i64 %457, %455
%459 = trunc i64 %458 to i32
store i32 %459, i32* %16
store i32 0, i32* %15
br label %460
460: ; preds = %449, %448, %388, %353, %343, %313, %312, %299, %239
br label %767
461: ; preds = %78
%462 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%463 = load i32, i32* %16
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i8, i8* %462, i64 %464
%466 = call i64 (i8*, i8*, ...) @sprintf(i8* %465, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.22, i64 0, i64 0))
%467 = load i32, i32* %16
%468 = sext i32 %467 to i64
%469 = add nsw i64 %468, %466
%470 = trunc i64 %469 to i32
store i32 %470, i32* %16
%471 = load i32, i32* %10
%472 = icmp sge i32 %471, 2
br i1 %472, label %473, label %487
473: ; preds = %461
%474 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%475 = load i32, i32* %16
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds i8, i8* %474, i64 %476
%478 = load i8*, i8** %18
%479 = getelementptr inbounds i8, i8* %478, i64 3
%480 = load i8, i8* %479
%481 = zext i8 %480 to i32
%482 = call i64 (i8*, i8*, ...) @sprintf(i8* %477, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), i32 %481)
%483 = load i32, i32* %16
%484 = sext i32 %483 to i64
%485 = add nsw i64 %484, %482
%486 = trunc i64 %485 to i32
store i32 %486, i32* %16
br label %488
487: ; preds = %461
store i32 0, i32* %15
br label %488
488: ; preds = %487, %473
br label %767
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 ([17 x i8], [17 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 %562
501: ; preds = %489
%502 = load i8*, i8** %18
%503 = getelementptr inbounds i8, i8* %502, i64 3
%504 = load i8, i8* %503
%505 = zext i8 %504 to i32
%506 = and i32 %505, 128
%507 = icmp ne i32 %506, 0
br i1 %507, label %508, label %518
508: ; preds = %501
%509 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%510 = load i32, i32* %16
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds i8, i8* %509, i64 %511
%513 = call i64 (i8*, i8*, ...) @sprintf(i8* %512, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.25, i64 0, i64 0))
%514 = load i32, i32* %16
%515 = sext i32 %514 to i64
%516 = add nsw i64 %515, %513
%517 = trunc i64 %516 to i32
store i32 %517, i32* %16
br label %518
518: ; preds = %508, %501
%519 = load i8*, i8** %18
%520 = getelementptr inbounds i8, i8* %519, i64 3
%521 = load i8, i8* %520
%522 = zext i8 %521 to i32
%523 = and i32 %522, 64
%524 = icmp ne i32 %523, 0
br i1 %524, label %525, label %535
525: ; preds = %518
%526 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%527 = load i32, i32* %16
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds i8, i8* %526, i64 %528
%530 = call i64 (i8*, i8*, ...) @sprintf(i8* %529, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.26, i64 0, i64 0))
%531 = load i32, i32* %16
%532 = sext i32 %531 to i64
%533 = add nsw i64 %532, %530
%534 = trunc i64 %533 to i32
store i32 %534, i32* %16
br label %535
535: ; preds = %525, %518
%536 = load i8*, i8** %18
%537 = getelementptr inbounds i8, i8* %536, i64 3
%538 = load i8, i8* %537
%539 = zext i8 %538 to i32
%540 = and i32 %539, 32
%541 = icmp ne i32 %540, 0
br i1 %541, label %542, label %552
542: ; preds = %535
%543 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%544 = load i32, i32* %16
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds i8, i8* %543, i64 %545
%547 = call i64 (i8*, i8*, ...) @sprintf(i8* %546, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.27, i64 0, i64 0))
%548 = load i32, i32* %16
%549 = sext i32 %548 to i64
%550 = add nsw i64 %549, %547
%551 = trunc i64 %550 to i32
store i32 %551, i32* %16
br label %552
552: ; preds = %542, %535
%553 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%554 = load i32, i32* %16
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i8, i8* %553, i64 %555
%557 = call i64 (i8*, i8*, ...) @sprintf(i8* %556, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%558 = load i32, i32* %16
%559 = sext i32 %558 to i64
%560 = add nsw i64 %559, %557
%561 = trunc i64 %560 to i32
store i32 %561, i32* %16
br label %563
562: ; preds = %489
store i32 0, i32* %15
br label %563
563: ; preds = %562, %552
br label %767
564: ; preds = %78
%565 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%566 = load i32, i32* %16
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds i8, i8* %565, i64 %567
%569 = call i64 (i8*, i8*, ...) @sprintf(i8* %568, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0))
%570 = load i32, i32* %16
%571 = sext i32 %570 to i64
%572 = add nsw i64 %571, %569
%573 = trunc i64 %572 to i32
store i32 %573, i32* %16
%574 = load i32, i32* %10
%575 = icmp sge i32 %574, 2
br i1 %575, label %576, label %594
576: ; preds = %564
%577 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%578 = load i32, i32* %16
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds i8, i8* %577, i64 %579
%581 = load i8*, i8** %18
%582 = getelementptr inbounds i8, i8* %581, i64 3
%583 = load i8, i8* %582
%584 = zext i8 %583 to i32
%585 = and i32 %584, 32
%586 = icmp ne i32 %585, 0
%587 = zext i1 %586 to i64
%588 = select i1 %586, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.30, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.31, i64 0, i64 0)
%589 = call i64 (i8*, i8*, ...) @sprintf(i8* %580, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.29, i64 0, i64 0), i8* %588)
%590 = load i32, i32* %16
%591 = sext i32 %590 to i64
%592 = add nsw i64 %591, %589
%593 = trunc i64 %592 to i32
store i32 %593, i32* %16
br label %595
594: ; preds = %564
store i32 0, i32* %15
br label %595
595: ; preds = %594, %576
br label %767
596: ; preds = %78
%597 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%598 = load i32, i32* %16
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds i8, i8* %597, i64 %599
%601 = call i64 (i8*, i8*, ...) @sprintf(i8* %600, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.32, i64 0, i64 0))
%602 = load i32, i32* %16
%603 = sext i32 %602 to i64
%604 = add nsw i64 %603, %601
%605 = trunc i64 %604 to i32
store i32 %605, i32* %16
store i32 0, i32* %15
br label %767
606: ; preds = %78
%607 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%608 = load i32, i32* %16
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds i8, i8* %607, i64 %609
%611 = call i64 (i8*, i8*, ...) @sprintf(i8* %610, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.33, i64 0, i64 0))
%612 = load i32, i32* %16
%613 = sext i32 %612 to i64
%614 = add nsw i64 %613, %611
%615 = trunc i64 %614 to i32
store i32 %615, i32* %16
store i32 0, i32* %15
br label %767
616: ; preds = %78
%617 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%618 = load i32, i32* %16
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds i8, i8* %617, i64 %619
%621 = call i64 (i8*, i8*, ...) @sprintf(i8* %620, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.34, i64 0, i64 0))
%622 = load i32, i32* %16
%623 = sext i32 %622 to i64
%624 = add nsw i64 %623, %621
%625 = trunc i64 %624 to i32
store i32 %625, i32* %16
store i32 0, i32* %15
br label %767
626: ; preds = %78
%627 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%628 = load i32, i32* %16
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds i8, i8* %627, i64 %629
%631 = call i64 (i8*, i8*, ...) @sprintf(i8* %630, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.35, i64 0, i64 0))
%632 = load i32, i32* %16
%633 = sext i32 %632 to i64
%634 = add nsw i64 %633, %631
%635 = trunc i64 %634 to i32
store i32 %635, i32* %16
%636 = load i32, i32* %10
%637 = icmp sge i32 %636, 12
br i1 %637, label %638, label %751
638: ; preds = %626
%639 = load i8*, i8** %18
%640 = getelementptr inbounds i8, i8* %639, i64 2
%641 = load i8, i8* %640
%642 = zext i8 %641 to i32
%643 = and i32 %642, 1
store i32 %643, i32* %20
%644 = load i8*, i8** %18
%645 = getelementptr inbounds i8, i8* %644, i64 5
%646 = load i8, i8* %645
%647 = zext i8 %646 to i32
%648 = load i32, i32* %20
%649 = icmp ne i32 %648, 0
br i1 %649, label %650, label %656
650: ; preds = %638
%651 = load i8*, i8** %18
%652 = getelementptr inbounds i8, i8* %651, i64 4
%653 = load i8, i8* %652
%654 = zext i8 %653 to i32
%655 = shl i32 %654, 8
br label %657
656: ; preds = %638
br label %657
657: ; preds = %656, %650
%658 = phi i32 [ %655, %650 ], [ 0, %656 ]
%659 = add nsw i32 %647, %658
store i32 %659, i32* %21
%660 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%661 = load i32, i32* %16
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds i8, i8* %660, i64 %662
%664 = load i32, i32* %20
%665 = load i8*, i8** %18
%666 = getelementptr inbounds i8, i8* %665, i64 3
%667 = load i8, i8* %666
%668 = zext i8 %667 to i32
%669 = load i32, i32* %21
%670 = call i64 (i8*, i8*, ...) @sprintf(i8* %663, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.36, i64 0, i64 0), i32 %664, i32 %668, i32 %669)
%671 = load i32, i32* %16
%672 = sext i32 %671 to i64
%673 = add nsw i64 %672, %670
%674 = trunc i64 %673 to i32
store i32 %674, i32* %16
%675 = load i32, i32* %20
%676 = icmp ne i32 %675, 0
br i1 %676, label %677, label %711
677: ; preds = %657
%678 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%679 = load i32, i32* %16
%680 = sext i32 %679 to i64
%681 = getelementptr inbounds i8, i8* %678, i64 %680
%682 = load i8*, i8** %18
%683 = getelementptr inbounds i8, i8* %682, i64 10
%684 = load i8, i8* %683
%685 = zext i8 %684 to i32
%686 = load i8*, i8** %18
%687 = getelementptr inbounds i8, i8* %686, i64 8
%688 = load i8, i8* %687
%689 = zext i8 %688 to i32
%690 = load i8*, i8** %18
%691 = getelementptr inbounds i8, i8* %690, i64 6
%692 = load i8, i8* %691
%693 = zext i8 %692 to i32
%694 = load i8*, i8** %18
%695 = getelementptr inbounds i8, i8* %694, i64 11
%696 = load i8, i8* %695
%697 = zext i8 %696 to i32
%698 = load i8*, i8** %18
%699 = getelementptr inbounds i8, i8* %698, i64 9
%700 = load i8, i8* %699
%701 = zext i8 %700 to i32
%702 = load i8*, i8** %18
%703 = getelementptr inbounds i8, i8* %702, i64 7
%704 = load i8, i8* %703
%705 = zext i8 %704 to i32
%706 = call i64 (i8*, i8*, ...) @sprintf(i8* %681, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.37, i64 0, i64 0), i32 %685, i32 %689, i32 %693, i32 %697, i32 %701, i32 %705)
%707 = load i32, i32* %16
%708 = sext i32 %707 to i64
%709 = add nsw i64 %708, %706
%710 = trunc i64 %709 to i32
store i32 %710, i32* %16
br label %733
711: ; preds = %657
%712 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%713 = load i32, i32* %16
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds i8, i8* %712, i64 %714
%716 = load i8*, i8** %18
%717 = getelementptr inbounds i8, i8* %716, i64 11
%718 = load i8, i8* %717
%719 = zext i8 %718 to i32
%720 = load i8*, i8** %18
%721 = getelementptr inbounds i8, i8* %720, i64 9
%722 = load i8, i8* %721
%723 = zext i8 %722 to i32
%724 = load i8*, i8** %18
%725 = getelementptr inbounds i8, i8* %724, i64 7
%726 = load i8, i8* %725
%727 = zext i8 %726 to i32
%728 = call i64 (i8*, i8*, ...) @sprintf(i8* %715, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.38, i64 0, i64 0), i32 %719, i32 %723, i32 %727)
%729 = load i32, i32* %16
%730 = sext i32 %729 to i64
%731 = add nsw i64 %730, %728
%732 = trunc i64 %731 to i32
store i32 %732, i32* %16
br label %733
733: ; preds = %711, %677
%734 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%735 = load i32, i32* %16
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds i8, i8* %734, i64 %736
%738 = load i8*, i8** %18
%739 = getelementptr inbounds i8, i8* %738, i64 12
%740 = load i8, i8* %739
%741 = zext i8 %740 to i32
%742 = load i8*, i8** %18
%743 = getelementptr inbounds i8, i8* %742, i64 13
%744 = load i8, i8* %743
%745 = zext i8 %744 to i32
%746 = call i64 (i8*, i8*, ...) @sprintf(i8* %737, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.39, i64 0, i64 0), i32 %741, i32 %745)
%747 = load i32, i32* %16
%748 = sext i32 %747 to i64
%749 = add nsw i64 %748, %746
%750 = trunc i64 %749 to i32
store i32 %750, i32* %16
br label %752
751: ; preds = %626
store i32 0, i32* %15
br label %752
752: ; preds = %751, %733
br label %767
753: ; preds = %78
%754 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%755 = load i32, i32* %16
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds i8, i8* %754, i64 %756
%758 = load i8*, i8** %18
%759 = getelementptr inbounds i8, i8* %758, i64 0
%760 = load i8, i8* %759
%761 = zext i8 %760 to i32
%762 = call i64 (i8*, i8*, ...) @sprintf(i8* %757, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.40, i64 0, i64 0), i32 %761)
%763 = load i32, i32* %16
%764 = sext i32 %763 to i64
%765 = add nsw i64 %764, %762
%766 = trunc i64 %765 to i32
store i32 %766, i32* %16
store i32 0, i32* %15
br label %767
767: ; preds = %753, %752, %616, %606, %596, %595, %563, %488, %460, %215, %158
%768 = load i32, i32* %15
%769 = icmp ne i32 %768, 0
br i1 %769, label %844, label %770
770: ; preds = %767
%771 = load i32, i32* %10
%772 = icmp sgt i32 %771, 0
br i1 %772, label %773, label %843
773: ; preds = %770
%774 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%775 = load i32, i32* %16
%776 = sext i32 %775 to i64
%777 = getelementptr inbounds i8, i8* %774, i64 %776
%778 = call i64 (i8*, i8*, ...) @sprintf(i8* %777, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.41, i64 0, i64 0))
%779 = load i32, i32* %16
%780 = sext i32 %779 to i64
%781 = add nsw i64 %780, %778
%782 = trunc i64 %781 to i32
store i32 %782, i32* %16
store i32 0, i32* %13
br label %783
783: ; preds = %830, %773
%784 = load i32, i32* %13
%785 = load i32, i32* %10
%786 = icmp slt i32 %784, %785
br i1 %786, label %787, label %794
787: ; preds = %783
%788 = load i32, i32* %12
%789 = load i32, i32* %13
%790 = add nsw i32 %788, %789
%791 = add nsw i32 %790, 2
%792 = load i32, i32* %9
%793 = icmp slt i32 %791, %792
br label %794
794: ; preds = %787, %783
%795 = phi i1 [ false, %783 ], [ %793, %787 ]
br i1 %795, label %796, label %833
796: ; preds = %794
%797 = load i32, i32* %13
%798 = icmp sgt i32 %797, 0
br i1 %798, label %799, label %813
799: ; preds = %796
%800 = load i32, i32* %13
%801 = srem i32 %800, 24
%802 = icmp eq i32 0, %801
br i1 %802, label %803, label %813
803: ; preds = %799
%804 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%805 = load i32, i32* %16
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds i8, i8* %804, i64 %806
%808 = call i64 (i8*, i8*, ...) @sprintf(i8* %807, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.42, i64 0, i64 0))
%809 = load i32, i32* %16
%810 = sext i32 %809 to i64
%811 = add nsw i64 %810, %808
%812 = trunc i64 %811 to i32
store i32 %812, i32* %16
br label %813
813: ; preds = %803, %799, %796
%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 i8*, i8** %18
%819 = load i32, i32* %13
%820 = add nsw i32 %819, 2
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds i8, i8* %818, i64 %821
%823 = load i8, i8* %822
%824 = zext i8 %823 to i32
%825 = call i64 (i8*, i8*, ...) @sprintf(i8* %817, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.43, i64 0, i64 0), i32 %824)
%826 = load i32, i32* %16
%827 = sext i32 %826 to i64
%828 = add nsw i64 %827, %825
%829 = trunc i64 %828 to i32
store i32 %829, i32* %16
br label %830
830: ; preds = %813
%831 = load i32, i32* %13
%832 = add nsw i32 %831, 1
store i32 %832, i32* %13
br label %783
833: ; preds = %794
%834 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%835 = load i32, i32* %16
%836 = sext i32 %835 to i64
%837 = getelementptr inbounds i8, i8* %834, i64 %836
%838 = call i64 (i8*, i8*, ...) @sprintf(i8* %837, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%839 = load i32, i32* %16
%840 = sext i32 %839 to i64
%841 = add nsw i64 %840, %838
%842 = trunc i64 %841 to i32
store i32 %842, i32* %16
br label %843
843: ; preds = %833, %770
br label %844
844: ; preds = %843, %767
%845 = load i32, i32* %10
%846 = icmp slt i32 %845, 0
br i1 %846, label %847, label %857
847: ; preds = %844
%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 = call i64 (i8*, i8*, ...) @sprintf(i8* %851, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.44, i64 0, i64 0))
%853 = load i32, i32* %16
%854 = sext i32 %853 to i64
%855 = add nsw i64 %854, %852
%856 = trunc i64 %855 to i32
store i32 %856, i32* %16
br label %857
857: ; preds = %847, %844
%858 = load i8*, i8** %8
%859 = call i32 @strlen(i8* %858)
store i32 %859, i32* %13
%860 = load i32, i32* %16
%861 = load i32, i32* %13
%862 = add nsw i32 %860, %861
%863 = load i32, i32* %7
%864 = icmp sge i32 %862, %863
br i1 %864, label %865, label %880
865: ; preds = %857
%866 = load i8*, i8** %8
%867 = load i32, i32* %13
%868 = sext i32 %867 to i64
%869 = getelementptr inbounds i8, i8* %866, i64 %868
%870 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%871 = load i32, i32* %7
%872 = load i32, i32* %13
%873 = sub nsw i32 %871, %872
%874 = call i32 @strncpy(i8* %869, i8* %870, i32 %873)
%875 = load i8*, i8** %8
%876 = load i32, i32* %7
%877 = sub nsw i32 %876, 1
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds i8, i8* %875, i64 %878
store i8 0, i8* %879
br label %895
880: ; preds = %857
%881 = load i8*, i8** %8
%882 = load i32, i32* %13
%883 = sext i32 %882 to i64
%884 = getelementptr inbounds i8, i8* %881, i64 %883
%885 = getelementptr inbounds [256 x i8], [256 x i8]* %19, i64 0, i64 0
%886 = call i32 @strcpy(i8* %884, i8* %885)
%887 = load i32, i32* %10
%888 = icmp slt i32 %887, 0
br i1 %888, label %889, label %890
889: ; preds = %880
br label %895
890: ; preds = %880
br label %891
891: ; preds = %890
%892 = load i32, i32* %11
%893 = load i32, i32* %12
%894 = add nsw i32 %893, %892
store i32 %894, i32* %12
br label %59
895: ; preds = %27, %39, %889, %865, %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 = [37 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 = [29 x i8] c" Sense_key: 0x%x unexpected\0A\00"
@.str.22 = [24 x i8] c"Field replaceable unit\0A\00"
@.str.23 = [15 x i8] c" code=0x%x\0A\00"
@.str.24 = [17 x i8] c"Stream commands\0A\00"
@.str.25 = [13 x i8] c" FILEMARK\00"
@.str.26 = [24 x i8] c" End Of Medium (EOM)\00"
@.str.27 = [37 x i8] c" Incorrect Length Indicator (ILI)\00"
@.str.28 = [16 x i8] c"Block commands\0A\00"
@.str.29 = [41 x i8] c" Incorrect Length Indicator (ILI) %s\0A\00"
@.str.30 = [4 x i8] c"set\00"
@.str.31 = [6 x i8] c"clear\00"
@.str.32 = [27 x i8] c"OSD object identification\0A\00"
@.str.33 = [36 x i8] c"OSD response integrity check value\0A\00"
@.str.34 = [30 x i8] c"OSD attribute identification\0A\00"
@.str.35 = [12 x i8] c"ATA Return\0A\00"
@.str.36 = [48 x i8] c" extended=%d error=0x%x sector_count=0x%x\0A\00"
@.str.37 = [36 x i8] c" lba=0x%02x%02x%02x%02x%02x%02x\0A\00"
@.str.38 = [24 x i8] c" lba=0x%02x%02x%02x\0A\00"
@.str.39 = [30 x i8] c" device=0x%x status=0x%x\0A\00"
@.str.40 = [35 x i8] c"Unknown or vendor specific [0x%x]\0A\00"
@.str.41 = [5 x i8] c" \00"
@.str.42 = [6 x i8] c"\0A \00"
@.str.43 = [6 x i8] c"%02x \00"
@.str.44 = [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 %652, label %10
10: ; preds = %4
store i8 0, i8* %3
%11 = icmp slt i32 %1, 8
br i1 %11, label %652, 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 %652, 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 %652, label %26
26: ; preds = %17
%27 = getelementptr inbounds i8, i8* %0, i64 8
%28 = add nsw i32 %20, -1
br label %29
29: ; preds = %647, %26
%30 = phi i32 [ 0, %26 ], [ %42, %647 ]
%31 = phi i8* [ %27, %26 ], [ %34, %647 ]
%32 = phi i32 [ 0, %26 ], [ %649, %647 ]
%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 %567 [
i8 0, label %45
i8 1, label %133
i8 2, label %218
i8 3, label %372
i8 4, label %391
i8 5, label %441
i8 6, label %462
i8 7, label %469
i8 8, label %476
i8 9, label %483
]
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 %575
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 %578, 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 %633
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 %633
216: ; preds = %133
%217 = trunc i64 %138 to i32
br label %575
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 %365 [
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
]
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 %575
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 %633
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 %633
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 %575
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 %633
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 %575
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 %633
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 %575
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 ([37 x i8], [37 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 %633
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 %633
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 ([29 x i8], [29 x i8]* @.str.21, i64 0, i64 0), i32 %24)
%370 = add i64 %369, %223
%371 = trunc i64 %370 to i32
br label %575
372: ; preds = %40
%373 = shl i64 %43, 32
%374 = ashr exact i64 %373, 32
%375 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %374
%376 = call i64 (i8*, i8*, ...) @sprintf(i8* %375, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.22, i64 0, i64 0))
%377 = add i64 %376, %43
%378 = icmp sgt i32 %41, 1
br i1 %378, label %379, label %389
379: ; preds = %372
%380 = shl i64 %377, 32
%381 = ashr exact i64 %380, 32
%382 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %381
%383 = getelementptr inbounds i8, i8* %34, i64 3
%384 = load i8, i8* %383
%385 = zext i8 %384 to i32
%386 = call i64 (i8*, i8*, ...) @sprintf(i8* %382, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), i32 %385)
%387 = add i64 %386, %377
%388 = trunc i64 %387 to i32
br label %633
389: ; preds = %372
%390 = trunc i64 %377 to i32
br label %575
391: ; preds = %40
%392 = shl i64 %43, 32
%393 = ashr exact i64 %392, 32
%394 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %393
%395 = call i64 (i8*, i8*, ...) @sprintf(i8* %394, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.24, i64 0, i64 0))
%396 = add i64 %395, %43
%397 = trunc i64 %396 to i32
%398 = icmp sgt i32 %41, 1
br i1 %398, label %399, label %575
399: ; preds = %391
%400 = getelementptr inbounds i8, i8* %34, i64 3
%401 = load i8, i8* %400
%402 = icmp sgt i8 %401, -1
br i1 %402, label %411, label %403
403: ; preds = %399
%404 = shl i64 %396, 32
%405 = ashr exact i64 %404, 32
%406 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %405
%407 = call i64 (i8*, i8*, ...) @sprintf(i8* %406, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.25, i64 0, i64 0))
%408 = add i64 %407, %396
%409 = trunc i64 %408 to i32
%410 = load i8, i8* %400
br label %411
411: ; preds = %403, %399
%412 = phi i8 [ %410, %403 ], [ %401, %399 ]
%413 = phi i32 [ %409, %403 ], [ %397, %399 ]
%414 = and i8 %412, 64
%415 = icmp eq i8 %414, 0
br i1 %415, label %423, label %416
416: ; preds = %411
%417 = sext i32 %413 to i64
%418 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %417
%419 = call i64 (i8*, i8*, ...) @sprintf(i8* %418, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.26, i64 0, i64 0))
%420 = trunc i64 %419 to i32
%421 = add i32 %413, %420
%422 = load i8, i8* %400
br label %423
423: ; preds = %416, %411
%424 = phi i8 [ %422, %416 ], [ %412, %411 ]
%425 = phi i32 [ %421, %416 ], [ %413, %411 ]
%426 = and i8 %424, 32
%427 = icmp eq i8 %426, 0
br i1 %427, label %434, label %428
428: ; preds = %423
%429 = sext i32 %425 to i64
%430 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %429
%431 = call i64 (i8*, i8*, ...) @sprintf(i8* %430, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.27, i64 0, i64 0))
%432 = trunc i64 %431 to i32
%433 = add i32 %425, %432
br label %434
434: ; preds = %428, %423
%435 = phi i32 [ %433, %428 ], [ %425, %423 ]
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %436
%438 = call i64 (i8*, i8*, ...) @sprintf(i8* %437, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%439 = trunc i64 %438 to i32
%440 = add i32 %435, %439
br label %633
441: ; preds = %40
%442 = shl i64 %43, 32
%443 = ashr exact i64 %442, 32
%444 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %443
%445 = call i64 (i8*, i8*, ...) @sprintf(i8* %444, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0))
%446 = add i64 %445, %43
%447 = icmp sgt i32 %41, 1
br i1 %447, label %448, label %460
448: ; preds = %441
%449 = shl i64 %446, 32
%450 = ashr exact i64 %449, 32
%451 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %450
%452 = getelementptr inbounds i8, i8* %34, i64 3
%453 = load i8, i8* %452
%454 = and i8 %453, 32
%455 = icmp eq i8 %454, 0
%456 = select i1 %455, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.31, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.30, i64 0, i64 0)
%457 = call i64 (i8*, i8*, ...) @sprintf(i8* %451, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.29, i64 0, i64 0), i8* %456)
%458 = add i64 %457, %446
%459 = trunc i64 %458 to i32
br label %633
460: ; preds = %441
%461 = trunc i64 %446 to i32
br label %575
462: ; preds = %40
%463 = shl i64 %43, 32
%464 = ashr exact i64 %463, 32
%465 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %464
%466 = call i64 (i8*, i8*, ...) @sprintf(i8* %465, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.32, i64 0, i64 0))
%467 = add i64 %466, %43
%468 = trunc i64 %467 to i32
br label %575
469: ; preds = %40
%470 = shl i64 %43, 32
%471 = ashr exact i64 %470, 32
%472 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %471
%473 = call i64 (i8*, i8*, ...) @sprintf(i8* %472, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.33, i64 0, i64 0))
%474 = add i64 %473, %43
%475 = trunc i64 %474 to i32
br label %575
476: ; preds = %40
%477 = shl i64 %43, 32
%478 = ashr exact i64 %477, 32
%479 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %478
%480 = call i64 (i8*, i8*, ...) @sprintf(i8* %479, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.34, i64 0, i64 0))
%481 = add i64 %480, %43
%482 = trunc i64 %481 to i32
br label %575
483: ; preds = %40
%484 = shl i64 %43, 32
%485 = ashr exact i64 %484, 32
%486 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %485
%487 = call i64 (i8*, i8*, ...) @sprintf(i8* %486, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.35, i64 0, i64 0))
%488 = add i64 %487, %43
%489 = icmp sgt i32 %41, 11
br i1 %489, label %490, label %565
490: ; preds = %483
%491 = getelementptr inbounds i8, i8* %34, i64 2
%492 = load i8, i8* %491
%493 = and i8 %492, 1
%494 = zext i8 %493 to i32
%495 = getelementptr inbounds i8, i8* %34, i64 5
%496 = load i8, i8* %495
%497 = zext i8 %496 to i32
%498 = icmp eq i8 %493, 0
br i1 %498, label %504, label %499
499: ; preds = %490
%500 = getelementptr inbounds i8, i8* %34, i64 4
%501 = load i8, i8* %500
%502 = zext i8 %501 to i32
%503 = shl nuw nsw i32 %502, 8
br label %504
504: ; preds = %490, %499
%505 = phi i32 [ %503, %499 ], [ 0, %490 ]
%506 = or i32 %505, %497
%507 = shl i64 %488, 32
%508 = ashr exact i64 %507, 32
%509 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %508
%510 = getelementptr inbounds i8, i8* %34, i64 3
%511 = load i8, i8* %510
%512 = zext i8 %511 to i32
%513 = call i64 (i8*, i8*, ...) @sprintf(i8* %509, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.36, i64 0, i64 0), i32 %494, i32 %512, i32 %506)
%514 = add i64 %513, %488
%515 = shl i64 %514, 32
%516 = ashr exact i64 %515, 32
%517 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %516
br i1 %498, label %539, label %518
518: ; preds = %504
%519 = getelementptr inbounds i8, i8* %34, i64 10
%520 = load i8, i8* %519
%521 = zext i8 %520 to i32
%522 = getelementptr inbounds i8, i8* %34, i64 8
%523 = load i8, i8* %522
%524 = zext i8 %523 to i32
%525 = getelementptr inbounds i8, i8* %34, i64 6
%526 = load i8, i8* %525
%527 = zext i8 %526 to i32
%528 = getelementptr inbounds i8, i8* %34, i64 11
%529 = load i8, i8* %528
%530 = zext i8 %529 to i32
%531 = getelementptr inbounds i8, i8* %34, i64 9
%532 = load i8, i8* %531
%533 = zext i8 %532 to i32
%534 = getelementptr inbounds i8, i8* %34, i64 7
%535 = load i8, i8* %534
%536 = zext i8 %535 to i32
%537 = call i64 (i8*, i8*, ...) @sprintf(i8* %517, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.37, i64 0, i64 0), i32 %521, i32 %524, i32 %527, i32 %530, i32 %533, i32 %536)
%538 = add nsw i64 %537, %516
br label %551
539: ; preds = %504
%540 = getelementptr inbounds i8, i8* %34, i64 11
%541 = load i8, i8* %540
%542 = zext i8 %541 to i32
%543 = getelementptr inbounds i8, i8* %34, i64 9
%544 = load i8, i8* %543
%545 = zext i8 %544 to i32
%546 = getelementptr inbounds i8, i8* %34, i64 7
%547 = load i8, i8* %546
%548 = zext i8 %547 to i32
%549 = call i64 (i8*, i8*, ...) @sprintf(i8* %517, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.38, i64 0, i64 0), i32 %542, i32 %545, i32 %548)
%550 = add i64 %549, %514
br label %551
551: ; preds = %539, %518
%552 = phi i64 [ %538, %518 ], [ %550, %539 ]
%553 = shl i64 %552, 32
%554 = ashr exact i64 %553, 32
%555 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %554
%556 = getelementptr inbounds i8, i8* %34, i64 12
%557 = load i8, i8* %556
%558 = zext i8 %557 to i32
%559 = getelementptr inbounds i8, i8* %34, i64 13
%560 = load i8, i8* %559
%561 = zext i8 %560 to i32
%562 = call i64 (i8*, i8*, ...) @sprintf(i8* %555, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.39, i64 0, i64 0), i32 %558, i32 %561)
%563 = add i64 %562, %552
%564 = trunc i64 %563 to i32
br label %633
565: ; preds = %483
%566 = trunc i64 %488 to i32
br label %575
567: ; preds = %40
%568 = zext i8 %44 to i32
%569 = shl i64 %43, 32
%570 = ashr exact i64 %569, 32
%571 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %570
%572 = call i64 (i8*, i8*, ...) @sprintf(i8* %571, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.40, i64 0, i64 0), i32 %568)
%573 = add i64 %572, %43
%574 = trunc i64 %573 to i32
br label %575
575: ; preds = %391, %45, %565, %460, %389, %231, %275, %297, %328, %365, %216, %567, %476, %469, %462
%576 = phi i32 [ %566, %565 ], [ %461, %460 ], [ %390, %389 ], [ %232, %231 ], [ %276, %275 ], [ %303, %297 ], [ %329, %328 ], [ %371, %365 ], [ %217, %216 ], [ %574, %567 ], [ %482, %476 ], [ %475, %469 ], [ %468, %462 ], [ %51, %45 ], [ %397, %391 ]
%577 = icmp sgt i32 %41, 0
br i1 %577, label %578, label %624
578: ; preds = %53, %575
%579 = phi i32 [ %576, %575 ], [ %51, %53 ]
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %580
%582 = call i64 (i8*, i8*, ...) @sprintf(i8* %581, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.41, i64 0, i64 0))
%583 = trunc i64 %582 to i32
%584 = add i32 %579, %583
%585 = zext i32 %41 to i64
br label %586
586: ; preds = %578, %604
%587 = phi i64 [ 0, %578 ], [ %615, %604 ]
%588 = phi i32 [ %584, %578 ], [ %614, %604 ]
%589 = trunc i64 %587 to i32
%590 = add nuw nsw i32 %589, 2
%591 = add i32 %590, %32
%592 = icmp slt i32 %591, %20
br i1 %592, label %593, label %617
593: ; preds = %586
%594 = icmp ne i64 %587, 0
%595 = urem i32 %589, 24
%596 = icmp eq i32 %595, 0
%597 = and i1 %594, %596
br i1 %597, label %598, label %604
598: ; preds = %593
%599 = sext i32 %588 to i64
%600 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %599
%601 = call i64 (i8*, i8*, ...) @sprintf(i8* %600, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.42, i64 0, i64 0))
%602 = trunc i64 %601 to i32
%603 = add i32 %588, %602
br label %604
604: ; preds = %598, %593
%605 = phi i32 [ %603, %598 ], [ %588, %593 ]
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %606
%608 = add nuw nsw i64 %587, 2
%609 = getelementptr inbounds i8, i8* %34, i64 %608
%610 = load i8, i8* %609
%611 = zext i8 %610 to i32
%612 = call i64 (i8*, i8*, ...) @sprintf(i8* %607, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.43, i64 0, i64 0), i32 %611)
%613 = trunc i64 %612 to i32
%614 = add i32 %605, %613
%615 = add nuw nsw i64 %587, 1
%616 = icmp eq i64 %615, %585
br i1 %616, label %617, label %586
617: ; preds = %586, %604
%618 = phi i32 [ %614, %604 ], [ %588, %586 ]
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %619
%621 = call i64 (i8*, i8*, ...) @sprintf(i8* %620, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
%622 = trunc i64 %621 to i32
%623 = add i32 %618, %622
br label %624
624: ; preds = %617, %575
%625 = phi i32 [ %623, %617 ], [ %576, %575 ]
%626 = icmp slt i32 %41, 0
br i1 %626, label %627, label %633
627: ; preds = %624
%628 = sext i32 %625 to i64
%629 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %628
%630 = call i64 (i8*, i8*, ...) @sprintf(i8* %629, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.44, i64 0, i64 0))
%631 = trunc i64 %630 to i32
%632 = add i32 %625, %631
br label %633
633: ; preds = %140, %57, %551, %448, %434, %379, %277, %304, %264, %259, %361, %356, %627, %624
%634 = phi i1 [ false, %627 ], [ true, %624 ], [ true, %356 ], [ true, %361 ], [ true, %259 ], [ true, %264 ], [ true, %304 ], [ true, %277 ], [ true, %379 ], [ true, %434 ], [ true, %448 ], [ true, %551 ], [ true, %57 ], [ true, %140 ]
%635 = phi i32 [ %632, %627 ], [ %625, %624 ], [ %360, %356 ], [ %364, %361 ], [ %263, %259 ], [ %267, %264 ], [ %320, %304 ], [ %289, %277 ], [ %388, %379 ], [ %440, %434 ], [ %459, %448 ], [ %564, %551 ], [ %132, %57 ], [ %215, %140 ]
%636 = call i32 @strlen(i8* %3)
%637 = add nsw i32 %636, %635
%638 = icmp slt i32 %637, %2
%639 = sext i32 %636 to i64
%640 = getelementptr inbounds i8, i8* %3, i64 %639
br i1 %638, label %647, label %641
641: ; preds = %633
%642 = sub nsw i32 %2, %636
%643 = call i32 @strncpy(i8* %640, i8* %6, i32 %642)
%644 = add nsw i32 %2, -1
%645 = zext i32 %644 to i64
%646 = getelementptr inbounds i8, i8* %3, i64 %645
store i8 0, i8* %646
br label %652
647: ; preds = %633
%648 = call i32 @strcpy(i8* %640, i8* %6)
%649 = add nsw i32 %42, %32
%650 = icmp slt i32 %649, %20
%651 = select i1 %634, i1 %650, i1 false
br i1 %651, label %29, label %652
652: ; preds = %647, %17, %641, %10, %12, %4
ret void
}