#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 DBL_MAX;
int DBL_MIN;
int /*<<< orphan*/ pack(unsigned char *, char *, float);
int /*<<< orphan*/ printf(char *, unsigned char, ...);
int /*<<< orphan*/ unpack(unsigned char *, char *, ...);
int main(void) {
  unsigned char buf[1024];
  int x;
  long long k, k2;
  long long test64[14] = {0,
                          -0,
                          1,
                          2,
                          -1,
                          -2,
                          0x7fffffffffffffffll >> 1,
                          0x7ffffffffffffffell,
                          0x7fffffffffffffffll,
                          -0x7fffffffffffffffll,
                          -0x8000000000000000ll,
                          9007199254740991ll,
                          9007199254740992ll,
                          9007199254740993ll};
  unsigned long long K, K2;
  unsigned long long testu64[14] = {0,
                                    0,
                                    1,
                                    2,
                                    0,
                                    0,
                                    0xffffffffffffffffll >> 1,
                                    0xfffffffffffffffell,
                                    0xffffffffffffffffll,
                                    0,
                                    0,
                                    9007199254740991ll,
                                    9007199254740992ll,
                                    9007199254740993ll};
  long i, i2;
  long test32[14] = {0,
                     -0,
                     1,
                     2,
                     -1,
                     -2,
                     0x7fffffffl >> 1,
                     0x7ffffffel,
                     0x7fffffffl,
                     -0x7fffffffl,
                     -0x80000000l,
                     0,
                     0,
                     0};
  unsigned long I, I2;
  unsigned long testu32[14] = {
      0,           0,           1, 2, 0, 0, 0xffffffffl >> 1,
      0xfffffffel, 0xffffffffl, 0, 0, 0, 0, 0};
  int j, j2;
  int test16[14] = {0,      -0,     1,       2,       -1, -2, 0x7fff >> 1,
                    0x7ffe, 0x7fff, -0x7fff, -0x8000, 0,  0,  0};
  printf("char bytes: %zu\n", sizeof(char));
  printf("int bytes: %zu\n", sizeof(int));
  printf("long bytes: %zu\n", sizeof(long));
  printf("long long bytes: %zu\n", sizeof(long long));
  printf("float bytes: %zu\n", sizeof(float));
  printf("double bytes: %zu\n", sizeof(double));
  printf("long double bytes: %zu\n", sizeof(long double));
  for (x = 0; x < 14; x++) {
    k = test64[x];
    pack(buf, "q", k);
    unpack(buf, "q", &k2);
    if (k2 != k) {
      printf("64: %lld != %lld\n", k, k2);
      printf("  before: %016llx\n", k);
      printf("  after:  %016llx\n", k2);
      printf("  buffer: %02hhx %02hhx %02hhx %02hhx "
             " %02hhx %02hhx %02hhx %02hhx\n",
             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
    } else {
    }
    K = testu64[x];
    pack(buf, "Q", K);
    unpack(buf, "Q", &K2);
    if (K2 != K) {
      printf("64: %llu != %llu\n", K, K2);
    } else {
    }
    i = test32[x];
    pack(buf, "l", i);
    unpack(buf, "l", &i2);
    if (i2 != i) {
      printf("32(%d): %ld != %ld\n", x, i, i2);
      printf("  before: %08lx\n", i);
      printf("  after:  %08lx\n", i2);
      printf("  buffer: %02hhx %02hhx %02hhx %02hhx "
             " %02hhx %02hhx %02hhx %02hhx\n",
             buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
    } else {
    }
    I = testu32[x];
    pack(buf, "L", I);
    unpack(buf, "L", &I2);
    if (I2 != I) {
      printf("32(%d): %lu != %lu\n", x, I, I2);
    } else {
    }
    j = test16[x];
    pack(buf, "h", j);
    unpack(buf, "h", &j2);
    if (j2 != j) {
      printf("16: %d != %d\n", j, j2);
    } else {
    }
  }
  if (1) {
    long double testf64[8] = {-3490.6677,  0.0,         1.0,     -1.0,
                              DBL_MIN * 2, DBL_MAX / 2, DBL_MIN, DBL_MAX};
    long double f, f2;
    for (i = 0; i < 8; i++) {
      f = testf64[i];
      pack(buf, "g", f);
      unpack(buf, "g", &f2);
      if (f2 != f) {
        printf("f64: %Lf != %Lf\n", f, f2);
        printf("  before: %016llx\n", *((long long *)&f));
        printf("  after:  %016llx\n", *((long long *)&f2));
        printf("  buffer: %02hhx %02hhx %02hhx %02hhx "
               " %02hhx %02hhx %02hhx %02hhx\n",
               buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
      } else {
      }
    }
  }
  if (1) {
    double testf32[7] = {0.0, 1.0, -1.0, 10, -3.6677, 3.1875, -3.1875};
    double f, f2;
    for (i = 0; i < 7; i++) {
      f = testf32[i];
      pack(buf, "d", f);
      unpack(buf, "d", &f2);
      if (f2 != f) {
        printf("f32: %.10f != %.10f\n", f, f2);
        printf("  before: %016llx\n", *((long long *)&f));
        printf("  after:  %016llx\n", *((long long *)&f2));
        printf("  buffer: %02hhx %02hhx %02hhx %02hhx "
               " %02hhx %02hhx %02hhx %02hhx\n",
               buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
      } else {
      }
    }
  }
  if (1) {
    float testf16[7] = {0.0, 1.0, -1.0, 10, -10, 3.1875, -3.1875};
    float f, f2;
    for (i = 0; i < 7; i++) {
      f = testf16[i];
      pack(buf, "f", f);
      unpack(buf, "f", &f2);
      if (f2 != f) {
        printf("f16: %f != %f\n", f, f2);
        printf("  before: %08x\n", *((int *)&f));
        printf("  after:  %08x\n", *((int *)&f2));
        printf("  buffer: %02hhx %02hhx %02hhx %02hhx "
               " %02hhx %02hhx %02hhx %02hhx\n",
               buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
      } else {
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x7e0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x4a0(%rbp),%rdi
lea    0xed0(%rip),%rsi
mov    $0x70,%edx
call   1070 <memcpy@plt>
lea    -0x520(%rbp),%rdi
lea    0xf28(%rip),%rsi
mov    $0x70,%edx
call   1070 <memcpy@plt>
lea    -0x5a0(%rbp),%rdi
lea    0xf80(%rip),%rsi
mov    $0x70,%edx
call   1070 <memcpy@plt>
lea    -0x620(%rbp),%rdi
xor    %esi,%esi
mov    $0x70,%edx
call   1050 <memset@plt>
movq   $0x1,-0x610(%rbp)
movq   $0x2,-0x608(%rbp)
movq   $0x7fffffff,-0x5f0(%rbp)
ff ff ff 7f
mov    $0xfffffffe,%eax
mov    %rax,-0x5e8(%rbp)
mov    $0xffffffff,%eax
mov    %rax,-0x5e0(%rbp)
lea    -0x660(%rbp),%rdi
lea    0xf8c(%rip),%rsi
mov    $0x38,%edx
call   1070 <memcpy@plt>
lea    0xfd7(%rip),%rdi
mov    $0x1,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xfd5(%rip),%rdi
mov    $0x4,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xfd7(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xfbf(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xfc2(%rip),%rdi
mov    $0x4,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xfc6(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xfae(%rip),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x414(%rbp)
cmpl   $0xe,-0x414(%rbp)
jge    1747 <main+0x5f7>
movslq -0x414(%rbp),%rax
mov    -0x4a0(%rbp,%rax,8),%rax
ff
mov    %rax,-0x420(%rbp)
lea    -0x410(%rbp),%rdi
cvtsi2ssq -0x420(%rbp),%xmm0
ff ff
lea    0xf76(%rip),%rsi
call   1030 <pack@plt>
lea    -0x410(%rbp),%rdi
lea    0xf63(%rip),%rsi
lea    -0x428(%rbp),%rdx
mov    $0x0,%al
call   1060 <unpack@plt>
mov    -0x428(%rbp),%rax
cmp    -0x420(%rbp),%rax
je     13bb <main+0x26b>
mov    -0x420(%rbp),%rax
mov    -0x428(%rbp),%rdx
lea    0xf2e(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x420(%rbp),%rax
lea    0xf28(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x428(%rbp),%rax
lea    0xf23(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x410(%rbp),%sil
movzbl -0x40f(%rbp),%edx
movzbl -0x40e(%rbp),%ecx
movzbl -0x40d(%rbp),%r8d
ff
movzbl -0x40c(%rbp),%r9d
ff
movzbl -0x40b(%rbp),%r11d
ff
movzbl -0x40a(%rbp),%r10d
ff
movzbl -0x409(%rbp),%eax
lea    0xee9(%rip),%rdi
movzbl %sil,%esi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13c0 <main+0x270>
jmp    13c0 <main+0x270>
movslq -0x414(%rbp),%rax
mov    -0x520(%rbp,%rax,8),%rax
ff
mov    %rax,-0x4a8(%rbp)
lea    -0x410(%rbp),%rax
mov    %rax,-0x7a8(%rbp)
mov    -0x4a8(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x79c(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x798(%rbp)
ff
js     1430 <main+0x2e0>
movss  -0x79c(%rbp),%xmm0
ff
movss  %xmm0,-0x798(%rbp)
ff
mov    -0x7a8(%rbp),%rdi
movss  -0x798(%rbp),%xmm0
ff
lea    0xe85(%rip),%rsi
call   1030 <pack@plt>
lea    -0x410(%rbp),%rdi
lea    0xe72(%rip),%rsi
lea    -0x4b0(%rbp),%rdx
mov    $0x0,%al
call   1060 <unpack@plt>
mov    -0x4b0(%rbp),%rax
cmp    -0x4a8(%rbp),%rax
je     149f <main+0x34f>
mov    -0x4a8(%rbp),%rax
mov    -0x4b0(%rbp),%rdx
lea    0xe3d(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    14a4 <main+0x354>
jmp    14a4 <main+0x354>
movslq -0x414(%rbp),%rax
mov    -0x5a0(%rbp,%rax,8),%rax
ff
mov    %rax,-0x528(%rbp)
lea    -0x410(%rbp),%rdi
cvtsi2ssq -0x528(%rbp),%xmm0
ff ff
lea    0xe0e(%rip),%rsi
call   1030 <pack@plt>
lea    -0x410(%rbp),%rdi
lea    0xdfb(%rip),%rsi
lea    -0x530(%rbp),%rdx
mov    $0x0,%al
call   1060 <unpack@plt>
mov    -0x530(%rbp),%rax
cmp    -0x528(%rbp),%rax
je     15bb <main+0x46b>
mov    -0x414(%rbp),%eax
mov    -0x528(%rbp),%rdx
mov    -0x530(%rbp),%rcx
lea    0xdc0(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x528(%rbp),%rax
lea    0xdbc(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x530(%rbp),%rax
lea    0xdb5(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x410(%rbp),%sil
movzbl -0x40f(%rbp),%edx
movzbl -0x40e(%rbp),%ecx
movzbl -0x40d(%rbp),%r8d
ff
movzbl -0x40c(%rbp),%r9d
ff
movzbl -0x40b(%rbp),%r11d
ff
movzbl -0x40a(%rbp),%r10d
ff
movzbl -0x409(%rbp),%eax
lea    0xce9(%rip),%rdi
movzbl %sil,%esi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1040 <printf@plt>
jmp    15c0 <main+0x470>
jmp    15c0 <main+0x470>
movslq -0x414(%rbp),%rax
mov    -0x620(%rbp,%rax,8),%rax
ff
mov    %rax,-0x5a8(%rbp)
lea    -0x410(%rbp),%rax
mov    %rax,-0x7b8(%rbp)
mov    -0x5a8(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x7b0(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x7ac(%rbp)
ff
js     1630 <main+0x4e0>
movss  -0x7b0(%rbp),%xmm0
ff
movss  %xmm0,-0x7ac(%rbp)
ff
mov    -0x7b8(%rbp),%rdi
movss  -0x7ac(%rbp),%xmm0
ff
lea    0xcd1(%rip),%rsi
call   1030 <pack@plt>
lea    -0x410(%rbp),%rdi
lea    0xcbe(%rip),%rsi
lea    -0x5b0(%rbp),%rdx
mov    $0x0,%al
call   1060 <unpack@plt>
mov    -0x5b0(%rbp),%rax
cmp    -0x5a8(%rbp),%rax
je     16a5 <main+0x555>
mov    -0x414(%rbp),%eax
mov    -0x5a8(%rbp),%rdx
mov    -0x5b0(%rbp),%rcx
lea    0xc83(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    16aa <main+0x55a>
jmp    16aa <main+0x55a>
movslq -0x414(%rbp),%rax
mov    -0x660(%rbp,%rax,4),%eax
mov    %eax,-0x624(%rbp)
lea    -0x410(%rbp),%rdi
cvtsi2ssl -0x624(%rbp),%xmm0
ff
lea    0xc59(%rip),%rsi
call   1030 <pack@plt>
lea    -0x410(%rbp),%rdi
lea    0xc46(%rip),%rsi
lea    -0x628(%rbp),%rdx
mov    $0x0,%al
call   1060 <unpack@plt>
mov    -0x628(%rbp),%eax
cmp    -0x624(%rbp),%eax
je     1729 <main+0x5d9>
mov    -0x624(%rbp),%eax
mov    -0x628(%rbp),%edx
lea    0xc15(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    172e <main+0x5de>
jmp    172e <main+0x5de>
jmp    1733 <main+0x5e3>
mov    -0x414(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x414(%rbp)
jmp    129d <main+0x14d>
fldl   0x8b3(%rip)
fstpt  -0x6e0(%rbp)
fldz
fstpt  -0x6d0(%rbp)
fld1
fld    %st(0)
fstpt  -0x6c0(%rbp)
fchs
fstpt  -0x6b0(%rbp)
mov    0x286c(%rip),%rcx
mov    (%rcx),%eax
add    %eax,%eax
mov    %eax,-0x788(%rbp)
fildl  -0x788(%rbp)
fstpt  -0x6a0(%rbp)
mov    0x2847(%rip),%rax
mov    (%rax),%edx
mov    %edx,%esi
shr    $0x1f,%esi
add    %esi,%edx
sar    %edx
mov    %edx,-0x784(%rbp)
fildl  -0x784(%rbp)
fstpt  -0x690(%rbp)
mov    (%rcx),%ecx
mov    %ecx,-0x780(%rbp)
fildl  -0x780(%rbp)
fstpt  -0x680(%rbp)
mov    (%rax),%eax
mov    %eax,-0x77c(%rbp)
fildl  -0x77c(%rbp)
fstpt  -0x670(%rbp)
movq   $0x0,-0x528(%rbp)
cmpq   $0x8,-0x528(%rbp)
08
jge    197f <main+0x82f>
mov    -0x528(%rbp),%rax
shl    $0x4,%rax
fldt   -0x6e0(%rbp,%rax,1)
fstpt  -0x6f0(%rbp)
fldt   -0x6f0(%rbp)
fstps  -0x78c(%rbp)
movss  -0x78c(%rbp),%xmm0
ff
lea    0xb1b(%rip),%rsi
mov    %rsi,-0x7c0(%rbp)
lea    -0x410(%rbp),%rdi
mov    %rdi,-0x7c8(%rbp)
call   1030 <pack@plt>
mov    -0x7c8(%rbp),%rdi
mov    -0x7c0(%rbp),%rsi
xor    %eax,%eax
lea    -0x700(%rbp),%rdx
call   1060 <unpack@plt>
fldt   -0x700(%rbp)
fldt   -0x6f0(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    187b <main+0x72b>
jp     187b <main+0x72b>
jmp    195e <main+0x80e>
fldt   -0x6f0(%rbp)
fnstcw -0x790(%rbp)
movzwl -0x790(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0x792(%rbp)
fldcw  -0x792(%rbp)
fistps -0x78e(%rbp)
fldcw  -0x790(%rbp)
mov    -0x78e(%rbp),%al
fldt   -0x700(%rbp)
mov    %rsp,%rcx
fstpt  (%rcx)
movzbl %al,%esi
lea    0xa78(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x6f0(%rbp),%rax
lea    0x985(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x700(%rbp),%rax
lea    0x980(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x410(%rbp),%sil
movzbl -0x40f(%rbp),%edx
movzbl -0x40e(%rbp),%ecx
movzbl -0x40d(%rbp),%r8d
ff
movzbl -0x40c(%rbp),%r9d
ff
movzbl -0x40b(%rbp),%r11d
ff
movzbl -0x40a(%rbp),%r10d
ff
movzbl -0x409(%rbp),%eax
lea    0x946(%rip),%rdi
movzbl %sil,%esi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1963 <main+0x813>
jmp    1963 <main+0x813>
jmp    1968 <main+0x818>
mov    -0x528(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x528(%rbp)
jmp    17e1 <main+0x691>
lea    -0x740(%rbp),%rdi
xor    %esi,%esi
mov    $0x38,%edx
call   1050 <memset@plt>
movsd  0x696(%rip),%xmm0
movsd  %xmm0,-0x738(%rbp)
ff
movsd  0x67e(%rip),%xmm0
movsd  %xmm0,-0x730(%rbp)
ff
movsd  0x666(%rip),%xmm0
movsd  %xmm0,-0x728(%rbp)
ff
movsd  0x64e(%rip),%xmm0
movsd  %xmm0,-0x720(%rbp)
ff
movsd  0x636(%rip),%xmm0
movsd  %xmm0,-0x718(%rbp)
ff
movsd  0x61e(%rip),%xmm0
movsd  %xmm0,-0x710(%rbp)
ff
movq   $0x0,-0x528(%rbp)
cmpq   $0x7,-0x528(%rbp)
07
jge    1b51 <main+0xa01>
mov    -0x528(%rbp),%rax
movsd  -0x740(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x748(%rbp)
ff
lea    -0x410(%rbp),%rdi
movsd  -0x748(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
lea    0x913(%rip),%rsi
call   1030 <pack@plt>
lea    -0x410(%rbp),%rdi
lea    0x900(%rip),%rsi
lea    -0x750(%rbp),%rdx
mov    $0x0,%al
call   1060 <unpack@plt>
movsd  -0x750(%rbp),%xmm0
ff
ucomisd -0x748(%rbp),%xmm0
ff
jne    1a7f <main+0x92f>
jp     1a7f <main+0x92f>
jmp    1b30 <main+0x9e0>
cvttsd2si -0x748(%rbp),%eax
ff
movsd  -0x750(%rbp),%xmm0
ff
lea    0x8bc(%rip),%rdi
movzbl %al,%esi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x748(%rbp),%rax
lea    0x7b3(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x750(%rbp),%rax
lea    0x7ae(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x410(%rbp),%sil
movzbl -0x40f(%rbp),%edx
movzbl -0x40e(%rbp),%ecx
movzbl -0x40d(%rbp),%r8d
ff
movzbl -0x40c(%rbp),%r9d
ff
movzbl -0x40b(%rbp),%r11d
ff
movzbl -0x40a(%rbp),%r10d
ff
movzbl -0x409(%rbp),%eax
lea    0x774(%rip),%rdi
movzbl %sil,%esi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1b35 <main+0x9e5>
jmp    1b35 <main+0x9e5>
jmp    1b3a <main+0x9ea>
mov    -0x528(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x528(%rbp)
jmp    19fd <main+0x8ad>
mov    0x678(%rip),%rax
mov    %rax,-0x770(%rbp)
mov    0x672(%rip),%rax
mov    %rax,-0x768(%rbp)
mov    0x66c(%rip),%rax
mov    %rax,-0x760(%rbp)
mov    0x667(%rip),%eax
mov    %eax,-0x758(%rbp)
movq   $0x0,-0x528(%rbp)
cmpq   $0x7,-0x528(%rbp)
07
jge    1ce3 <main+0xb93>
mov    -0x528(%rbp),%rax
movss  -0x770(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x774(%rbp)
ff
lea    -0x410(%rbp),%rdi
movss  -0x774(%rbp),%xmm0
ff
lea    0x799(%rip),%rsi
call   1030 <pack@plt>
lea    -0x410(%rbp),%rdi
lea    0x786(%rip),%rsi
lea    -0x778(%rbp),%rdx
mov    $0x0,%al
call   1060 <unpack@plt>
movss  -0x778(%rbp),%xmm0
ff
ucomiss -0x774(%rbp),%xmm0
jne    1c0f <main+0xabf>
jp     1c0f <main+0xabf>
jmp    1cc2 <main+0xb72>
cvttss2si -0x774(%rbp),%eax
ff
movss  -0x778(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x73f(%rip),%rdi
movzbl %al,%esi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x774(%rbp),%eax
lea    0x737(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x778(%rbp),%eax
lea    0x730(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x410(%rbp),%sil
movzbl -0x40f(%rbp),%edx
movzbl -0x40e(%rbp),%ecx
movzbl -0x40d(%rbp),%r8d
ff
movzbl -0x40c(%rbp),%r9d
ff
movzbl -0x40b(%rbp),%r11d
ff
movzbl -0x40a(%rbp),%r10d
ff
movzbl -0x409(%rbp),%eax
lea    0x5e2(%rip),%rdi
movzbl %sil,%esi
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1cc7 <main+0xb77>
jmp    1cc7 <main+0xb77>
jmp    1ccc <main+0xb7c>
mov    -0x528(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x528(%rbp)
jmp    1b92 <main+0xa42>
xor    %eax,%eax
add    $0x7e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x568,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,0x130(%rsp)
movaps %xmm0,0x150(%rsp)
movaps %xmm0,0x140(%rsp)
movaps %xmm0,0x110(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps 0xe8d(%rip),%xmm0
movaps %xmm0,0x100(%rsp)
movaps 0xe8e(%rip),%xmm0
movaps %xmm0,0x120(%rsp)
mov    $0xffffffff,%eax
mov    %rax,0x130(%rsp)
lea    0x106e(%rip),%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x106c(%rip),%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x106e(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x1056(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x1059(%rip),%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x105d(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x1045(%rip),%rdi
mov    $0x10,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf8d(%rip),%r12
lea    0x160(%rsp),%rbx
xor    %r13d,%r13d
xor    %r15d,%r15d
jmp    1256 <main+0x126>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15
add    $0x4,%r12
add    $0x8,%r13
cmp    $0xe,%r15
je     1560 <main+0x430>
lea    0xe03(%rip),%rax
mov    0x0(%r13,%rax,1),%r14
xorps  %xmm0,%xmm0
cvtsi2ss %r14,%xmm0
mov    %rbx,%rdi
mov    %rbx,%rbp
lea    0xff6(%rip),%rbx
mov    %rbx,%rsi
call   1030 <pack@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
lea    0x48(%rsp),%rdx
xor    %eax,%eax
call   1050 <unpack@plt>
mov    0x48(%rsp),%rdx
cmp    %r14,%rdx
je     1333 <main+0x203>
movzbl %r14b,%ebp
lea    0xfc5(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xfc7(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x48(%rsp),%esi
lea    0xfc5(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x160(%rsp),%esi
movzbl 0x161(%rsp),%edx
movzbl 0x162(%rsp),%ecx
movzbl 0x163(%rsp),%r8d
movzbl 0x164(%rsp),%r9d
movzbl 0x165(%rsp),%r10d
movzbl 0x166(%rsp),%ebx
movzbl 0x167(%rsp),%ebp
sub    $0x8,%rsp
lea    0xf83(%rip),%rdi
xor    %eax,%eax
push   %rbp
push   %rbx
push   %r10
call   1040 <printf@plt>
add    $0x20,%rsp
lea    0xd96(%rip),%rax
mov    0x0(%r13,%rax,1),%rbp
test   %rbp,%rbp
js     1350 <main+0x220>
xorps  %xmm0,%xmm0
cvtsi2ss %rbp,%xmm0
jmp    136a <main+0x23a>
xchg   %ax,%ax
mov    %rbp,%rax
shr    %rax
mov    %ebp,%ecx
and    $0x1,%ecx
or     %rax,%rcx
xorps  %xmm0,%xmm0
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
lea    0x160(%rsp),%rbx
mov    %rbx,%rdi
lea    0xf6f(%rip),%r14
mov    %r14,%rsi
call   1030 <pack@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
lea    0x58(%rsp),%rdx
xor    %eax,%eax
call   1050 <unpack@plt>
mov    0x58(%rsp),%rdx
cmp    %rbp,%rdx
je     13b2 <main+0x282>
movzbl %bpl,%esi
lea    0xf42(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xd87(%rip),%rax
mov    0x0(%r13,%rax,1),%rbp
xorps  %xmm0,%xmm0
cvtsi2ss %rbp,%xmm0
mov    %rbx,%rdi
lea    0xf2f(%rip),%r14
mov    %r14,%rsi
call   1030 <pack@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
lea    0x40(%rsp),%rdx
xor    %eax,%eax
call   1050 <unpack@plt>
mov    0x40(%rsp),%rcx
cmp    %rbp,%rcx
je     1497 <main+0x367>
movzbl %r15b,%esi
lea    0xefe(%rip),%rdi
mov    %rbp,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
movzbl %bpl,%esi
lea    0xefd(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x40(%rsp),%esi
lea    0xefb(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x160(%rsp),%esi
movzbl 0x161(%rsp),%edx
movzbl 0x162(%rsp),%ecx
movzbl 0x163(%rsp),%r8d
movzbl 0x164(%rsp),%r9d
movzbl 0x165(%rsp),%r10d
movzbl 0x166(%rsp),%ebx
movzbl 0x167(%rsp),%ebp
sub    $0x8,%rsp
lea    0xe27(%rip),%rdi
xor    %eax,%eax
push   %rbp
push   %rbx
lea    0x178(%rsp),%rbx
push   %r10
call   1040 <printf@plt>
add    $0x20,%rsp
mov    0xf0(%rsp,%r15,8),%r14
test   %r14,%r14
js     14b0 <main+0x380>
xorps  %xmm0,%xmm0
cvtsi2ss %r14,%xmm0
jmp    14cb <main+0x39b>
xchg   %ax,%ax
mov    %r14,%rax
shr    %rax
mov    %r14d,%ecx
and    $0x1,%ecx
or     %rax,%rcx
xorps  %xmm0,%xmm0
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
mov    %rbx,%rdi
lea    0xe62(%rip),%rbp
mov    %rbp,%rsi
call   1030 <pack@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
lea    0x50(%rsp),%rdx
xor    %eax,%eax
call   1050 <unpack@plt>
mov    0x50(%rsp),%rcx
cmp    %r14,%rcx
je     150e <main+0x3de>
movzbl %r15b,%esi
lea    0xe35(%rip),%rdi
mov    %r14,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r12),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mov    %rbx,%rdi
lea    0xe2a(%rip),%r14
mov    %r14,%rsi
call   1030 <pack@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
lea    0x2c(%rsp),%rdx
xor    %eax,%eax
call   1050 <unpack@plt>
mov    0x2c(%rsp),%edx
cmp    %ebp,%edx
je     1240 <main+0x110>
movzbl %bpl,%esi
lea    0xdfb(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    1240 <main+0x110>
fldl   0xaea(%rip)
fld    %st(0)
fstpt  0x70(%rsp)
fldz
fstpt  0x80(%rsp)
fld1
fld    %st(0)
fstpt  0x90(%rsp)
fchs
fstpt  0xa0(%rsp)
mov    0x2a50(%rip),%rax
mov    (%rax),%eax
lea    (%rax,%rax,1),%ecx
mov    %ecx,0x24(%rsp)
fildl  0x24(%rsp)
fstpt  0xb0(%rsp)
mov    0x2a2d(%rip),%rcx
mov    (%rcx),%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
sar    %edx
mov    %edx,0x28(%rsp)
fildl  0x28(%rsp)
fstpt  0xc0(%rsp)
mov    %eax,0x1c(%rsp)
fildl  0x1c(%rsp)
fstpt  0xd0(%rsp)
mov    %ecx,0x20(%rsp)
fildl  0x20(%rsp)
fstpt  0xe0(%rsp)
mov    $0x10,%r13d
lea    0xd6d(%rip),%r15
lea    0x160(%rsp),%r14
nopl   0x0(%rax,%rax,1)
fld    %st(0)
fstpt  0x8(%rsp)
fstps  0x18(%rsp)
movss  0x18(%rsp),%xmm0
mov    %r14,%rdi
mov    %r15,%rsi
call   1030 <pack@plt>
mov    %r14,%rdi
mov    %r15,%rsi
lea    0x30(%rsp),%rdx
xor    %eax,%eax
call   1050 <unpack@plt>
fldt   0x8(%rsp)
fldt   0x30(%rsp)
fucomi %st(1),%st
jne    163f <main+0x50f>
jnp    1711 <main+0x5e1>
fld    %st(1)
fstpt  0x60(%rsp)
fnstcw 0x2(%rsp)
movzwl 0x2(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x4(%rsp)
fldcw  0x4(%rsp)
fxch   %st(1)
fistps 0x6(%rsp)
fldcw  0x2(%rsp)
movzbl 0x60(%rsp),%r12d
movzbl 0x6(%rsp),%esi
sub    $0x10,%rsp
fstpt  (%rsp)
lea    0xce0(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x10,%rsp
lea    0xbf0(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x30(%rsp),%esi
lea    0xbed(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x160(%rsp),%esi
movzbl 0x161(%rsp),%edx
movzbl 0x162(%rsp),%ecx
movzbl 0x163(%rsp),%r8d
movzbl 0x164(%rsp),%r9d
movzbl 0x165(%rsp),%r10d
movzbl 0x166(%rsp),%ebp
movzbl 0x167(%rsp),%ebx
sub    $0x8,%rsp
lea    0xbab(%rip),%rdi
xor    %eax,%eax
push   %rbx
push   %rbp
push   %r10
call   1040 <printf@plt>
add    $0x20,%rsp
fldz
fldz
fxch   %st(1)
fstp   %st(0)
fstp   %st(0)
cmp    $0x80,%r13
je     172c <main+0x5fc>
fldt   0x70(%rsp,%r13,1)
add    $0x10,%r13
jmp    1600 <main+0x4d0>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0x8e5(%rip),%xmm0
movups %xmm0,0x78(%rsp)
movaps 0x8e9(%rip),%xmm0
movups %xmm0,0x88(%rsp)
movapd 0x8e9(%rip),%xmm0
movupd %xmm0,0x98(%rsp)
lea    0xc09(%rip),%r13
lea    0x160(%rsp),%r15
lea    0x30(%rsp),%r14
xor    %r12d,%r12d
jmp    178e <main+0x65e>
nopl   0x0(%rax)
add    $0x1,%r12
cmp    $0x7,%r12
je     1874 <main+0x744>
movsd  0x70(%rsp,%r12,8),%xmm0
movsd  %xmm0,0x8(%rsp)
cvtsd2ss %xmm0,%xmm0
mov    %r15,%rdi
mov    %r13,%rsi
call   1030 <pack@plt>
mov    %r15,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1050 <unpack@plt>
movsd  0x30(%rsp),%xmm0
movsd  0x8(%rsp),%xmm2
ucomisd %xmm2,%xmm0
jne    17ce <main+0x69e>
jnp    1780 <main+0x650>
cvttsd2si %xmm2,%eax
movzbl %al,%esi
lea    0xb96(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movq   0x8(%rsp),%xmm0
movq   %xmm0,%rax
movzbl %al,%esi
lea    0xa89(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x30(%rsp),%esi
lea    0xa89(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x160(%rsp),%esi
movzbl 0x161(%rsp),%edx
movzbl 0x162(%rsp),%ecx
movzbl 0x163(%rsp),%r8d
movzbl 0x164(%rsp),%r9d
movzbl 0x165(%rsp),%r10d
movzbl 0x166(%rsp),%ebp
movzbl 0x167(%rsp),%ebx
sub    $0x8,%rsp
lea    0xa47(%rip),%rdi
xor    %eax,%eax
push   %rbx
push   %rbp
push   %r10
call   1040 <printf@plt>
add    $0x20,%rsp
jmp    1780 <main+0x650>
lea    0xb0c(%rip),%r15
lea    0x160(%rsp),%r12
lea    0x70(%rsp),%r14
xor    %r13d,%r13d
jmp    189e <main+0x76e>
nopl   (%rax)
add    $0x4,%r13
cmp    $0x1c,%r13
je     1989 <main+0x859>
lea    0x94b(%rip),%rax
movss  0x0(%r13,%rax,1),%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r12,%rdi
mov    %r15,%rsi
call   1030 <pack@plt>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1050 <unpack@plt>
movss  0x70(%rsp),%xmm0
movss  0x8(%rsp),%xmm2
ucomiss %xmm2,%xmm0
jne    18e0 <main+0x7b0>
jnp    1890 <main+0x760>
cvttss2si %xmm2,%eax
cvtss2sd %xmm0,%xmm0
movzbl %al,%esi
lea    0xa97(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movd   0x8(%rsp),%xmm0
movd   %xmm0,%eax
movzbl %al,%esi
lea    0xa8b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x70(%rsp),%esi
lea    0xa88(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x160(%rsp),%esi
movzbl 0x161(%rsp),%edx
movzbl 0x162(%rsp),%ecx
movzbl 0x163(%rsp),%r8d
movzbl 0x164(%rsp),%r9d
movzbl 0x165(%rsp),%r10d
movzbl 0x166(%rsp),%ebp
movzbl 0x167(%rsp),%ebx
sub    $0x8,%rsp
lea    0x932(%rip),%rdi
xor    %eax,%eax
push   %rbx
push   %rbp
push   %r10
call   1040 <printf@plt>
add    $0x20,%rsp
jmp    1890 <main+0x760>
xor    %eax,%eax
add    $0x568,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.main.test64 = [14 x i64] [i64 0, i64 0, i64 1, i64 2, i64 -1, i64 -2, i64 4611686018427387903, i64 9223372036854775806, i64 9223372036854775807, i64 -9223372036854775807, i64 -9223372036854775808, i64 9007199254740991, i64 9007199254740992, i64 9007199254740993]
@__const.main.testu64 = [14 x i64] [i64 0, i64 0, i64 1, i64 2, i64 0, i64 0, i64 9223372036854775807, i64 -2, i64 -1, i64 0, i64 0, i64 9007199254740991, i64 9007199254740992, i64 9007199254740993]
@__const.main.test32 = [14 x i64] [i64 0, i64 0, i64 1, i64 2, i64 -1, i64 -2, i64 1073741823, i64 2147483646, i64 2147483647, i64 -2147483647, i64 -2147483648, i64 0, i64 0, i64 0]
@__const.main.test16 = [14 x i32] [i32 0, i32 0, i32 1, i32 2, i32 -1, i32 -2, i32 16383, i32 32766, i32 32767, i32 -32767, i32 -32768, i32 0, i32 0, i32 0]
@.str = [17 x i8] c"char bytes: %zu\0A\00"
@.str.1 = [16 x i8] c"int bytes: %zu\0A\00"
@.str.2 = [17 x i8] c"long bytes: %zu\0A\00"
@.str.3 = [22 x i8] c"long long bytes: %zu\0A\00"
@.str.4 = [18 x i8] c"float bytes: %zu\0A\00"
@.str.5 = [19 x i8] c"double bytes: %zu\0A\00"
@.str.6 = [24 x i8] c"long double bytes: %zu\0A\00"
@.str.7 = [2 x i8] c"q\00"
@.str.8 = [18 x i8] c"64: %lld != %lld\0A\00"
@.str.9 = [19 x i8] c" before: %016llx\0A\00"
@.str.10 = [19 x i8] c" after: %016llx\0A\00"
@.str.11 = [68 x i8] c" buffer: %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\0A\00"
@.str.12 = [2 x i8] c"Q\00"
@.str.13 = [18 x i8] c"64: %llu != %llu\0A\00"
@.str.14 = [2 x i8] c"l\00"
@.str.15 = [20 x i8] c"32(%d): %ld != %ld\0A\00"
@.str.16 = [17 x i8] c" before: %08lx\0A\00"
@.str.17 = [17 x i8] c" after: %08lx\0A\00"
@.str.18 = [2 x i8] c"L\00"
@.str.19 = [20 x i8] c"32(%d): %lu != %lu\0A\00"
@.str.20 = [2 x i8] c"h\00"
@.str.21 = [14 x i8] c"16: %d != %d\0A\00"
@DBL_MIN = global i32 0
@DBL_MAX = global i32 0
@.str.22 = [2 x i8] c"g\00"
@.str.23 = [17 x i8] c"f64: %Lf != %Lf\0A\00"
@.str.24 = [2 x i8] c"d\00"
@.str.25 = [21 x i8] c"f32: %.10f != %.10f\0A\00"
@__const.main.testf16 = [7 x float] [float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float 1.000000e+01, float -1.000000e+01, float 3.187500e+00, float -3.187500e+00]
@.str.26 = [2 x i8] c"f\00"
@.str.27 = [15 x i8] c"f16: %f != %f\0A\00"
@.str.28 = [16 x i8] c" before: %08x\0A\00"
@.str.29 = [16 x i8] c" after: %08x\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [1024 x i8]
%3 = alloca i32
%4 = alloca i64
%5 = alloca i64
%6 = alloca [14 x i64]
%7 = alloca i64
%8 = alloca i64
%9 = alloca [14 x i64]
%10 = alloca i64
%11 = alloca i64
%12 = alloca [14 x i64]
%13 = alloca i64
%14 = alloca i64
%15 = alloca [14 x i64]
%16 = alloca i32
%17 = alloca i32
%18 = alloca [14 x i32]
%19 = alloca [8 x x86_fp80]
%20 = alloca x86_fp80
%21 = alloca x86_fp80
%22 = alloca [7 x double]
%23 = alloca double
%24 = alloca double
%25 = alloca [7 x float]
%26 = alloca float
%27 = alloca float
store i32 0, i32* %1
%28 = bitcast [14 x i64]* %6 to i8*
%29 = bitcast [14 x i64]* %9 to i8*
%30 = bitcast [14 x i64]* %12 to i8*
%31 = bitcast [14 x i64]* %15 to i8*
%32 = bitcast i8* %31 to [14 x i64]*
%33 = getelementptr inbounds [14 x i64], [14 x i64]* %32, i32 0, i32 2
store i64 1, i64* %33
%34 = getelementptr inbounds [14 x i64], [14 x i64]* %32, i32 0, i32 3
store i64 2, i64* %34
%35 = getelementptr inbounds [14 x i64], [14 x i64]* %32, i32 0, i32 6
store i64 2147483647, i64* %35
%36 = getelementptr inbounds [14 x i64], [14 x i64]* %32, i32 0, i32 7
store i64 4294967294, i64* %36
%37 = getelementptr inbounds [14 x i64], [14 x i64]* %32, i32 0, i32 8
store i64 4294967295, i64* %37
%38 = bitcast [14 x i32]* %18 to i8*
%39 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), i8 zeroext 1)
%40 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i8 zeroext 4)
%41 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i8 zeroext 8)
%42 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0), i8 zeroext 8)
%43 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0), i8 zeroext 4)
%44 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.5, i64 0, i64 0), i8 zeroext 8)
%45 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.6, i64 0, i64 0), i8 zeroext 16)
store i32 0, i32* %3
br label %46
46: ; preds = %212, %0
%47 = load i32, i32* %3
%48 = icmp slt i32 %47, 14
br i1 %48, label %49, label %215
49: ; preds = %46
%50 = load i32, i32* %3
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [14 x i64], [14 x i64]* %6, i64 0, i64 %51
%53 = load i64, i64* %52
store i64 %53, i64* %4
%54 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%55 = load i64, i64* %4
%56 = sitofp i64 %55 to float
%57 = call i32 @pack(i8* %54, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), float %56)
%58 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%59 = call i32 (i8*, i8*, ...) @unpack(i8* %58, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i64* %5)
%60 = load i64, i64* %5
%61 = load i64, i64* %4
%62 = icmp ne i64 %60, %61
br i1 %62, label %63, label %98
63: ; preds = %49
%64 = load i64, i64* %4
%65 = trunc i64 %64 to i8
%66 = load i64, i64* %5
%67 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0), i8 zeroext %65, i64 %66)
%68 = load i64, i64* %4
%69 = trunc i64 %68 to i8
%70 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), i8 zeroext %69)
%71 = load i64, i64* %5
%72 = trunc i64 %71 to i8
%73 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i8 zeroext %72)
%74 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%75 = load i8, i8* %74
%76 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 1
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 2
%80 = load i8, i8* %79
%81 = zext i8 %80 to i32
%82 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 3
%83 = load i8, i8* %82
%84 = zext i8 %83 to i32
%85 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 4
%86 = load i8, i8* %85
%87 = zext i8 %86 to i32
%88 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 5
%89 = load i8, i8* %88
%90 = zext i8 %89 to i32
%91 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 6
%92 = load i8, i8* %91
%93 = zext i8 %92 to i32
%94 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 7
%95 = load i8, i8* %94
%96 = zext i8 %95 to i32
%97 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %75, i32 %78, i32 %81, i32 %84, i32 %87, i32 %90, i32 %93, i32 %96)
br label %99
98: ; preds = %49
br label %99
99: ; preds = %98, %63
%100 = load i32, i32* %3
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [14 x i64], [14 x i64]* %9, i64 0, i64 %101
%103 = load i64, i64* %102
store i64 %103, i64* %7
%104 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%105 = load i64, i64* %7
%106 = uitofp i64 %105 to float
%107 = call i32 @pack(i8* %104, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), float %106)
%108 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%109 = call i32 (i8*, i8*, ...) @unpack(i8* %108, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i64* %8)
%110 = load i64, i64* %8
%111 = load i64, i64* %7
%112 = icmp ne i64 %110, %111
br i1 %112, label %113, label %118
113: ; preds = %99
%114 = load i64, i64* %7
%115 = trunc i64 %114 to i8
%116 = load i64, i64* %8
%117 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0), i8 zeroext %115, i64 %116)
br label %119
118: ; preds = %99
br label %119
119: ; preds = %118, %113
%120 = load i32, i32* %3
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [14 x i64], [14 x i64]* %12, i64 0, i64 %121
%123 = load i64, i64* %122
store i64 %123, i64* %10
%124 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%125 = load i64, i64* %10
%126 = sitofp i64 %125 to float
%127 = call i32 @pack(i8* %124, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), float %126)
%128 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%129 = call i32 (i8*, i8*, ...) @unpack(i8* %128, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), i64* %11)
%130 = load i64, i64* %11
%131 = load i64, i64* %10
%132 = icmp ne i64 %130, %131
br i1 %132, label %133, label %169
133: ; preds = %119
%134 = load i32, i32* %3
%135 = trunc i32 %134 to i8
%136 = load i64, i64* %10
%137 = load i64, i64* %11
%138 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.15, i64 0, i64 0), i8 zeroext %135, i64 %136, i64 %137)
%139 = load i64, i64* %10
%140 = trunc i64 %139 to i8
%141 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.16, i64 0, i64 0), i8 zeroext %140)
%142 = load i64, i64* %11
%143 = trunc i64 %142 to i8
%144 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.17, i64 0, i64 0), i8 zeroext %143)
%145 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%146 = load i8, i8* %145
%147 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 1
%148 = load i8, i8* %147
%149 = zext i8 %148 to i32
%150 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 2
%151 = load i8, i8* %150
%152 = zext i8 %151 to i32
%153 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 3
%154 = load i8, i8* %153
%155 = zext i8 %154 to i32
%156 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 4
%157 = load i8, i8* %156
%158 = zext i8 %157 to i32
%159 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 5
%160 = load i8, i8* %159
%161 = zext i8 %160 to i32
%162 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 6
%163 = load i8, i8* %162
%164 = zext i8 %163 to i32
%165 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 7
%166 = load i8, i8* %165
%167 = zext i8 %166 to i32
%168 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %146, i32 %149, i32 %152, i32 %155, i32 %158, i32 %161, i32 %164, i32 %167)
br label %170
169: ; preds = %119
br label %170
170: ; preds = %169, %133
%171 = load i32, i32* %3
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [14 x i64], [14 x i64]* %15, i64 0, i64 %172
%174 = load i64, i64* %173
store i64 %174, i64* %13
%175 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%176 = load i64, i64* %13
%177 = uitofp i64 %176 to float
%178 = call i32 @pack(i8* %175, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0), float %177)
%179 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%180 = call i32 (i8*, i8*, ...) @unpack(i8* %179, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0), i64* %14)
%181 = load i64, i64* %14
%182 = load i64, i64* %13
%183 = icmp ne i64 %181, %182
br i1 %183, label %184, label %190
184: ; preds = %170
%185 = load i32, i32* %3
%186 = trunc i32 %185 to i8
%187 = load i64, i64* %13
%188 = load i64, i64* %14
%189 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.19, i64 0, i64 0), i8 zeroext %186, i64 %187, i64 %188)
br label %191
190: ; preds = %170
br label %191
191: ; preds = %190, %184
%192 = load i32, i32* %3
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [14 x i32], [14 x i32]* %18, i64 0, i64 %193
%195 = load i32, i32* %194
store i32 %195, i32* %16
%196 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%197 = load i32, i32* %16
%198 = sitofp i32 %197 to float
%199 = call i32 @pack(i8* %196, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float %198)
%200 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%201 = call i32 (i8*, i8*, ...) @unpack(i8* %200, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i32* %17)
%202 = load i32, i32* %17
%203 = load i32, i32* %16
%204 = icmp ne i32 %202, %203
br i1 %204, label %205, label %210
205: ; preds = %191
%206 = load i32, i32* %16
%207 = trunc i32 %206 to i8
%208 = load i32, i32* %17
%209 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.21, i64 0, i64 0), i8 zeroext %207, i32 %208)
br label %211
210: ; preds = %191
br label %211
211: ; preds = %210, %205
br label %212
212: ; preds = %211
%213 = load i32, i32* %3
%214 = add nsw i32 %213, 1
store i32 %214, i32* %3
br label %46
215: ; preds = %46
%216 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %19, i64 0, i64 0
store x86_fp80 0xKC00ADA2AAEE631F8A000, x86_fp80* %216
%217 = getelementptr inbounds x86_fp80, x86_fp80* %216, i64 1
store x86_fp80 0xK00000000000000000000, x86_fp80* %217
%218 = getelementptr inbounds x86_fp80, x86_fp80* %217, i64 1
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %218
%219 = getelementptr inbounds x86_fp80, x86_fp80* %218, i64 1
store x86_fp80 0xKBFFF8000000000000000, x86_fp80* %219
%220 = getelementptr inbounds x86_fp80, x86_fp80* %219, i64 1
%221 = load i32, i32* @DBL_MIN
%222 = mul nsw i32 %221, 2
%223 = sitofp i32 %222 to x86_fp80
store x86_fp80 %223, x86_fp80* %220
%224 = getelementptr inbounds x86_fp80, x86_fp80* %220, i64 1
%225 = load i32, i32* @DBL_MAX
%226 = sdiv i32 %225, 2
%227 = sitofp i32 %226 to x86_fp80
store x86_fp80 %227, x86_fp80* %224
%228 = getelementptr inbounds x86_fp80, x86_fp80* %224, i64 1
%229 = load i32, i32* @DBL_MIN
%230 = sitofp i32 %229 to x86_fp80
store x86_fp80 %230, x86_fp80* %228
%231 = getelementptr inbounds x86_fp80, x86_fp80* %228, i64 1
%232 = load i32, i32* @DBL_MAX
%233 = sitofp i32 %232 to x86_fp80
store x86_fp80 %233, x86_fp80* %231
store i64 0, i64* %10
br label %234
234: ; preds = %289, %215
%235 = load i64, i64* %10
%236 = icmp slt i64 %235, 8
br i1 %236, label %237, label %292
237: ; preds = %234
%238 = load i64, i64* %10
%239 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %19, i64 0, i64 %238
%240 = load x86_fp80, x86_fp80* %239
store x86_fp80 %240, x86_fp80* %20
%241 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%242 = load x86_fp80, x86_fp80* %20
%243 = fptrunc x86_fp80 %242 to float
%244 = call i32 @pack(i8* %241, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), float %243)
%245 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%246 = call i32 (i8*, i8*, ...) @unpack(i8* %245, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), x86_fp80* %21)
%247 = load x86_fp80, x86_fp80* %21
%248 = load x86_fp80, x86_fp80* %20
%249 = fcmp une x86_fp80 %247, %248
br i1 %249, label %250, label %287
250: ; preds = %237
%251 = load x86_fp80, x86_fp80* %20
%252 = fptoui x86_fp80 %251 to i8
%253 = load x86_fp80, x86_fp80* %21
%254 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.23, i64 0, i64 0), i8 zeroext %252, x86_fp80 %253)
%255 = bitcast x86_fp80* %20 to i64*
%256 = load i64, i64* %255
%257 = trunc i64 %256 to i8
%258 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), i8 zeroext %257)
%259 = bitcast x86_fp80* %21 to i64*
%260 = load i64, i64* %259
%261 = trunc i64 %260 to i8
%262 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i8 zeroext %261)
%263 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%264 = load i8, i8* %263
%265 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 1
%266 = load i8, i8* %265
%267 = zext i8 %266 to i32
%268 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 2
%269 = load i8, i8* %268
%270 = zext i8 %269 to i32
%271 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 3
%272 = load i8, i8* %271
%273 = zext i8 %272 to i32
%274 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 4
%275 = load i8, i8* %274
%276 = zext i8 %275 to i32
%277 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 5
%278 = load i8, i8* %277
%279 = zext i8 %278 to i32
%280 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 6
%281 = load i8, i8* %280
%282 = zext i8 %281 to i32
%283 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 7
%284 = load i8, i8* %283
%285 = zext i8 %284 to i32
%286 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %264, i32 %267, i32 %270, i32 %273, i32 %276, i32 %279, i32 %282, i32 %285)
br label %288
287: ; preds = %237
br label %288
288: ; preds = %287, %250
br label %289
289: ; preds = %288
%290 = load i64, i64* %10
%291 = add nsw i64 %290, 1
store i64 %291, i64* %10
br label %234
292: ; preds = %234
%293 = bitcast [7 x double]* %22 to i8*
%294 = bitcast i8* %293 to [7 x double]*
%295 = getelementptr inbounds [7 x double], [7 x double]* %294, i32 0, i32 1
store double 1.000000e+00, double* %295
%296 = getelementptr inbounds [7 x double], [7 x double]* %294, i32 0, i32 2
store double -1.000000e+00, double* %296
%297 = getelementptr inbounds [7 x double], [7 x double]* %294, i32 0, i32 3
store double 1.000000e+01, double* %297
%298 = getelementptr inbounds [7 x double], [7 x double]* %294, i32 0, i32 4
store double -3.667700e+00, double* %298
%299 = getelementptr inbounds [7 x double], [7 x double]* %294, i32 0, i32 5
store double 3.187500e+00, double* %299
%300 = getelementptr inbounds [7 x double], [7 x double]* %294, i32 0, i32 6
store double -3.187500e+00, double* %300
store i64 0, i64* %10
br label %301
301: ; preds = %356, %292
%302 = load i64, i64* %10
%303 = icmp slt i64 %302, 7
br i1 %303, label %304, label %359
304: ; preds = %301
%305 = load i64, i64* %10
%306 = getelementptr inbounds [7 x double], [7 x double]* %22, i64 0, i64 %305
%307 = load double, double* %306
store double %307, double* %23
%308 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%309 = load double, double* %23
%310 = fptrunc double %309 to float
%311 = call i32 @pack(i8* %308, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.24, i64 0, i64 0), float %310)
%312 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%313 = call i32 (i8*, i8*, ...) @unpack(i8* %312, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.24, i64 0, i64 0), double* %24)
%314 = load double, double* %24
%315 = load double, double* %23
%316 = fcmp une double %314, %315
br i1 %316, label %317, label %354
317: ; preds = %304
%318 = load double, double* %23
%319 = fptoui double %318 to i8
%320 = load double, double* %24
%321 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.25, i64 0, i64 0), i8 zeroext %319, double %320)
%322 = bitcast double* %23 to i64*
%323 = load i64, i64* %322
%324 = trunc i64 %323 to i8
%325 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), i8 zeroext %324)
%326 = bitcast double* %24 to i64*
%327 = load i64, i64* %326
%328 = trunc i64 %327 to i8
%329 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i8 zeroext %328)
%330 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%331 = load i8, i8* %330
%332 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 1
%333 = load i8, i8* %332
%334 = zext i8 %333 to i32
%335 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 2
%336 = load i8, i8* %335
%337 = zext i8 %336 to i32
%338 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 3
%339 = load i8, i8* %338
%340 = zext i8 %339 to i32
%341 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 4
%342 = load i8, i8* %341
%343 = zext i8 %342 to i32
%344 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 5
%345 = load i8, i8* %344
%346 = zext i8 %345 to i32
%347 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 6
%348 = load i8, i8* %347
%349 = zext i8 %348 to i32
%350 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 7
%351 = load i8, i8* %350
%352 = zext i8 %351 to i32
%353 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %331, i32 %334, i32 %337, i32 %340, i32 %343, i32 %346, i32 %349, i32 %352)
br label %355
354: ; preds = %304
br label %355
355: ; preds = %354, %317
br label %356
356: ; preds = %355
%357 = load i64, i64* %10
%358 = add nsw i64 %357, 1
store i64 %358, i64* %10
br label %301
359: ; preds = %301
%360 = bitcast [7 x float]* %25 to i8*
store i64 0, i64* %10
br label %361
361: ; preds = %416, %359
%362 = load i64, i64* %10
%363 = icmp slt i64 %362, 7
br i1 %363, label %364, label %419
364: ; preds = %361
%365 = load i64, i64* %10
%366 = getelementptr inbounds [7 x float], [7 x float]* %25, i64 0, i64 %365
%367 = load float, float* %366
store float %367, float* %26
%368 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%369 = load float, float* %26
%370 = call i32 @pack(i8* %368, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.26, i64 0, i64 0), float %369)
%371 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%372 = call i32 (i8*, i8*, ...) @unpack(i8* %371, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.26, i64 0, i64 0), float* %27)
%373 = load float, float* %27
%374 = load float, float* %26
%375 = fcmp une float %373, %374
br i1 %375, label %376, label %414
376: ; preds = %364
%377 = load float, float* %26
%378 = fptoui float %377 to i8
%379 = load float, float* %27
%380 = fpext float %379 to double
%381 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.27, i64 0, i64 0), i8 zeroext %378, double %380)
%382 = bitcast float* %26 to i32*
%383 = load i32, i32* %382
%384 = trunc i32 %383 to i8
%385 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0), i8 zeroext %384)
%386 = bitcast float* %27 to i32*
%387 = load i32, i32* %386
%388 = trunc i32 %387 to i8
%389 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.29, i64 0, i64 0), i8 zeroext %388)
%390 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 0
%391 = load i8, i8* %390
%392 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 1
%393 = load i8, i8* %392
%394 = zext i8 %393 to i32
%395 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 2
%396 = load i8, i8* %395
%397 = zext i8 %396 to i32
%398 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 3
%399 = load i8, i8* %398
%400 = zext i8 %399 to i32
%401 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 4
%402 = load i8, i8* %401
%403 = zext i8 %402 to i32
%404 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 5
%405 = load i8, i8* %404
%406 = zext i8 %405 to i32
%407 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 6
%408 = load i8, i8* %407
%409 = zext i8 %408 to i32
%410 = getelementptr inbounds [1024 x i8], [1024 x i8]* %2, i64 0, i64 7
%411 = load i8, i8* %410
%412 = zext i8 %411 to i32
%413 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %391, i32 %394, i32 %397, i32 %400, i32 %403, i32 %406, i32 %409, i32 %412)
br label %415
414: ; preds = %364
br label %415
415: ; preds = %414, %376
br label %416
416: ; preds = %415
%417 = load i64, i64* %10
%418 = add nsw i64 %417, 1
store i64 %418, i64* %10
br label %361
419: ; preds = %361
ret i32 0
}

LLVM IR (-O2):
@__const.main.test64 = [14 x i64] [i64 0, i64 0, i64 1, i64 2, i64 -1, i64 -2, i64 4611686018427387903, i64 9223372036854775806, i64 9223372036854775807, i64 -9223372036854775807, i64 -9223372036854775808, i64 9007199254740991, i64 9007199254740992, i64 9007199254740993]
@__const.main.testu64 = [14 x i64] [i64 0, i64 0, i64 1, i64 2, i64 0, i64 0, i64 9223372036854775807, i64 -2, i64 -1, i64 0, i64 0, i64 9007199254740991, i64 9007199254740992, i64 9007199254740993]
@__const.main.test32 = [14 x i64] [i64 0, i64 0, i64 1, i64 2, i64 -1, i64 -2, i64 1073741823, i64 2147483646, i64 2147483647, i64 -2147483647, i64 -2147483648, i64 0, i64 0, i64 0]
@__const.main.test16 = [14 x i32] [i32 0, i32 0, i32 1, i32 2, i32 -1, i32 -2, i32 16383, i32 32766, i32 32767, i32 -32767, i32 -32768, i32 0, i32 0, i32 0]
@.str = [17 x i8] c"char bytes: %zu\0A\00"
@.str.1 = [16 x i8] c"int bytes: %zu\0A\00"
@.str.2 = [17 x i8] c"long bytes: %zu\0A\00"
@.str.3 = [22 x i8] c"long long bytes: %zu\0A\00"
@.str.4 = [18 x i8] c"float bytes: %zu\0A\00"
@.str.5 = [19 x i8] c"double bytes: %zu\0A\00"
@.str.6 = [24 x i8] c"long double bytes: %zu\0A\00"
@.str.7 = [2 x i8] c"q\00"
@.str.8 = [18 x i8] c"64: %lld != %lld\0A\00"
@.str.9 = [19 x i8] c" before: %016llx\0A\00"
@.str.10 = [19 x i8] c" after: %016llx\0A\00"
@.str.11 = [68 x i8] c" buffer: %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\0A\00"
@.str.12 = [2 x i8] c"Q\00"
@.str.13 = [18 x i8] c"64: %llu != %llu\0A\00"
@.str.14 = [2 x i8] c"l\00"
@.str.15 = [20 x i8] c"32(%d): %ld != %ld\0A\00"
@.str.16 = [17 x i8] c" before: %08lx\0A\00"
@.str.17 = [17 x i8] c" after: %08lx\0A\00"
@.str.18 = [2 x i8] c"L\00"
@.str.19 = [20 x i8] c"32(%d): %lu != %lu\0A\00"
@.str.20 = [2 x i8] c"h\00"
@.str.21 = [14 x i8] c"16: %d != %d\0A\00"
@DBL_MIN = global i32 0
@DBL_MAX = global i32 0
@.str.22 = [2 x i8] c"g\00"
@.str.23 = [17 x i8] c"f64: %Lf != %Lf\0A\00"
@.str.24 = [2 x i8] c"d\00"
@.str.25 = [21 x i8] c"f32: %.10f != %.10f\0A\00"
@__const.main.testf16 = [7 x float] [float 0.000000e+00, float 1.000000e+00, float -1.000000e+00, float 1.000000e+01, float -1.000000e+01, float 3.187500e+00, float -3.187500e+00]
@.str.26 = [2 x i8] c"f\00"
@.str.27 = [15 x i8] c"f16: %f != %f\0A\00"
@.str.28 = [16 x i8] c" before: %08x\0A\00"
@.str.29 = [16 x i8] c" after: %08x\0A\00"
define i32 @main() {
%1 = alloca [1024 x i8]
%2 = alloca i64
%3 = alloca i64
%4 = alloca i64
%5 = alloca i64
%6 = alloca [14 x i64]
%7 = alloca i32
%8 = alloca [8 x x86_fp80]
%9 = alloca x86_fp80
%10 = alloca [7 x double]
%11 = alloca double
%12 = alloca float
%13 = getelementptr inbounds [1024 x i8], [1024 x i8]* %1, i64 0, i64 0
%14 = bitcast i64* %2 to i8*
%15 = bitcast i64* %3 to i8*
%16 = bitcast i64* %4 to i8*
%17 = bitcast i64* %5 to i8*
%18 = bitcast [14 x i64]* %6 to i8*
%19 = getelementptr inbounds [14 x i64], [14 x i64]* %6, i64 0, i64 2
%20 = bitcast i64* %19 to <2 x i64>*
store <2 x i64> <i64 1, i64 2>, <2 x i64>* %20
%21 = getelementptr inbounds [14 x i64], [14 x i64]* %6, i64 0, i64 6
%22 = bitcast i64* %21 to <2 x i64>*
store <2 x i64> <i64 2147483647, i64 4294967294>, <2 x i64>* %22
%23 = getelementptr inbounds [14 x i64], [14 x i64]* %6, i64 0, i64 8
store i64 4294967295, i64* %23
%24 = bitcast i32* %7 to i8*
%25 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), i8 zeroext 1)
%26 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i8 zeroext 4)
%27 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i8 zeroext 8)
%28 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0), i8 zeroext 8)
%29 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0), i8 zeroext 4)
%30 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.5, i64 0, i64 0), i8 zeroext 8)
%31 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.6, i64 0, i64 0), i8 zeroext 16)
%32 = getelementptr inbounds [1024 x i8], [1024 x i8]* %1, i64 0, i64 1
%33 = getelementptr inbounds [1024 x i8], [1024 x i8]* %1, i64 0, i64 2
%34 = getelementptr inbounds [1024 x i8], [1024 x i8]* %1, i64 0, i64 3
%35 = getelementptr inbounds [1024 x i8], [1024 x i8]* %1, i64 0, i64 4
%36 = getelementptr inbounds [1024 x i8], [1024 x i8]* %1, i64 0, i64 5
%37 = getelementptr inbounds [1024 x i8], [1024 x i8]* %1, i64 0, i64 6
%38 = getelementptr inbounds [1024 x i8], [1024 x i8]* %1, i64 0, i64 7
br label %39
39: ; preds = %0, %136
%40 = phi i64 [ 0, %0 ], [ %137, %136 ]
%41 = getelementptr inbounds [14 x i64], [14 x i64]* @__const.main.test64, i64 0, i64 %40
%42 = load i64, i64* %41
%43 = sitofp i64 %42 to float
%44 = call i32 @pack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), float %43)
%45 = call i32 (i8*, i8*, ...) @unpack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i64* %2)
%46 = load i64, i64* %2
%47 = icmp eq i64 %46, %42
br i1 %47, label %71, label %48
48: ; preds = %39
%49 = trunc i64 %42 to i8
%50 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0), i8 zeroext %49, i64 %46)
%51 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), i8 zeroext %49)
%52 = load i64, i64* %2
%53 = trunc i64 %52 to i8
%54 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i8 zeroext %53)
%55 = load i8, i8* %13
%56 = load i8, i8* %32
%57 = zext i8 %56 to i32
%58 = load i8, i8* %33
%59 = zext i8 %58 to i32
%60 = load i8, i8* %34
%61 = zext i8 %60 to i32
%62 = load i8, i8* %35
%63 = zext i8 %62 to i32
%64 = load i8, i8* %36
%65 = zext i8 %64 to i32
%66 = load i8, i8* %37
%67 = zext i8 %66 to i32
%68 = load i8, i8* %38
%69 = zext i8 %68 to i32
%70 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %55, i32 %57, i32 %59, i32 %61, i32 %63, i32 %65, i32 %67, i32 %69)
br label %71
71: ; preds = %39, %48
%72 = getelementptr inbounds [14 x i64], [14 x i64]* @__const.main.testu64, i64 0, i64 %40
%73 = load i64, i64* %72
%74 = uitofp i64 %73 to float
%75 = call i32 @pack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), float %74)
%76 = call i32 (i8*, i8*, ...) @unpack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0), i64* %3)
%77 = load i64, i64* %3
%78 = icmp eq i64 %77, %73
br i1 %78, label %82, label %79
79: ; preds = %71
%80 = trunc i64 %73 to i8
%81 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0), i8 zeroext %80, i64 %77)
br label %82
82: ; preds = %71, %79
%83 = getelementptr inbounds [14 x i64], [14 x i64]* @__const.main.test32, i64 0, i64 %40
%84 = load i64, i64* %83
%85 = sitofp i64 %84 to float
%86 = call i32 @pack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), float %85)
%87 = call i32 (i8*, i8*, ...) @unpack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0), i64* %4)
%88 = load i64, i64* %4
%89 = icmp eq i64 %88, %84
br i1 %89, label %114, label %90
90: ; preds = %82
%91 = trunc i64 %40 to i8
%92 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.15, i64 0, i64 0), i8 zeroext %91, i64 %84, i64 %88)
%93 = trunc i64 %84 to i8
%94 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.16, i64 0, i64 0), i8 zeroext %93)
%95 = load i64, i64* %4
%96 = trunc i64 %95 to i8
%97 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.17, i64 0, i64 0), i8 zeroext %96)
%98 = load i8, i8* %13
%99 = load i8, i8* %32
%100 = zext i8 %99 to i32
%101 = load i8, i8* %33
%102 = zext i8 %101 to i32
%103 = load i8, i8* %34
%104 = zext i8 %103 to i32
%105 = load i8, i8* %35
%106 = zext i8 %105 to i32
%107 = load i8, i8* %36
%108 = zext i8 %107 to i32
%109 = load i8, i8* %37
%110 = zext i8 %109 to i32
%111 = load i8, i8* %38
%112 = zext i8 %111 to i32
%113 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %98, i32 %100, i32 %102, i32 %104, i32 %106, i32 %108, i32 %110, i32 %112)
br label %114
114: ; preds = %82, %90
%115 = getelementptr inbounds [14 x i64], [14 x i64]* %6, i64 0, i64 %40
%116 = load i64, i64* %115
%117 = uitofp i64 %116 to float
%118 = call i32 @pack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0), float %117)
%119 = call i32 (i8*, i8*, ...) @unpack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0), i64* %5)
%120 = load i64, i64* %5
%121 = icmp eq i64 %120, %116
br i1 %121, label %125, label %122
122: ; preds = %114
%123 = trunc i64 %40 to i8
%124 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.19, i64 0, i64 0), i8 zeroext %123, i64 %116, i64 %120)
br label %125
125: ; preds = %114, %122
%126 = getelementptr inbounds [14 x i32], [14 x i32]* @__const.main.test16, i64 0, i64 %40
%127 = load i32, i32* %126
%128 = sitofp i32 %127 to float
%129 = call i32 @pack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float %128)
%130 = call i32 (i8*, i8*, ...) @unpack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i32* %7)
%131 = load i32, i32* %7
%132 = icmp eq i32 %131, %127
br i1 %132, label %136, label %133
133: ; preds = %125
%134 = trunc i32 %127 to i8
%135 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.21, i64 0, i64 0), i8 zeroext %134, i32 %131)
br label %136
136: ; preds = %133, %125
%137 = add nuw nsw i64 %40, 1
%138 = icmp eq i64 %137, 14
br i1 %138, label %139, label %39
139: ; preds = %136
%140 = bitcast [8 x x86_fp80]* %8 to i8*
%141 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 0
store x86_fp80 0xKC00ADA2AAEE631F8A000, x86_fp80* %141
%142 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 1
store x86_fp80 0xK00000000000000000000, x86_fp80* %142
%143 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 2
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %143
%144 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 3
store x86_fp80 0xKBFFF8000000000000000, x86_fp80* %144
%145 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 4
%146 = load i32, i32* @DBL_MIN
%147 = shl nsw i32 %146, 1
%148 = sitofp i32 %147 to x86_fp80
store x86_fp80 %148, x86_fp80* %145
%149 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 5
%150 = load i32, i32* @DBL_MAX
%151 = sdiv i32 %150, 2
%152 = sitofp i32 %151 to x86_fp80
store x86_fp80 %152, x86_fp80* %149
%153 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 6
%154 = sitofp i32 %146 to x86_fp80
store x86_fp80 %154, x86_fp80* %153
%155 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 7
%156 = sitofp i32 %150 to x86_fp80
store x86_fp80 %156, x86_fp80* %155
%157 = bitcast x86_fp80* %9 to i8*
%158 = bitcast x86_fp80* %9 to i64*
br label %159
159: ; preds = %195, %139
%160 = phi x86_fp80 [ 0xKC00ADA2AAEE631F8A000, %139 ], [ %197, %195 ]
%161 = phi i64 [ 0, %139 ], [ %193, %195 ]
%162 = fptrunc x86_fp80 %160 to float
%163 = call i32 @pack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), float %162)
%164 = call i32 (i8*, i8*, ...) @unpack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), x86_fp80* %9)
%165 = load x86_fp80, x86_fp80* %9
%166 = fcmp une x86_fp80 %165, %160
br i1 %166, label %167, label %192
167: ; preds = %159
%168 = fptoui x86_fp80 %160 to i8
%169 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.23, i64 0, i64 0), i8 zeroext %168, x86_fp80 %165)
%170 = bitcast x86_fp80 %160 to i80
%171 = trunc i80 %170 to i8
%172 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), i8 zeroext %171)
%173 = load i64, i64* %158
%174 = trunc i64 %173 to i8
%175 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i8 zeroext %174)
%176 = load i8, i8* %13
%177 = load i8, i8* %32
%178 = zext i8 %177 to i32
%179 = load i8, i8* %33
%180 = zext i8 %179 to i32
%181 = load i8, i8* %34
%182 = zext i8 %181 to i32
%183 = load i8, i8* %35
%184 = zext i8 %183 to i32
%185 = load i8, i8* %36
%186 = zext i8 %185 to i32
%187 = load i8, i8* %37
%188 = zext i8 %187 to i32
%189 = load i8, i8* %38
%190 = zext i8 %189 to i32
%191 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %176, i32 %178, i32 %180, i32 %182, i32 %184, i32 %186, i32 %188, i32 %190)
br label %192
192: ; preds = %167, %159
%193 = add nuw nsw i64 %161, 1
%194 = icmp eq i64 %193, 8
br i1 %194, label %198, label %195
195: ; preds = %192
%196 = getelementptr inbounds [8 x x86_fp80], [8 x x86_fp80]* %8, i64 0, i64 %193
%197 = load x86_fp80, x86_fp80* %196
br label %159
198: ; preds = %192
%199 = bitcast [7 x double]* %10 to i8*
%200 = getelementptr inbounds [7 x double], [7 x double]* %10, i64 0, i64 1
%201 = bitcast double* %200 to <2 x double>*
store <2 x double> <double 1.000000e+00, double -1.000000e+00>, <2 x double>* %201
%202 = getelementptr inbounds [7 x double], [7 x double]* %10, i64 0, i64 3
%203 = bitcast double* %202 to <2 x double>*
store <2 x double> <double 1.000000e+01, double -3.667700e+00>, <2 x double>* %203
%204 = getelementptr inbounds [7 x double], [7 x double]* %10, i64 0, i64 5
%205 = bitcast double* %204 to <2 x double>*
store <2 x double> <double 3.187500e+00, double -3.187500e+00>, <2 x double>* %205
%206 = bitcast double* %11 to i8*
%207 = bitcast double* %11 to i64*
br label %208
208: ; preds = %198, %242
%209 = phi i64 [ 0, %198 ], [ %243, %242 ]
%210 = getelementptr inbounds [7 x double], [7 x double]* %10, i64 0, i64 %209
%211 = load double, double* %210
%212 = fptrunc double %211 to float
%213 = call i32 @pack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.24, i64 0, i64 0), float %212)
%214 = call i32 (i8*, i8*, ...) @unpack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.24, i64 0, i64 0), double* %11)
%215 = load double, double* %11
%216 = fcmp une double %215, %211
br i1 %216, label %217, label %242
217: ; preds = %208
%218 = fptoui double %211 to i8
%219 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.25, i64 0, i64 0), i8 zeroext %218, double %215)
%220 = bitcast double %211 to i64
%221 = trunc i64 %220 to i8
%222 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.9, i64 0, i64 0), i8 zeroext %221)
%223 = load i64, i64* %207
%224 = trunc i64 %223 to i8
%225 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i8 zeroext %224)
%226 = load i8, i8* %13
%227 = load i8, i8* %32
%228 = zext i8 %227 to i32
%229 = load i8, i8* %33
%230 = zext i8 %229 to i32
%231 = load i8, i8* %34
%232 = zext i8 %231 to i32
%233 = load i8, i8* %35
%234 = zext i8 %233 to i32
%235 = load i8, i8* %36
%236 = zext i8 %235 to i32
%237 = load i8, i8* %37
%238 = zext i8 %237 to i32
%239 = load i8, i8* %38
%240 = zext i8 %239 to i32
%241 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %226, i32 %228, i32 %230, i32 %232, i32 %234, i32 %236, i32 %238, i32 %240)
br label %242
242: ; preds = %217, %208
%243 = add nuw nsw i64 %209, 1
%244 = icmp eq i64 %243, 7
br i1 %244, label %245, label %208
245: ; preds = %242
%246 = bitcast float* %12 to i8*
%247 = bitcast float* %12 to i32*
br label %248
248: ; preds = %245, %282
%249 = phi i64 [ 0, %245 ], [ %283, %282 ]
%250 = getelementptr inbounds [7 x float], [7 x float]* @__const.main.testf16, i64 0, i64 %249
%251 = load float, float* %250
%252 = call i32 @pack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.26, i64 0, i64 0), float %251)
%253 = call i32 (i8*, i8*, ...) @unpack(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.26, i64 0, i64 0), float* %12)
%254 = load float, float* %12
%255 = fcmp une float %254, %251
br i1 %255, label %256, label %282
256: ; preds = %248
%257 = fptoui float %251 to i8
%258 = fpext float %254 to double
%259 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.27, i64 0, i64 0), i8 zeroext %257, double %258)
%260 = bitcast float %251 to i32
%261 = trunc i32 %260 to i8
%262 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0), i8 zeroext %261)
%263 = load i32, i32* %247
%264 = trunc i32 %263 to i8
%265 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.29, i64 0, i64 0), i8 zeroext %264)
%266 = load i8, i8* %13
%267 = load i8, i8* %32
%268 = zext i8 %267 to i32
%269 = load i8, i8* %33
%270 = zext i8 %269 to i32
%271 = load i8, i8* %34
%272 = zext i8 %271 to i32
%273 = load i8, i8* %35
%274 = zext i8 %273 to i32
%275 = load i8, i8* %36
%276 = zext i8 %275 to i32
%277 = load i8, i8* %37
%278 = zext i8 %277 to i32
%279 = load i8, i8* %38
%280 = zext i8 %279 to i32
%281 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.11, i64 0, i64 0), i8 zeroext %266, i32 %268, i32 %270, i32 %272, i32 %274, i32 %276, i32 %278, i32 %280)
br label %282
282: ; preds = %256, %248
%283 = add nuw nsw i64 %249, 1
%284 = icmp eq i64 %283, 7
br i1 %284, label %285, label %248
285: ; preds = %282
ret i32 0
}