#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 */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int);
int /*<<< orphan*/ printf(char *, int, int, int, int, int, int, int, int);
int /*<<< orphan*/ stderr;
int decode_tapealert_supported_vpd(unsigned char *b, int len) {
  if (len < 12) {
    fprintf(stderr, "TapeAlert supported flags length too short=%d\n", len);
    return 97;
  }
  printf("  Flag01h: %d  02h: %d  03h: %d  04h: %d  05h: %d  06h: %d  "
         "07h: %d  08h: %d\n",
         !!(b[4] & 0x80), !!(b[4] & 0x40), !!(b[4] & 0x20), !!(b[4] & 0x10),
         !!(b[4] & 0x8), !!(b[4] & 0x4), !!(b[4] & 0x2), !!(b[4] & 0x1));
  printf("  Flag09h: %d  0ah: %d  0bh: %d  0ch: %d  0dh: %d  0eh: %d  "
         "0fh: %d  10h: %d\n",
         !!(b[5] & 0x80), !!(b[5] & 0x40), !!(b[5] & 0x20), !!(b[5] & 0x10),
         !!(b[5] & 0x8), !!(b[5] & 0x4), !!(b[5] & 0x2), !!(b[5] & 0x1));
  printf("  Flag11h: %d  12h: %d  13h: %d  14h: %d  15h: %d  16h: %d  "
         "17h: %d  18h: %d\n",
         !!(b[6] & 0x80), !!(b[6] & 0x40), !!(b[6] & 0x20), !!(b[6] & 0x10),
         !!(b[6] & 0x8), !!(b[6] & 0x4), !!(b[6] & 0x2), !!(b[6] & 0x1));
  printf("  Flag19h: %d  1ah: %d  1bh: %d  1ch: %d  1dh: %d  1eh: %d  "
         "1fh: %d  20h: %d\n",
         !!(b[7] & 0x80), !!(b[7] & 0x40), !!(b[7] & 0x20), !!(b[7] & 0x10),
         !!(b[7] & 0x8), !!(b[7] & 0x4), !!(b[7] & 0x2), !!(b[7] & 0x1));
  printf("  Flag21h: %d  22h: %d  23h: %d  24h: %d  25h: %d  26h: %d  "
         "27h: %d  28h: %d\n",
         !!(b[8] & 0x80), !!(b[8] & 0x40), !!(b[8] & 0x20), !!(b[8] & 0x10),
         !!(b[8] & 0x8), !!(b[8] & 0x4), !!(b[8] & 0x2), !!(b[8] & 0x1));
  printf("  Flag29h: %d  2ah: %d  2bh: %d  2ch: %d  2dh: %d  2eh: %d  "
         "2fh: %d  30h: %d\n",
         !!(b[9] & 0x80), !!(b[9] & 0x40), !!(b[9] & 0x20), !!(b[9] & 0x10),
         !!(b[9] & 0x8), !!(b[9] & 0x4), !!(b[9] & 0x2), !!(b[9] & 0x1));
  printf("  Flag31h: %d  32h: %d  33h: %d  34h: %d  35h: %d  36h: %d  "
         "37h: %d  38h: %d\n",
         !!(b[10] & 0x80), !!(b[10] & 0x40), !!(b[10] & 0x20), !!(b[10] & 0x10),
         !!(b[10] & 0x8), !!(b[10] & 0x4), !!(b[10] & 0x2), !!(b[10] & 0x1));
  printf("  Flag39h: %d  3ah: %d  3bh: %d  3ch: %d  3dh: %d  3eh: %d  "
         "3fh: %d  40h: %d\n",
         !!(b[11] & 0x80), !!(b[11] & 0x40), !!(b[11] & 0x20), !!(b[11] & 0x10),
         !!(b[11] & 0x8), !!(b[11] & 0x4), !!(b[11] & 0x2), !!(b[11] & 0x1));
  return 0;
}


x86 assembly (clang, -O0):
<decode_tapealert_supported_vpd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
cmpl   $0xc,-0x14(%rbp)
jge    115d <decode_tapealert_supported_vpd+0x3d>
mov    0x2ea0(%rip),%rax
mov    (%rax),%edi
mov    -0x14(%rbp),%edx
lea    0xeb4(%rip),%rsi
call   1040 <fprintf@plt>
movl   $0x61,-0x4(%rbp)
jmp    18dc <decode_tapealert_supported_vpd+0x7bc>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r10d
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
lea    0xdf5(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r10d
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
lea    0xd54(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r10d
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
lea    0xcb3(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r10d
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
lea    0xc12(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r10d
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
lea    0xb71(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r10d
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
lea    0xad0(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r10d
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
lea    0xa2f(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%esi
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r8d
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r9d
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r11d
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
and    $0x2,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%r10d
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
lea    0x98e(%rip),%rdi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decode_tapealert_supported_vpd>:
push   %r14
push   %rbx
push   %rax
cmp    $0xb,%esi
jg     114a <decode_tapealert_supported_vpd+0x2a>
mov    %esi,%edx
mov    0x2eae(%rip),%rax
mov    (%rax),%edi
lea    0xec5(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x61,%eax
jmp    1436 <decode_tapealert_supported_vpd+0x316>
mov    %rdi,%r14
movzbl 0x4(%rdi),%eax
mov    %eax,%esi
shr    $0x7,%esi
mov    %eax,%edx
shr    $0x6,%edx
and    $0x1,%edx
mov    %eax,%ecx
shr    $0x5,%ecx
and    $0x1,%ecx
mov    %eax,%r8d
shr    $0x4,%r8d
and    $0x1,%r8d
mov    %eax,%r9d
shr    $0x3,%r9d
and    $0x1,%r9d
mov    %eax,%r10d
shr    $0x2,%r10d
and    $0x1,%r10d
mov    %eax,%ebx
shr    %ebx
and    $0x1,%ebx
and    $0x1,%eax
sub    $0x8,%rsp
lea    0xe93(%rip),%rdi
push   %rax
push   %rbx
push   %r10
call   1030 <printf@plt>
add    $0x20,%rsp
movzbl 0x5(%r14),%eax
mov    %eax,%esi
shr    $0x7,%esi
mov    %eax,%edx
shr    $0x6,%edx
and    $0x1,%edx
mov    %eax,%ecx
shr    $0x5,%ecx
and    $0x1,%ecx
mov    %eax,%r8d
shr    $0x4,%r8d
and    $0x1,%r8d
mov    %eax,%r9d
shr    $0x3,%r9d
and    $0x1,%r9d
mov    %eax,%r10d
shr    $0x2,%r10d
and    $0x1,%r10d
mov    %eax,%ebx
shr    %ebx
and    $0x1,%ebx
and    $0x1,%eax
sub    $0x8,%rsp
lea    0xe84(%rip),%rdi
push   %rax
push   %rbx
push   %r10
call   1030 <printf@plt>
add    $0x20,%rsp
movzbl 0x6(%r14),%eax
mov    %eax,%esi
shr    $0x7,%esi
mov    %eax,%edx
shr    $0x6,%edx
and    $0x1,%edx
mov    %eax,%ecx
shr    $0x5,%ecx
and    $0x1,%ecx
mov    %eax,%r8d
shr    $0x4,%r8d
and    $0x1,%r8d
mov    %eax,%r9d
shr    $0x3,%r9d
and    $0x1,%r9d
mov    %eax,%r10d
shr    $0x2,%r10d
and    $0x1,%r10d
mov    %eax,%ebx
shr    %ebx
and    $0x1,%ebx
and    $0x1,%eax
sub    $0x8,%rsp
lea    0xe75(%rip),%rdi
push   %rax
push   %rbx
push   %r10
call   1030 <printf@plt>
add    $0x20,%rsp
movzbl 0x7(%r14),%eax
mov    %eax,%esi
shr    $0x7,%esi
mov    %eax,%edx
shr    $0x6,%edx
and    $0x1,%edx
mov    %eax,%ecx
shr    $0x5,%ecx
and    $0x1,%ecx
mov    %eax,%r8d
shr    $0x4,%r8d
and    $0x1,%r8d
mov    %eax,%r9d
shr    $0x3,%r9d
and    $0x1,%r9d
mov    %eax,%r10d
shr    $0x2,%r10d
and    $0x1,%r10d
mov    %eax,%ebx
shr    %ebx
and    $0x1,%ebx
and    $0x1,%eax
sub    $0x8,%rsp
lea    0xe66(%rip),%rdi
push   %rax
push   %rbx
push   %r10
call   1030 <printf@plt>
add    $0x20,%rsp
movzbl 0x8(%r14),%eax
mov    %eax,%esi
shr    $0x7,%esi
mov    %eax,%edx
shr    $0x6,%edx
and    $0x1,%edx
mov    %eax,%ecx
shr    $0x5,%ecx
and    $0x1,%ecx
mov    %eax,%r8d
shr    $0x4,%r8d
and    $0x1,%r8d
mov    %eax,%r9d
shr    $0x3,%r9d
and    $0x1,%r9d
mov    %eax,%r10d
shr    $0x2,%r10d
and    $0x1,%r10d
mov    %eax,%ebx
shr    %ebx
and    $0x1,%ebx
and    $0x1,%eax
sub    $0x8,%rsp
lea    0xe57(%rip),%rdi
push   %rax
push   %rbx
push   %r10
call   1030 <printf@plt>
add    $0x20,%rsp
movzbl 0x9(%r14),%eax
mov    %eax,%esi
shr    $0x7,%esi
mov    %eax,%edx
shr    $0x6,%edx
and    $0x1,%edx
mov    %eax,%ecx
shr    $0x5,%ecx
and    $0x1,%ecx
mov    %eax,%r8d
shr    $0x4,%r8d
and    $0x1,%r8d
mov    %eax,%r9d
shr    $0x3,%r9d
and    $0x1,%r9d
mov    %eax,%r10d
shr    $0x2,%r10d
and    $0x1,%r10d
mov    %eax,%ebx
shr    %ebx
and    $0x1,%ebx
and    $0x1,%eax
sub    $0x8,%rsp
lea    0xe48(%rip),%rdi
push   %rax
push   %rbx
push   %r10
call   1030 <printf@plt>
add    $0x20,%rsp
movzbl 0xa(%r14),%eax
mov    %eax,%esi
shr    $0x7,%esi
mov    %eax,%edx
shr    $0x6,%edx
and    $0x1,%edx
mov    %eax,%ecx
shr    $0x5,%ecx
and    $0x1,%ecx
mov    %eax,%r8d
shr    $0x4,%r8d
and    $0x1,%r8d
mov    %eax,%r9d
shr    $0x3,%r9d
and    $0x1,%r9d
mov    %eax,%r10d
shr    $0x2,%r10d
and    $0x1,%r10d
mov    %eax,%ebx
shr    %ebx
and    $0x1,%ebx
and    $0x1,%eax
sub    $0x8,%rsp
lea    0xe39(%rip),%rdi
push   %rax
push   %rbx
push   %r10
call   1030 <printf@plt>
add    $0x20,%rsp
movzbl 0xb(%r14),%eax
mov    %eax,%esi
shr    $0x7,%esi
mov    %eax,%edx
shr    $0x6,%edx
and    $0x1,%edx
mov    %eax,%ecx
shr    $0x5,%ecx
and    $0x1,%ecx
mov    %eax,%r8d
shr    $0x4,%r8d
and    $0x1,%r8d
mov    %eax,%r9d
shr    $0x3,%r9d
and    $0x1,%r9d
mov    %eax,%r10d
shr    $0x2,%r10d
and    $0x1,%r10d
mov    %eax,%ebx
shr    %ebx
and    $0x1,%ebx
and    $0x1,%eax
sub    $0x8,%rsp
lea    0xe2a(%rip),%rdi
push   %rax
push   %rbx
push   %r10
call   1030 <printf@plt>
add    $0x20,%rsp
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [47 x i8] c"TapeAlert supported flags length too short=%d\0A\00"
@.str.1 = [78 x i8] c" Flag01h: %d 02h: %d 03h: %d 04h: %d 05h: %d 06h: %d 07h: %d 08h: %d\0A\00"
@.str.2 = [78 x i8] c" Flag09h: %d 0ah: %d 0bh: %d 0ch: %d 0dh: %d 0eh: %d 0fh: %d 10h: %d\0A\00"
@.str.3 = [78 x i8] c" Flag11h: %d 12h: %d 13h: %d 14h: %d 15h: %d 16h: %d 17h: %d 18h: %d\0A\00"
@.str.4 = [78 x i8] c" Flag19h: %d 1ah: %d 1bh: %d 1ch: %d 1dh: %d 1eh: %d 1fh: %d 20h: %d\0A\00"
@.str.5 = [78 x i8] c" Flag21h: %d 22h: %d 23h: %d 24h: %d 25h: %d 26h: %d 27h: %d 28h: %d\0A\00"
@.str.6 = [78 x i8] c" Flag29h: %d 2ah: %d 2bh: %d 2ch: %d 2dh: %d 2eh: %d 2fh: %d 30h: %d\0A\00"
@.str.7 = [78 x i8] c" Flag31h: %d 32h: %d 33h: %d 34h: %d 35h: %d 36h: %d 37h: %d 38h: %d\0A\00"
@.str.8 = [78 x i8] c" Flag39h: %d 3ah: %d 3bh: %d 3ch: %d 3dh: %d 3eh: %d 3fh: %d 40h: %d\0A\00"
define i32 @decode_tapealert_supported_vpd(i8* nocapture %0, i32 %1) {
%3 = icmp slt i32 %1, 12
br i1 %3, label %4, label %7
4: ; preds = %2
%5 = load i32, i32* @stderr
%6 = tail call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str, i64 0, i64 0), i32 %1)
br label %152
7: ; preds = %2
%8 = getelementptr inbounds i8, i8* %0, i64 4
%9 = load i8, i8* %8
%10 = zext i8 %9 to i32
%11 = lshr i32 %10, 7
%12 = lshr i32 %10, 6
%13 = and i32 %12, 1
%14 = lshr i32 %10, 5
%15 = and i32 %14, 1
%16 = lshr i32 %10, 4
%17 = and i32 %16, 1
%18 = lshr i32 %10, 3
%19 = and i32 %18, 1
%20 = lshr i32 %10, 2
%21 = and i32 %20, 1
%22 = lshr i32 %10, 1
%23 = and i32 %22, 1
%24 = and i32 %10, 1
%25 = tail call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.1, i64 0, i64 0), i32 %11, i32 %13, i32 %15, i32 %17, i32 %19, i32 %21, i32 %23, i32 %24)
%26 = getelementptr inbounds i8, i8* %0, i64 5
%27 = load i8, i8* %26
%28 = zext i8 %27 to i32
%29 = lshr i32 %28, 7
%30 = lshr i32 %28, 6
%31 = and i32 %30, 1
%32 = lshr i32 %28, 5
%33 = and i32 %32, 1
%34 = lshr i32 %28, 4
%35 = and i32 %34, 1
%36 = lshr i32 %28, 3
%37 = and i32 %36, 1
%38 = lshr i32 %28, 2
%39 = and i32 %38, 1
%40 = lshr i32 %28, 1
%41 = and i32 %40, 1
%42 = and i32 %28, 1
%43 = tail call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.2, i64 0, i64 0), i32 %29, i32 %31, i32 %33, i32 %35, i32 %37, i32 %39, i32 %41, i32 %42)
%44 = getelementptr inbounds i8, i8* %0, i64 6
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = lshr i32 %46, 7
%48 = lshr i32 %46, 6
%49 = and i32 %48, 1
%50 = lshr i32 %46, 5
%51 = and i32 %50, 1
%52 = lshr i32 %46, 4
%53 = and i32 %52, 1
%54 = lshr i32 %46, 3
%55 = and i32 %54, 1
%56 = lshr i32 %46, 2
%57 = and i32 %56, 1
%58 = lshr i32 %46, 1
%59 = and i32 %58, 1
%60 = and i32 %46, 1
%61 = tail call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.3, i64 0, i64 0), i32 %47, i32 %49, i32 %51, i32 %53, i32 %55, i32 %57, i32 %59, i32 %60)
%62 = getelementptr inbounds i8, i8* %0, i64 7
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = lshr i32 %64, 7
%66 = lshr i32 %64, 6
%67 = and i32 %66, 1
%68 = lshr i32 %64, 5
%69 = and i32 %68, 1
%70 = lshr i32 %64, 4
%71 = and i32 %70, 1
%72 = lshr i32 %64, 3
%73 = and i32 %72, 1
%74 = lshr i32 %64, 2
%75 = and i32 %74, 1
%76 = lshr i32 %64, 1
%77 = and i32 %76, 1
%78 = and i32 %64, 1
%79 = tail call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.4, i64 0, i64 0), i32 %65, i32 %67, i32 %69, i32 %71, i32 %73, i32 %75, i32 %77, i32 %78)
%80 = getelementptr inbounds i8, i8* %0, i64 8
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
%83 = lshr i32 %82, 7
%84 = lshr i32 %82, 6
%85 = and i32 %84, 1
%86 = lshr i32 %82, 5
%87 = and i32 %86, 1
%88 = lshr i32 %82, 4
%89 = and i32 %88, 1
%90 = lshr i32 %82, 3
%91 = and i32 %90, 1
%92 = lshr i32 %82, 2
%93 = and i32 %92, 1
%94 = lshr i32 %82, 1
%95 = and i32 %94, 1
%96 = and i32 %82, 1
%97 = tail call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.5, i64 0, i64 0), i32 %83, i32 %85, i32 %87, i32 %89, i32 %91, i32 %93, i32 %95, i32 %96)
%98 = getelementptr inbounds i8, i8* %0, i64 9
%99 = load i8, i8* %98
%100 = zext i8 %99 to i32
%101 = lshr i32 %100, 7
%102 = lshr i32 %100, 6
%103 = and i32 %102, 1
%104 = lshr i32 %100, 5
%105 = and i32 %104, 1
%106 = lshr i32 %100, 4
%107 = and i32 %106, 1
%108 = lshr i32 %100, 3
%109 = and i32 %108, 1
%110 = lshr i32 %100, 2
%111 = and i32 %110, 1
%112 = lshr i32 %100, 1
%113 = and i32 %112, 1
%114 = and i32 %100, 1
%115 = tail call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.6, i64 0, i64 0), i32 %101, i32 %103, i32 %105, i32 %107, i32 %109, i32 %111, i32 %113, i32 %114)
%116 = getelementptr inbounds i8, i8* %0, i64 10
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = lshr i32 %118, 7
%120 = lshr i32 %118, 6
%121 = and i32 %120, 1
%122 = lshr i32 %118, 5
%123 = and i32 %122, 1
%124 = lshr i32 %118, 4
%125 = and i32 %124, 1
%126 = lshr i32 %118, 3
%127 = and i32 %126, 1
%128 = lshr i32 %118, 2
%129 = and i32 %128, 1
%130 = lshr i32 %118, 1
%131 = and i32 %130, 1
%132 = and i32 %118, 1
%133 = tail call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.7, i64 0, i64 0), i32 %119, i32 %121, i32 %123, i32 %125, i32 %127, i32 %129, i32 %131, i32 %132)
%134 = getelementptr inbounds i8, i8* %0, i64 11
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = lshr i32 %136, 7
%138 = lshr i32 %136, 6
%139 = and i32 %138, 1
%140 = lshr i32 %136, 5
%141 = and i32 %140, 1
%142 = lshr i32 %136, 4
%143 = and i32 %142, 1
%144 = lshr i32 %136, 3
%145 = and i32 %144, 1
%146 = lshr i32 %136, 2
%147 = and i32 %146, 1
%148 = lshr i32 %136, 1
%149 = and i32 %148, 1
%150 = and i32 %136, 1
%151 = tail call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.8, i64 0, i64 0), i32 %137, i32 %139, i32 %141, i32 %143, i32 %145, i32 %147, i32 %149, i32 %150)
br label %152
152: ; preds = %7, %4
%153 = phi i32 [ 97, %4 ], [ 0, %7 ]
ret i32 %153
}