#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 */
typedef struct TYPE_2__ TYPE_1__;

/* Type definitions */
typedef int /*<<< orphan*/ table;
typedef int /*<<< orphan*/ fmt_table;
struct TYPE_2__ {
  int member_0;
  int member_1;
  int member_2;
  int member_3;
  int member_4;
  int member_5;
  int member_6;
};
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ get_mode_string(unsigned char *, char *);
int /*<<< orphan*/ memcmp(unsigned char *, unsigned char *, int);
int /*<<< orphan*/ sprintf(char *, char *, ...);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ strcpy(char *, char *);
void print_f3d(FILE *fout, unsigned char *data) {
  char description[64];
  unsigned char offset;
  unsigned int address;
  unsigned int val;
  description[0] = '\0';
  switch (data[0]) {
  case 0x03:
    switch (data[1]) {
    case 0x86:
      sprintf(description, "light");
      break;
    case 0x88:
      sprintf(description, "dark ");
      break;
    }
    address = (unsigned int)(((&data[4])[0] << 24) + ((&data[4])[1] << 16) +
                             ((&data[4])[2] << 8) + ((&data[4])[3]));
    fprintf(fout, "%14s %s %08X", "F3D_MOVEMEM", description, address);
    break;
  case 0x04:
    offset = data[1];
    val = (((&data[2])[0] << 8) + ((&data[2])[1]));
    address = (unsigned int)(((&data[4])[0] << 24) + ((&data[4])[1] << 16) +
                             ((&data[4])[2] << 8) + ((&data[4])[3]));
    fprintf(fout, "%14s %02X %04X (%d) %08X", "F3D_VTX", offset, val,
            val / 0x10, address);
    break;
  case 0x06:
    address = (unsigned int)(((&data[4])[0] << 24) + ((&data[4])[1] << 16) +
                             ((&data[4])[2] << 8) + ((&data[4])[3]));
    fprintf(fout, "%14s %08X", "F3D_DL", address);
    break;
  case 0xB5: {
    unsigned char vertex[6];
    vertex[0] = data[1] / 0x0A;
    vertex[1] = data[2] / 0x0A;
    vertex[2] = data[3] / 0x0A;
    vertex[3] = data[5] / 0x0A;
    vertex[4] = data[6] / 0x0A;
    vertex[5] = data[7] / 0x0A;
    fprintf(fout, "%14s %3d %3d %3d %3d %3d %3d", "F3D_QUAD", vertex[0],
            vertex[1], vertex[2], vertex[3], vertex[4], vertex[5]);
    break;
  }
  case 0xB6:
    get_mode_string(data, description);
    fprintf(fout, "%14s %s", "F3D_CLRGEOMODE", description);
    break;
  case 0xB7:
    get_mode_string(data, description);
    fprintf(fout, "%14s %s", "F3D_SETGEOMODE", description);
    break;
  case 0xB8:
    fprintf(fout, "%14s %s", "F3D_ENDL", description);
    break;
  case 0xBB:
    switch (data[3]) {
    case 0x00:
      val = (unsigned int)(((&data[4])[0] << 24) + ((&data[4])[1] << 16) +
                           ((&data[4])[2] << 8) + ((&data[4])[3]));
      if (val == 0xFFFFFFFF) {
        sprintf(description, "end, reset scale to 0");
      }
      break;
    case 0x01:
      val = (unsigned int)(((&data[4])[0] << 24) + ((&data[4])[1] << 16) +
                           ((&data[4])[2] << 8) + ((&data[4])[3]));
      if (val == 0xFFFFFFFF) {
        sprintf(description, "start, set scale to 1");
      } else if (val == 0x0F8007C0) {
        sprintf(description, "start environment mapping");
      }
      break;
    }
    fprintf(fout, "%14s %s", "F3D_TEXTURE", description);
    break;
  case 0xBF: {
    unsigned char vertex[3];
    vertex[0] = data[5] / 0x0A;
    vertex[1] = data[6] / 0x0A;
    vertex[2] = data[7] / 0x0A;
    fprintf(fout, "%14s %3d %3d %3d", "F3D_TRI1", vertex[0], vertex[1],
            vertex[2]);
    break;
  }
  case 0xF2: {
    unsigned short width, height;
    width = (((data[5] << 8) | (data[6] & 0xF0)) >> 6) + 1;
    height = (((data[6] & 0x0F) << 8 | data[7]) >> 2) + 1;
    fprintf(fout, "%14s %2d %2d", "G_SETTILESIZE", width, height);
    break;
  }
  case 0xF3: {
    unsigned w0 = (unsigned int)(((data)[0] << 24) + ((data)[1] << 16) +
                                 ((data)[2] << 8) + ((data)[3]));
    unsigned w1 = (unsigned int)(((&data[4])[0] << 24) + ((&data[4])[1] << 16) +
                                 ((&data[4])[2] << 8) + ((&data[4])[3]));
    unsigned uls = (w0 >> 12) & 0x3FF;
    unsigned ult = w0 & 0x3FF;
    unsigned lrs = (w1 >> 12) & 0x3FF;
    unsigned dxt = w1 & 0x3FF;
    fprintf(fout, "%14s %03X %03X %03X %u", "G_LOADBLOCK", uls, ult, lrs, dxt);
    break;
  }
  case 0xF5: {
    const char *fmt_table[] = {"RGBA", "YUV", "CI", "IA", "I"};
    unsigned format = (data[1] >> 5) & 0x7;
    unsigned size = (data[1] >> 3) & 0x3;
    unsigned depth = 0;
    switch (size) {
    case 0:
      depth = 4;
      break;
    case 1:
      depth = 8;
      break;
    case 2:
      depth = 16;
      break;
    case 3:
      depth = 32;
      break;
    default:
      fprintf(stderr, "Unknown depth: %d\n", size);
    }
    if (format < (sizeof(fmt_table) / sizeof(fmt_table[0]))) {
      sprintf(description, "%s %d", fmt_table[format], depth);
    }
    fprintf(fout, "%14s %s", "G_SETTILE", description);
    break;
  }
  case 0xF8:
    fprintf(fout, "%14s %3d, %3d, %3d, %3d", "G_SETFOGCOLOR", data[4], data[5],
            data[6], data[7]);
    break;
  case 0xFB:
    fprintf(fout, "%14s %3d, %3d, %3d, %3d", "G_SETENVCOLOR", data[4], data[5],
            data[6], data[7]);
    break;
  case 0xFC: {
    struct {
      unsigned char data[7];
      char *description;
    } table[] = {
        {{0x12, 0x7F, 0xFF, 0xFF, 0xFF, 0xF8, 0x38}, "solid RGBA"},
        {{0x12, 0x18, 0x24, 0xFF, 0x33, 0xFF, 0xFF}, "alpha RGBA"},
    };
    unsigned i;
    for (i = 0; i < (sizeof(table) / sizeof(table[0])); i++) {
      if (!memcmp(table[i].data, &data[1], 7)) {
        strcpy(description, table[i].description);
      }
    }
    fprintf(fout, "%14s %s", "G_SETCOMBINE", description);
    break;
  }
  case 0xFD:
    address = (unsigned int)(((&data[4])[0] << 24) + ((&data[4])[1] << 16) +
                             ((&data[4])[2] << 8) + ((&data[4])[3]));
    fprintf(fout, "%14s %08X", "G_SETTIMG", address);
    break;
  default:
    fprintf(fout, "%14s %s", "Unknown", description);
    break;
  }
}


x86 assembly (clang, -O0):
<print_f3d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movb   $0x0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0xe8(%rbp)
sub    $0x3,%eax
je     12c8 <print_f3d+0x178>
jmp    1182 <print_f3d+0x32>
mov    -0xe8(%rbp),%eax
sub    $0x4,%eax
je     137d <print_f3d+0x22d>
jmp    1196 <print_f3d+0x46>
mov    -0xe8(%rbp),%eax
sub    $0x6,%eax
je     1405 <print_f3d+0x2b5>
jmp    11aa <print_f3d+0x5a>
mov    -0xe8(%rbp),%eax
sub    $0xb5,%eax
je     1458 <print_f3d+0x308>
jmp    11c0 <print_f3d+0x70>
mov    -0xe8(%rbp),%eax
sub    $0xb6,%eax
je     1511 <print_f3d+0x3c1>
jmp    11d6 <print_f3d+0x86>
mov    -0xe8(%rbp),%eax
sub    $0xb7,%eax
je     1540 <print_f3d+0x3f0>
jmp    11ec <print_f3d+0x9c>
mov    -0xe8(%rbp),%eax
sub    $0xb8,%eax
je     156f <print_f3d+0x41f>
jmp    1202 <print_f3d+0xb2>
mov    -0xe8(%rbp),%eax
sub    $0xbb,%eax
je     1591 <print_f3d+0x441>
jmp    1218 <print_f3d+0xc8>
mov    -0xe8(%rbp),%eax
sub    $0xbf,%eax
je     16b1 <print_f3d+0x561>
jmp    122e <print_f3d+0xde>
mov    -0xe8(%rbp),%eax
sub    $0xf2,%eax
je     1716 <print_f3d+0x5c6>
jmp    1244 <print_f3d+0xf4>
mov    -0xe8(%rbp),%eax
sub    $0xf3,%eax
je     1784 <print_f3d+0x634>
jmp    125a <print_f3d+0x10a>
mov    -0xe8(%rbp),%eax
sub    $0xf5,%eax
je     184e <print_f3d+0x6fe>
jmp    1270 <print_f3d+0x120>
mov    -0xe8(%rbp),%eax
sub    $0xf8,%eax
je     19bf <print_f3d+0x86f>
jmp    1286 <print_f3d+0x136>
mov    -0xe8(%rbp),%eax
sub    $0xfb,%eax
je     1a02 <print_f3d+0x8b2>
jmp    129c <print_f3d+0x14c>
mov    -0xe8(%rbp),%eax
sub    $0xfc,%eax
je     1a45 <print_f3d+0x8f5>
jmp    12b2 <print_f3d+0x162>
mov    -0xe8(%rbp),%eax
sub    $0xfd,%eax
je     1b24 <print_f3d+0x9d4>
jmp    1b77 <print_f3d+0xa27>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    %eax,-0xec(%rbp)
sub    $0x86,%eax
je     12fc <print_f3d+0x1ac>
jmp    12e6 <print_f3d+0x196>
mov    -0xec(%rbp),%eax
sub    $0x88,%eax
je     1313 <print_f3d+0x1c3>
jmp    1325 <print_f3d+0x1d5>
lea    -0x50(%rbp),%rdi
lea    0xd09(%rip),%rsi
mov    $0x0,%al
call   1070 <sprintf@plt>
jmp    1325 <print_f3d+0x1d5>
lea    -0x50(%rbp),%rdi
lea    0xcf8(%rip),%rsi
mov    $0x0,%al
call   1070 <sprintf@plt>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rcx
mov    -0x58(%rbp),%r8d
lea    0xcb2(%rip),%rsi
lea    0xcb8(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x51(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
movzbl -0x51(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    -0x5c(%rbp),%r9d
shr    $0x4,%r9d
mov    -0x58(%rbp),%eax
lea    0xc46(%rip),%rsi
lea    0xc58(%rip),%rdx
mov    %eax,(%rsp)
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x58(%rbp),%ecx
lea    0xc11(%rip),%rsi
lea    0xc14(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x62(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x61(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x5f(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x5e(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x5d(%rbp)
mov    -0x8(%rbp),%rdi
movzbl -0x62(%rbp),%ecx
movzbl -0x61(%rbp),%r8d
movzbl -0x60(%rbp),%r9d
movzbl -0x5f(%rbp),%r11d
movzbl -0x5e(%rbp),%r10d
movzbl -0x5d(%rbp),%eax
lea    0xb76(%rip),%rsi
lea    0xb8c(%rip),%rdx
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   1030 <get_mode_string@plt>
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rcx
lea    0xb60(%rip),%rsi
lea    0xb61(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   1030 <get_mode_string@plt>
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rcx
lea    0xb31(%rip),%rsi
lea    0xb41(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rcx
lea    0xb0f(%rip),%rsi
lea    0xb2e(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
mov    %eax,-0xf0(%rbp)
test   %eax,%eax
je     15c0 <print_f3d+0x470>
jmp    15ac <print_f3d+0x45c>
mov    -0xf0(%rbp),%eax
sub    $0x1,%eax
je     1613 <print_f3d+0x4c3>
jmp    168f <print_f3d+0x53f>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0xffffffff,-0x5c(%rbp)
jne    160e <print_f3d+0x4be>
lea    -0x50(%rbp),%rdi
lea    0xab5(%rip),%rsi
mov    $0x0,%al
call   1070 <sprintf@plt>
jmp    168f <print_f3d+0x53f>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0xffffffff,-0x5c(%rbp)
jne    1666 <print_f3d+0x516>
lea    -0x50(%rbp),%rdi
lea    0xa78(%rip),%rsi
mov    $0x0,%al
call   1070 <sprintf@plt>
jmp    168a <print_f3d+0x53a>
cmpl   $0xf8007c0,-0x5c(%rbp)
jne    1685 <print_f3d+0x535>
lea    -0x50(%rbp),%rdi
lea    0xa6a(%rip),%rsi
mov    $0x0,%al
call   1070 <sprintf@plt>
jmp    168a <print_f3d+0x53a>
jmp    168f <print_f3d+0x53f>
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rcx
lea    0x9ef(%rip),%rsi
lea    0xa5d(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x65(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %al,-0x63(%rbp)
mov    -0x8(%rbp),%rdi
movzbl -0x65(%rbp),%ecx
movzbl -0x64(%rbp),%r8d
movzbl -0x63(%rbp),%r9d
lea    0xa0b(%rip),%rsi
lea    0xa15(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
and    $0xf0,%ecx
or     %ecx,%eax
sar    $0x6,%eax
add    $0x1,%eax
mov    %ax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0xf,%eax
shl    $0x8,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
or     %ecx,%eax
sar    $0x2,%eax
add    $0x1,%eax
mov    %ax,-0x6a(%rbp)
mov    -0x8(%rbp),%rdi
movzwl -0x68(%rbp),%ecx
movzwl -0x6a(%rbp),%r8d
lea    0x9b7(%rip),%rsi
lea    0x9bd(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
shr    $0xc,%eax
and    $0x3ff,%eax
mov    %eax,-0x78(%rbp)
mov    -0x70(%rbp),%eax
and    $0x3ff,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x74(%rbp),%eax
shr    $0xc,%eax
and    $0x3ff,%eax
mov    %eax,-0x80(%rbp)
mov    -0x74(%rbp),%eax
and    $0x3ff,%eax
mov    %eax,-0x84(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x78(%rbp),%ecx
mov    -0x7c(%rbp),%r8d
mov    -0x80(%rbp),%r9d
mov    -0x84(%rbp),%eax
lea    0x90b(%rip),%rsi
lea    0x91b(%rip),%rdx
mov    %eax,(%rsp)
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
xorps  %xmm0,%xmm0
movaps %xmm0,-0xa0(%rbp)
movaps %xmm0,-0xb0(%rbp)
movq   $0x0,-0x90(%rbp)
lea    0x967(%rip),%rax
mov    %rax,-0xb0(%rbp)
lea    0x8e7(%rip),%rax
mov    %rax,-0xa8(%rbp)
lea    0x8dd(%rip),%rax
mov    %rax,-0xa0(%rbp)
lea    0x8d2(%rip),%rax
mov    %rax,-0x98(%rbp)
lea    0x8c2(%rip),%rax
mov    %rax,-0x90(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
shr    $0x5,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
shr    $0x3,%eax
and    $0x3,%eax
mov    %eax,-0xb8(%rbp)
movl   $0x0,-0xbc(%rbp)
mov    -0xb8(%rbp),%eax
mov    %rax,-0xf8(%rbp)
sub    $0x3,%rax
ja     1949 <print_f3d+0x7f9>
mov    -0xf8(%rbp),%rax
lea    0x6fc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x4,-0xbc(%rbp)
jmp    1967 <print_f3d+0x817>
movl   $0x8,-0xbc(%rbp)
jmp    1967 <print_f3d+0x817>
movl   $0x10,-0xbc(%rbp)
jmp    1967 <print_f3d+0x817>
movl   $0x20,-0xbc(%rbp)
jmp    1967 <print_f3d+0x817>
mov    0x2688(%rip),%rax
movslq (%rax),%rdi
mov    -0xb8(%rbp),%edx
lea    0x810(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0xb4(%rbp),%eax
cmp    $0x5,%rax
jae    199d <print_f3d+0x84d>
lea    -0x50(%rbp),%rdi
mov    -0xb4(%rbp),%eax
mov    -0xb0(%rbp,%rax,8),%rdx
ff
mov    -0xbc(%rbp),%ecx
lea    0x7ed(%rip),%rsi
mov    $0x0,%al
call   1070 <sprintf@plt>
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rcx
lea    0x6e1(%rip),%rsi
lea    0x7d6(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%ecx
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%r8d
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%r9d
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
lea    0x7a7(%rip),%rsi
lea    0x7b8(%rip),%rdx
mov    %eax,(%rsp)
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%ecx
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%r8d
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%r9d
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
lea    0x764(%rip),%rsi
lea    0x783(%rip),%rdx
mov    %eax,(%rsp)
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    0x23a4(%rip),%rax
mov    %rax,-0xe0(%rbp)
mov    0x239e(%rip),%rax
mov    %rax,-0xd8(%rbp)
mov    0x2398(%rip),%rax
mov    %rax,-0xd0(%rbp)
mov    0x2392(%rip),%rax
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    $0x2,%rax
jae    1b02 <print_f3d+0x9b2>
mov    -0xe4(%rbp),%eax
lea    -0xe0(%rbp),%rdi
shl    $0x4,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
add    $0x1,%rsi
mov    $0x7,%edx
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    1ae9 <print_f3d+0x999>
lea    -0x50(%rbp),%rdi
mov    -0xe4(%rbp),%eax
mov    %eax,%ecx
lea    -0xe0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rsi
call   1040 <strcpy@plt>
jmp    1aee <print_f3d+0x99e>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1a87 <print_f3d+0x937>
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rcx
lea    0x57c(%rip),%rsi
lea    0x6c5(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
shl    $0x18,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x58(%rbp),%ecx
lea    0x4f2(%rip),%rsi
lea    0x67f(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    1b94 <print_f3d+0xa44>
mov    -0x8(%rbp),%rdi
lea    -0x50(%rbp),%rcx
lea    0x507(%rip),%rsi
lea    0x667(%rip),%rdx
mov    $0x0,%al
call   1060 <fprintf@plt>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_f3d>:
push   %r15
push   %r14
push   %rbx
sub    $0x90,%rsp
mov    %rdi,%r14
movb   $0x0,0x20(%rsp)
mov    (%rsi),%al
add    $0x4b,%al
cmp    $0x51,%al
ja     1384 <print_f3d+0x234>
mov    %rsi,%rbx
movzbl %al,%eax
lea    0xe83(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl 0x1(%rbx),%eax
imul   $0xcd,%eax,%ecx
shr    $0xb,%ecx
movzbl 0x2(%rbx),%eax
imul   $0xcd,%eax,%r8d
shr    $0xb,%r8d
movzbl 0x3(%rbx),%eax
imul   $0xcd,%eax,%r9d
shr    $0xb,%r9d
movzbl 0x5(%rbx),%eax
imul   $0xcd,%eax,%eax
shr    $0xb,%eax
movzbl 0x6(%rbx),%edx
imul   $0xcd,%edx,%edx
shr    $0xb,%edx
movzbl 0x7(%rbx),%esi
imul   $0xcd,%esi,%esi
shr    $0xb,%esi
mov    %esi,0x10(%rsp)
mov    %edx,0x8(%rsp)
mov    %eax,(%rsp)
lea    0xfb5(%rip),%rsi
lea    0xfcb(%rip),%rdx
jmp    156e <print_f3d+0x41e>
lea    0x20(%rsp),%r15
mov    %rbx,%rdi
mov    %r15,%rsi
call   1030 <get_mode_string@plt>
lea    0xfb8(%rip),%rsi
lea    0xfc8(%rip),%rdx
jmp    1366 <print_f3d+0x216>
movzbl 0x5(%rbx),%eax
imul   $0xcd,%eax,%ecx
shr    $0xb,%ecx
movzbl 0x6(%rbx),%eax
imul   $0xcd,%eax,%r8d
shr    $0xb,%r8d
movzbl 0x7(%rbx),%eax
imul   $0xcd,%eax,%r9d
shr    $0xb,%r9d
lea    0xffb(%rip),%rsi
lea    0x1005(%rip),%rdx
mov    %r14,%rdi
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbx
pop    %r14
pop    %r15
jmp    1060 <fprintf@plt>
movzbl 0x4(%rbx),%ecx
movzbl 0x5(%rbx),%r8d
movzbl 0x6(%rbx),%r9d
movzbl 0x7(%rbx),%eax
mov    %eax,(%rsp)
lea    0x1034(%rip),%rsi
lea    0x1053(%rip),%rdx
jmp    156e <print_f3d+0x41e>
movaps 0x2b79(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0x2b5d(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
add    $0x1,%rbx
lea    0x60(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x7,%edx
call   1050 <memcmp@plt>
test   %eax,%eax
jne    12d1 <print_f3d+0x181>
mov    0x68(%rsp),%rsi
lea    0x20(%rsp),%rdi
call   1040 <strcpy@plt>
lea    0x70(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x7,%edx
call   1050 <memcmp@plt>
test   %eax,%eax
jne    12f6 <print_f3d+0x1a6>
mov    0x78(%rsp),%rsi
lea    0x20(%rsp),%rdi
call   1040 <strcpy@plt>
lea    0xec8(%rip),%rsi
lea    0xffe(%rip),%rdx
jmp    162f <print_f3d+0x4df>
mov    0x4(%rbx),%ecx
bswap  %ecx
lea    0xe79(%rip),%rsi
lea    0xff3(%rip),%rdx
jmp    1590 <print_f3d+0x440>
mov    0x1(%rbx),%al
cmp    $0x88,%al
je     15a6 <print_f3d+0x456>
cmp    $0x86,%al
jne    15b5 <print_f3d+0x465>
movw   $0x74,0x24(%rsp)
movl   $0x6867696c,0x20(%rsp)
68
jmp    15b5 <print_f3d+0x465>
lea    0x20(%rsp),%r15
mov    %rbx,%rdi
mov    %r15,%rsi
call   1030 <get_mode_string@plt>
lea    0xe66(%rip),%rsi
lea    0xe67(%rip),%rdx
mov    %r14,%rdi
mov    %r15,%rcx
jmp    1637 <print_f3d+0x4e7>
lea    0xe4d(%rip),%rsi
lea    0xe6c(%rip),%rdx
jmp    162f <print_f3d+0x4df>
lea    0xe3a(%rip),%rsi
lea    0xf87(%rip),%rdx
jmp    162f <print_f3d+0x4df>
mov    0x3(%rbx),%al
cmp    $0x1,%al
je     15db <print_f3d+0x48b>
test   %al,%al
jne    1621 <print_f3d+0x4d1>
mov    0x4(%rbx),%eax
bswap  %eax
cmp    $0xffffffff,%eax
jne    1621 <print_f3d+0x4d1>
movups 0xe35(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movabs $0x30206f7420656c,%rax
mov    %rax,0x2e(%rsp)
jmp    1621 <print_f3d+0x4d1>
movzbl 0x5(%rbx),%ecx
shl    $0x8,%ecx
movzbl 0x6(%rbx),%eax
or     %eax,%ecx
shr    $0x6,%ecx
add    $0x1,%ecx
and    $0xf,%eax
shl    $0x8,%eax
movzbl 0x7(%rbx),%r8d
or     %eax,%r8d
shr    $0x2,%r8d
add    $0x1,%r8d
lea    0xe58(%rip),%rsi
lea    0xe5e(%rip),%rdx
mov    %r14,%rdi
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbx
pop    %r14
pop    %r15
jmp    1060 <fprintf@plt>
movzbl 0x1(%rbx),%ecx
shl    $0x10,%ecx
movzbl 0x2(%rbx),%r8d
shl    $0x8,%r8d
or     %r8d,%ecx
movzbl 0x3(%rbx),%eax
movzbl 0x5(%rbx),%r9d
shl    $0x10,%r9d
movzbl 0x6(%rbx),%edx
shl    $0x8,%edx
or     %edx,%r9d
movzbl 0x7(%rbx),%esi
shr    $0xc,%ecx
and    $0x3ff,%ecx
and    $0x300,%r8d
or     %eax,%r8d
shr    $0xc,%r9d
and    $0x3ff,%r9d
and    $0x300,%edx
or     %esi,%edx
mov    %edx,(%rsp)
lea    0xdf8(%rip),%rsi
lea    0xe08(%rip),%rdx
jmp    156e <print_f3d+0x41e>
lea    0xe67(%rip),%rax
mov    %rax,0x60(%rsp)
lea    0xdfc(%rip),%rax
mov    %rax,0x68(%rsp)
lea    0xdf4(%rip),%rax
mov    %rax,0x70(%rsp)
lea    0xdeb(%rip),%rax
mov    %rax,0x78(%rsp)
lea    0xddd(%rip),%rax
mov    %rax,0x80(%rsp)
movzbl 0x1(%rbx),%eax
cmp    $0x9f,%rax
ja     1509 <print_f3d+0x3b9>
mov    %rax,%rcx
shr    %rcx
and    $0xc,%ecx
lea    0xe3a(%rip),%rdx
mov    (%rcx,%rdx,1),%ecx
shr    $0x5,%rax
mov    0x60(%rsp,%rax,8),%rdx
lea    0xdab(%rip),%rsi
lea    0x20(%rsp),%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
lea    0xcb5(%rip),%rsi
lea    0xd97(%rip),%rdx
jmp    162f <print_f3d+0x4df>
movzbl 0x4(%rbx),%ecx
movzbl 0x5(%rbx),%r8d
movzbl 0x6(%rbx),%r9d
movzbl 0x7(%rbx),%eax
mov    %eax,(%rsp)
lea    0xd80(%rip),%rsi
lea    0xd91(%rip),%rdx
jmp    156e <print_f3d+0x41e>
movzbl 0x1(%rbx),%ecx
movzwl 0x2(%rbx),%r8d
shl    $0x10,%r8d
bswap  %r8d
mov    0x4(%rbx),%eax
bswap  %eax
mov    %r8d,%r9d
shr    $0x4,%r9d
mov    %eax,(%rsp)
lea    0xc06(%rip),%rsi
lea    0xc18(%rip),%rdx
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <fprintf@plt>
jmp    163e <print_f3d+0x4ee>
mov    0x4(%rbx),%ecx
bswap  %ecx
lea    0xc05(%rip),%rsi
lea    0xc08(%rip),%rdx
mov    %r14,%rdi
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbx
pop    %r14
pop    %r15
jmp    1060 <fprintf@plt>
movw   $0x20,0x24(%rsp)
movl   $0x6b726164,0x20(%rsp)
6b
mov    0x4(%rbx),%r8d
bswap  %r8d
lea    0xb91(%rip),%rsi
lea    0xb97(%rip),%rdx
lea    0x20(%rsp),%rcx
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <fprintf@plt>
jmp    163e <print_f3d+0x4ee>
mov    0x4(%rbx),%eax
bswap  %eax
cmp    $0xf8007c0,%eax
je     1609 <print_f3d+0x4b9>
cmp    $0xffffffff,%eax
jne    1621 <print_f3d+0x4d1>
movups 0xc17(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movabs $0x31206f7420656c,%rax
mov    %rax,0x2e(%rsp)
jmp    1621 <print_f3d+0x4d1>
movups 0xc1a(%rip),%xmm0
movups %xmm0,0x2a(%rsp)
movups 0xc04(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
lea    0xb9d(%rip),%rsi
lea    0xc0b(%rip),%rdx
lea    0x20(%rsp),%rcx
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <fprintf@plt>
add    $0x90,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
%struct.anon = type { [7 x i8], i8* }
@.str = [6 x i8] c"light\00"
@.str.1 = [6 x i8] c"dark \00"
@.str.2 = [13 x i8] c"%14s %s %08X\00"
@.str.3 = [12 x i8] c"F3D_MOVEMEM\00"
@.str.4 = [25 x i8] c"%14s %02X %04X (%d) %08X\00"
@.str.5 = [8 x i8] c"F3D_VTX\00"
@.str.6 = [10 x i8] c"%14s %08X\00"
@.str.7 = [7 x i8] c"F3D_DL\00"
@.str.8 = [29 x i8] c"%14s %3d %3d %3d %3d %3d %3d\00"
@.str.9 = [9 x i8] c"F3D_QUAD\00"
@.str.10 = [8 x i8] c"%14s %s\00"
@.str.11 = [15 x i8] c"F3D_CLRGEOMODE\00"
@.str.12 = [15 x i8] c"F3D_SETGEOMODE\00"
@.str.13 = [9 x i8] c"F3D_ENDL\00"
@.str.14 = [22 x i8] c"end, reset scale to 0\00"
@.str.15 = [22 x i8] c"start, set scale to 1\00"
@.str.16 = [26 x i8] c"start environment mapping\00"
@.str.17 = [12 x i8] c"F3D_TEXTURE\00"
@.str.18 = [17 x i8] c"%14s %3d %3d %3d\00"
@.str.19 = [9 x i8] c"F3D_TRI1\00"
@.str.20 = [13 x i8] c"%14s %2d %2d\00"
@.str.21 = [14 x i8] c"G_SETTILESIZE\00"
@.str.22 = [23 x i8] c"%14s %03X %03X %03X %u\00"
@.str.23 = [12 x i8] c"G_LOADBLOCK\00"
@.str.24 = [5 x i8] c"RGBA\00"
@.str.25 = [4 x i8] c"YUV\00"
@.str.26 = [3 x i8] c"CI\00"
@.str.27 = [3 x i8] c"IA\00"
@.str.28 = [2 x i8] c"I\00"
@stderr = global i32 0
@.str.30 = [6 x i8] c"%s %d\00"
@.str.31 = [10 x i8] c"G_SETTILE\00"
@.str.32 = [24 x i8] c"%14s %3d, %3d, %3d, %3d\00"
@.str.33 = [14 x i8] c"G_SETFOGCOLOR\00"
@.str.34 = [14 x i8] c"G_SETENVCOLOR\00"
@.str.35 = [11 x i8] c"solid RGBA\00"
@.str.36 = [11 x i8] c"alpha RGBA\00"
@__const.print_f3d.table = [2 x %struct.anon] [%struct.anon { [7 x i8] c"\12\7F\FF\FF\FF\F88", i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.35, i32 0, i32 0) }, %struct.anon { [7 x i8] c"\12\18$\FF3\FF\FF", i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.36, i32 0, i32 0) }]
@.str.37 = [13 x i8] c"G_SETCOMBINE\00"
@.str.38 = [10 x i8] c"G_SETTIMG\00"
@.str.39 = [8 x i8] c"Unknown\00"
@switch.table.print_f3d = [4 x i32] [i32 4, i32 8, i32 16, i32 32]
define void @print_f3d(i32* nocapture %0, i8* %1) {
%3 = alloca [64 x i8]
%4 = alloca [5 x i8*]
%5 = alloca [2 x %struct.anon]
%6 = getelementptr inbounds [64 x i8], [64 x i8]* %3, i64 0, i64 0
store i8 0, i8* %6
%7 = load i8, i8* %1
switch i8 %7, label %325 [
i8 3, label %8
i8 4, label %33
i8 6, label %65
i8 -75, label %85
i8 -74, label %111
i8 -73, label %114
i8 -72, label %117
i8 -69, label %119
i8 -65, label %166
i8 -14, label %180
i8 -13, label %200
i8 -11, label %234
i8 -8, label %258
i8 -5, label %272
i8 -4, label %286
i8 -3, label %305
]
8: ; preds = %2
%9 = getelementptr inbounds i8, i8* %1, i64 1
%10 = load i8, i8* %9
switch i8 %10, label %13 [
i8 -122, label %11
i8 -120, label %12
]
11: ; preds = %8
br label %13
12: ; preds = %8
br label %13
13: ; preds = %8, %12, %11
%14 = getelementptr inbounds i8, i8* %1, i64 4
%15 = load i8, i8* %14
%16 = zext i8 %15 to i32
%17 = shl nuw i32 %16, 24
%18 = getelementptr inbounds i8, i8* %1, i64 5
%19 = load i8, i8* %18
%20 = zext i8 %19 to i32
%21 = shl nuw nsw i32 %20, 16
%22 = or i32 %21, %17
%23 = getelementptr inbounds i8, i8* %1, i64 6
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = shl nuw nsw i32 %25, 8
%27 = or i32 %22, %26
%28 = getelementptr inbounds i8, i8* %1, i64 7
%29 = load i8, i8* %28
%30 = zext i8 %29 to i32
%31 = or i32 %27, %30
%32 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i8* %6, i32 %31)
br label %327
33: ; preds = %2
%34 = getelementptr inbounds i8, i8* %1, i64 1
%35 = load i8, i8* %34
%36 = getelementptr inbounds i8, i8* %1, i64 2
%37 = load i8, i8* %36
%38 = zext i8 %37 to i32
%39 = shl nuw nsw i32 %38, 8
%40 = getelementptr inbounds i8, i8* %1, i64 3
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = or i32 %39, %42
%44 = getelementptr inbounds i8, i8* %1, i64 4
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = shl nuw i32 %46, 24
%48 = getelementptr inbounds i8, i8* %1, i64 5
%49 = load i8, i8* %48
%50 = zext i8 %49 to i32
%51 = shl nuw nsw i32 %50, 16
%52 = or i32 %51, %47
%53 = getelementptr inbounds i8, i8* %1, i64 6
%54 = load i8, i8* %53
%55 = zext i8 %54 to i32
%56 = shl nuw nsw i32 %55, 8
%57 = or i32 %52, %56
%58 = getelementptr inbounds i8, i8* %1, i64 7
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = or i32 %57, %60
%62 = zext i8 %35 to i32
%63 = lshr i32 %43, 4
%64 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i64 0, i64 0), i32 %62, i32 %43, i32 %63, i32 %61)
br label %327
65: ; preds = %2
%66 = getelementptr inbounds i8, i8* %1, i64 4
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = shl nuw i32 %68, 24
%70 = getelementptr inbounds i8, i8* %1, i64 5
%71 = load i8, i8* %70
%72 = zext i8 %71 to i32
%73 = shl nuw nsw i32 %72, 16
%74 = or i32 %73, %69
%75 = getelementptr inbounds i8, i8* %1, i64 6
%76 = load i8, i8* %75
%77 = zext i8 %76 to i32
%78 = shl nuw nsw i32 %77, 8
%79 = or i32 %74, %78
%80 = getelementptr inbounds i8, i8* %1, i64 7
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
%83 = or i32 %79, %82
%84 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %83)
br label %327
85: ; preds = %2
%86 = getelementptr inbounds i8, i8* %1, i64 1
%87 = load i8, i8* %86
%88 = udiv i8 %87, 10
%89 = getelementptr inbounds i8, i8* %1, i64 2
%90 = load i8, i8* %89
%91 = udiv i8 %90, 10
%92 = getelementptr inbounds i8, i8* %1, i64 3
%93 = load i8, i8* %92
%94 = udiv i8 %93, 10
%95 = getelementptr inbounds i8, i8* %1, i64 5
%96 = load i8, i8* %95
%97 = udiv i8 %96, 10
%98 = getelementptr inbounds i8, i8* %1, i64 6
%99 = load i8, i8* %98
%100 = udiv i8 %99, 10
%101 = getelementptr inbounds i8, i8* %1, i64 7
%102 = load i8, i8* %101
%103 = udiv i8 %102, 10
%104 = zext i8 %88 to i32
%105 = zext i8 %91 to i32
%106 = zext i8 %94 to i32
%107 = zext i8 %97 to i32
%108 = zext i8 %100 to i32
%109 = zext i8 %103 to i32
%110 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i64 0, i64 0), i32 %104, i32 %105, i32 %106, i32 %107, i32 %108, i32 %109)
br label %327
111: ; preds = %2
%112 = call i32 @get_mode_string(i8* %1, i8* %6)
%113 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.11, i64 0, i64 0), i8* %6)
br label %327
114: ; preds = %2
%115 = call i32 @get_mode_string(i8* %1, i8* %6)
%116 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.12, i64 0, i64 0), i8* %6)
br label %327
117: ; preds = %2
%118 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.13, i64 0, i64 0), i8* %6)
br label %327
119: ; preds = %2
%120 = getelementptr inbounds i8, i8* %1, i64 3
%121 = load i8, i8* %120
switch i8 %121, label %164 [
i8 0, label %122
i8 1, label %143
]
122: ; preds = %119
%123 = getelementptr inbounds i8, i8* %1, i64 4
%124 = load i8, i8* %123
%125 = zext i8 %124 to i32
%126 = shl nuw i32 %125, 24
%127 = getelementptr inbounds i8, i8* %1, i64 5
%128 = load i8, i8* %127
%129 = zext i8 %128 to i32
%130 = shl nuw nsw i32 %129, 16
%131 = or i32 %130, %126
%132 = getelementptr inbounds i8, i8* %1, i64 6
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = shl nuw nsw i32 %134, 8
%136 = or i32 %131, %135
%137 = getelementptr inbounds i8, i8* %1, i64 7
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
%140 = or i32 %136, %139
%141 = icmp eq i32 %140, -1
br i1 %141, label %142, label %164
142: ; preds = %122
br label %164
143: ; preds = %119
%144 = getelementptr inbounds i8, i8* %1, i64 4
%145 = load i8, i8* %144
%146 = zext i8 %145 to i32
%147 = shl nuw i32 %146, 24
%148 = getelementptr inbounds i8, i8* %1, i64 5
%149 = load i8, i8* %148
%150 = zext i8 %149 to i32
%151 = shl nuw nsw i32 %150, 16
%152 = or i32 %151, %147
%153 = getelementptr inbounds i8, i8* %1, i64 6
%154 = load i8, i8* %153
%155 = zext i8 %154 to i32
%156 = shl nuw nsw i32 %155, 8
%157 = or i32 %152, %156
%158 = getelementptr inbounds i8, i8* %1, i64 7
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
%161 = or i32 %157, %160
switch i32 %161, label %164 [
i32 -1, label %162
i32 260048832, label %163
]
162: ; preds = %143
br label %164
163: ; preds = %143
br label %164
164: ; preds = %143, %162, %163, %122, %142, %119
%165 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.17, i64 0, i64 0), i8* %6)
br label %327
166: ; preds = %2
%167 = getelementptr inbounds i8, i8* %1, i64 5
%168 = load i8, i8* %167
%169 = udiv i8 %168, 10
%170 = getelementptr inbounds i8, i8* %1, i64 6
%171 = load i8, i8* %170
%172 = udiv i8 %171, 10
%173 = getelementptr inbounds i8, i8* %1, i64 7
%174 = load i8, i8* %173
%175 = udiv i8 %174, 10
%176 = zext i8 %169 to i32
%177 = zext i8 %172 to i32
%178 = zext i8 %175 to i32
%179 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.19, i64 0, i64 0), i32 %176, i32 %177, i32 %178)
br label %327
180: ; preds = %2
%181 = getelementptr inbounds i8, i8* %1, i64 5
%182 = load i8, i8* %181
%183 = zext i8 %182 to i32
%184 = shl nuw nsw i32 %183, 8
%185 = getelementptr inbounds i8, i8* %1, i64 6
%186 = load i8, i8* %185
%187 = zext i8 %186 to i32
%188 = or i32 %184, %187
%189 = lshr i32 %188, 6
%190 = add nuw nsw i32 %189, 1
%191 = shl nuw nsw i32 %187, 8
%192 = and i32 %191, 3840
%193 = getelementptr inbounds i8, i8* %1, i64 7
%194 = load i8, i8* %193
%195 = zext i8 %194 to i32
%196 = or i32 %192, %195
%197 = lshr i32 %196, 2
%198 = add nuw nsw i32 %197, 1
%199 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.21, i64 0, i64 0), i32 %190, i32 %198)
br label %327
200: ; preds = %2
%201 = getelementptr inbounds i8, i8* %1, i64 1
%202 = load i8, i8* %201
%203 = zext i8 %202 to i32
%204 = shl nuw nsw i32 %203, 16
%205 = getelementptr inbounds i8, i8* %1, i64 2
%206 = load i8, i8* %205
%207 = zext i8 %206 to i32
%208 = shl nuw nsw i32 %207, 8
%209 = or i32 %208, %204
%210 = getelementptr inbounds i8, i8* %1, i64 3
%211 = load i8, i8* %210
%212 = zext i8 %211 to i32
%213 = getelementptr inbounds i8, i8* %1, i64 5
%214 = load i8, i8* %213
%215 = zext i8 %214 to i32
%216 = shl nuw nsw i32 %215, 16
%217 = getelementptr inbounds i8, i8* %1, i64 6
%218 = load i8, i8* %217
%219 = zext i8 %218 to i32
%220 = shl nuw nsw i32 %219, 8
%221 = or i32 %220, %216
%222 = getelementptr inbounds i8, i8* %1, i64 7
%223 = load i8, i8* %222
%224 = zext i8 %223 to i32
%225 = lshr i32 %209, 12
%226 = and i32 %225, 1023
%227 = and i32 %208, 768
%228 = or i32 %227, %212
%229 = lshr i32 %221, 12
%230 = and i32 %229, 1023
%231 = and i32 %220, 768
%232 = or i32 %231, %224
%233 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.23, i64 0, i64 0), i32 %226, i32 %228, i32 %230, i32 %232)
br label %327
234: ; preds = %2
%235 = bitcast [5 x i8*]* %4 to i8*
%236 = getelementptr inbounds [5 x i8*], [5 x i8*]* %4, i64 0, i64 0
store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.24, i64 0, i64 0), i8** %236
%237 = getelementptr inbounds [5 x i8*], [5 x i8*]* %4, i64 0, i64 1
store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.25, i64 0, i64 0), i8** %237
%238 = getelementptr inbounds [5 x i8*], [5 x i8*]* %4, i64 0, i64 2
store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.26, i64 0, i64 0), i8** %238
%239 = getelementptr inbounds [5 x i8*], [5 x i8*]* %4, i64 0, i64 3
store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.27, i64 0, i64 0), i8** %239
%240 = getelementptr inbounds [5 x i8*], [5 x i8*]* %4, i64 0, i64 4
store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.28, i64 0, i64 0), i8** %240
%241 = getelementptr inbounds i8, i8* %1, i64 1
%242 = load i8, i8* %241
%243 = zext i8 %242 to i32
%244 = icmp ult i8 %242, -96
br i1 %244, label %245, label %256
245: ; preds = %234
%246 = lshr i32 %243, 3
%247 = and i32 %246, 3
%248 = zext i32 %247 to i64
%249 = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.print_f3d, i64 0, i64 %248
%250 = load i32, i32* %249
%251 = lshr i32 %243, 5
%252 = zext i32 %251 to i64
%253 = getelementptr inbounds [5 x i8*], [5 x i8*]* %4, i64 0, i64 %252
%254 = load i8*, i8** %253
%255 = call i32 (i8*, i8*, ...) @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.30, i64 0, i64 0), i8* %254, i32 %250)
br label %256
256: ; preds = %245, %234
%257 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.31, i64 0, i64 0), i8* %6)
br label %327
258: ; preds = %2
%259 = getelementptr inbounds i8, i8* %1, i64 4
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = getelementptr inbounds i8, i8* %1, i64 5
%263 = load i8, i8* %262
%264 = zext i8 %263 to i32
%265 = getelementptr inbounds i8, i8* %1, i64 6
%266 = load i8, i8* %265
%267 = zext i8 %266 to i32
%268 = getelementptr inbounds i8, i8* %1, i64 7
%269 = load i8, i8* %268
%270 = zext i8 %269 to i32
%271 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.32, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.33, i64 0, i64 0), i32 %261, i32 %264, i32 %267, i32 %270)
br label %327
272: ; preds = %2
%273 = getelementptr inbounds i8, i8* %1, i64 4
%274 = load i8, i8* %273
%275 = zext i8 %274 to i32
%276 = getelementptr inbounds i8, i8* %1, i64 5
%277 = load i8, i8* %276
%278 = zext i8 %277 to i32
%279 = getelementptr inbounds i8, i8* %1, i64 6
%280 = load i8, i8* %279
%281 = zext i8 %280 to i32
%282 = getelementptr inbounds i8, i8* %1, i64 7
%283 = load i8, i8* %282
%284 = zext i8 %283 to i32
%285 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.32, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.34, i64 0, i64 0), i32 %275, i32 %278, i32 %281, i32 %284)
br label %327
286: ; preds = %2
%287 = getelementptr inbounds [2 x %struct.anon], [2 x %struct.anon]* %5, i64 0, i64 0, i32 0, i64 0
%288 = getelementptr inbounds i8, i8* %1, i64 1
%289 = call i32 @memcmp(i8* %287, i8* %288, i32 7)
%290 = icmp eq i32 %289, 0
br i1 %290, label %291, label %295
291: ; preds = %286
%292 = getelementptr inbounds [2 x %struct.anon], [2 x %struct.anon]* %5, i64 0, i64 0, i32 1
%293 = load i8*, i8** %292
%294 = call i32 @strcpy(i8* %6, i8* %293)
br label %295
295: ; preds = %286, %291
%296 = getelementptr inbounds [2 x %struct.anon], [2 x %struct.anon]* %5, i64 0, i64 1, i32 0, i64 0
%297 = call i32 @memcmp(i8* %296, i8* %288, i32 7)
%298 = icmp eq i32 %297, 0
br i1 %298, label %299, label %303
299: ; preds = %295
%300 = getelementptr inbounds [2 x %struct.anon], [2 x %struct.anon]* %5, i64 0, i64 1, i32 1
%301 = load i8*, i8** %300
%302 = call i32 @strcpy(i8* %6, i8* %301)
br label %303
303: ; preds = %299, %295
%304 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.37, i64 0, i64 0), i8* %6)
br label %327
305: ; preds = %2
%306 = getelementptr inbounds i8, i8* %1, i64 4
%307 = load i8, i8* %306
%308 = zext i8 %307 to i32
%309 = shl nuw i32 %308, 24
%310 = getelementptr inbounds i8, i8* %1, i64 5
%311 = load i8, i8* %310
%312 = zext i8 %311 to i32
%313 = shl nuw nsw i32 %312, 16
%314 = or i32 %313, %309
%315 = getelementptr inbounds i8, i8* %1, i64 6
%316 = load i8, i8* %315
%317 = zext i8 %316 to i32
%318 = shl nuw nsw i32 %317, 8
%319 = or i32 %314, %318
%320 = getelementptr inbounds i8, i8* %1, i64 7
%321 = load i8, i8* %320
%322 = zext i8 %321 to i32
%323 = or i32 %319, %322
%324 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.38, i64 0, i64 0), i32 %323)
br label %327
325: ; preds = %2
%326 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.39, i64 0, i64 0), i8* %6)
br label %327
327: ; preds = %325, %305, %303, %272, %258, %256, %200, %180, %166, %164, %117, %114, %111, %85, %65, %33, %13
ret void
}