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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ equal_double(double *, double *);
int /*<<< orphan*/ printf(char *, ...);
void main_double(void) {
  int mant_bits;
  int epsilon_bits = -1;
  int negepsilon_bits = -1;
  {
    double x = 1.0;
    double y;
    double z;
    for (y = 1.0;; y = 0.5 * y) {
      z = x + y;
      if (equal_double(&x, &z))
        break;
      z = z - x;
      if (!equal_double(&y, &z))
        break;
      epsilon_bits++;
    }
  }
  {
    double x = 1.0;
    double y;
    double z;
    for (y = -1.0;; y = 0.5 * y) {
      z = x + y;
      if (equal_double(&x, &z))
        break;
      z = z - x;
      if (!equal_double(&y, &z))
        break;
      negepsilon_bits++;
    }
  }
  printf("/* Properties of type `%s': */\n", "double");
  printf("/* Largest n for which 1+2^(-n) is exactly represented is %d. */\n",
         epsilon_bits);
  printf("/* Largest n for which 1-2^(-n) is exactly represented is %d. */\n",
         negepsilon_bits);
  if (negepsilon_bits <= epsilon_bits) {
    printf("#error \"No exponent jump at 1.0 for type %s!\"\n", "double");
    mant_bits = -1;
  } else {
    if (negepsilon_bits > epsilon_bits + 1)
      printf("/* Base for type `%s' is 2^%d\n", "double",
             negepsilon_bits - epsilon_bits);
    mant_bits = epsilon_bits + 1;
    printf("#define %s_mant_bits %d\n", "double", mant_bits);
  }
  {
    int i;
    double x, y1, y2, ys1, ys2, z1, z2, zs1, zs2;
    x = 1.0;
    for (i = 0; i < epsilon_bits; i++) {
      x = 0.5 * x;
    }
    y1 = 1.0 + 5.0 * x;
    y2 = 1.0 + 6.0 * x;
    ys1 = 1.0 + 5.4 * x;
    ys2 = 1.0 + 5.6 * x;
    z1 = -1.0 + (-5.0) * x;
    z2 = -1.0 + (-6.0) * x;
    zs1 = -1.0 + (-5.4) * x;
    zs2 = -1.0 + (-5.6) * x;
    if (equal_double(&ys1, &y1) && equal_double(&ys2, &y2) &&
        equal_double(&zs1, &z1) && equal_double(&zs2, &z2))
      printf("#define %s_rounds rounds_to_nearest\n", "double");
    else if (equal_double(&ys1, &y1) && equal_double(&ys2, &y1) &&
             equal_double(&zs1, &z1) && equal_double(&zs2, &z1))
      printf("#define %s_rounds rounds_to_zero\n", "double");
    else if (equal_double(&ys1, &y2) && equal_double(&ys2, &y2) &&
             equal_double(&zs1, &z1) && equal_double(&zs2, &z1))
      printf("#define %s_rounds rounds_to_infinity\n", "double");
    else if (equal_double(&ys1, &y1) && equal_double(&ys2, &y1) &&
             equal_double(&zs1, &z2) && equal_double(&zs2, &z2))
      printf("#define %s_rounds rounds_to_minus_infinity\n", "double");
    else
      printf("#error \"Unknown rounding mode for type %s!\"\n", "double");
  }
  printf("\n");
}


x86 assembly (clang, -O0):
<main_double>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0xffffffff,-0x8(%rbp)
movl   $0xffffffff,-0xc(%rbp)
movsd  0xebf(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xeb2(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
addsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
lea    -0x18(%rbp),%rdi
lea    -0x28(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     117e <main_double+0x5e>
jmp    11c9 <main_double+0xa9>
movsd  -0x28(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
lea    -0x20(%rbp),%rdi
lea    -0x28(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
jne    11a9 <main_double+0x89>
jmp    11c9 <main_double+0xa9>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
movsd  0xe4e(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
jmp    1153 <main_double+0x33>
movsd  0xe2f(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xe32(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x30(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
lea    -0x30(%rbp),%rdi
lea    -0x40(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     120e <main_double+0xee>
jmp    1259 <main_double+0x139>
movsd  -0x40(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
lea    -0x38(%rbp),%rdi
lea    -0x40(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
jne    1239 <main_double+0x119>
jmp    1259 <main_double+0x139>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
movsd  0xdbe(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    11e3 <main_double+0xc3>
lea    0xdf8(%rip),%rdi
lea    0xe11(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%esi
lea    0xe07(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%esi
lea    0xe38(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     12bd <main_double+0x19d>
lea    0xe60(%rip),%rdi
lea    0xdce(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    130a <main_double+0x1ea>
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    12e9 <main_double+0x1c9>
mov    -0xc(%rbp),%edx
sub    -0x8(%rbp),%edx
lea    0xe57(%rip),%rdi
lea    0xd96(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%edx
lea    0xe55(%rip),%rdi
lea    0xd75(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  0xcee(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    134a <main_double+0x22a>
movsd  0xcd6(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    131e <main_double+0x1fe>
movsd  -0x50(%rbp),%xmm0
movsd  0xcf9(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc9d(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xccf(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc7b(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xca5(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc59(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xc7b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc37(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xc51(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc25(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xc27(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc03(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  0xbfd(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xbe1(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  0xbd0(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xbbc(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
lea    -0x68(%rbp),%rdi
lea    -0x58(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     14dc <main_double+0x3bc>
lea    -0x70(%rbp),%rdi
lea    -0x60(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     14dc <main_double+0x3bc>
lea    -0x88(%rbp),%rdi
lea    -0x78(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     14dc <main_double+0x3bc>
lea    -0x90(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     14dc <main_double+0x3bc>
lea    0xca1(%rip),%rdi
lea    0xba8(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1674 <main_double+0x554>
lea    -0x68(%rbp),%rdi
lea    -0x58(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     1558 <main_double+0x438>
lea    -0x70(%rbp),%rdi
lea    -0x58(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     1558 <main_double+0x438>
lea    -0x88(%rbp),%rdi
lea    -0x78(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     1558 <main_double+0x438>
lea    -0x90(%rbp),%rdi
lea    -0x78(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     1558 <main_double+0x438>
lea    0xc4a(%rip),%rdi
lea    0xb2c(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    166f <main_double+0x54f>
lea    -0x68(%rbp),%rdi
lea    -0x60(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     15d4 <main_double+0x4b4>
lea    -0x70(%rbp),%rdi
lea    -0x60(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     15d4 <main_double+0x4b4>
lea    -0x88(%rbp),%rdi
lea    -0x78(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     15d4 <main_double+0x4b4>
lea    -0x90(%rbp),%rdi
lea    -0x78(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     15d4 <main_double+0x4b4>
lea    0xbf0(%rip),%rdi
lea    0xab0(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    166a <main_double+0x54a>
lea    -0x68(%rbp),%rdi
lea    -0x58(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     1650 <main_double+0x530>
lea    -0x70(%rbp),%rdi
lea    -0x58(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     1650 <main_double+0x530>
lea    -0x88(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     1650 <main_double+0x530>
lea    -0x90(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1040 <equal_double@plt>
cmp    $0x0,%rax
je     1650 <main_double+0x530>
lea    0xb9a(%rip),%rdi
lea    0xa34(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1665 <main_double+0x545>
lea    0xbac(%rip),%rdi
lea    0xa1a(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    166a <main_double+0x54a>
jmp    166f <main_double+0x54f>
jmp    1674 <main_double+0x554>
lea    0xab5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main_double>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
movabs $0x3ff0000000000000,%r13
mov    %r13,0x10(%rsp)
mov    %r13,0x18(%rsp)
movabs $0x4000000000000000,%rax
mov    %rax,0x8(%rsp)
lea    0x10(%rsp),%rdi
lea    0x8(%rsp),%rsi
call   1050 <equal_double@plt>
mov    $0xffffffff,%ebp
mov    $0xffffffff,%ebx
test   %rax,%rax
jne    11f5 <main_double+0xc5>
mov    $0xffffffff,%ebx
lea    0x18(%rsp),%r14
lea    0x8(%rsp),%r15
lea    0x10(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%rsp),%xmm0
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     11f5 <main_double+0xc5>
add    $0x1,%ebx
movsd  0x18(%rsp),%xmm0
mulsd  0xe2d(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r12,%rdi
mov    %r15,%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     11a0 <main_double+0x70>
mov    %r13,0x10(%rsp)
movabs $0xbff0000000000000,%rax
mov    %rax,0x18(%rsp)
movq   $0x0,0x8(%rsp)
lea    0x10(%rsp),%rdi
lea    0x8(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
jne    1295 <main_double+0x165>
mov    $0xffffffff,%ebp
lea    0x18(%rsp),%r14
lea    0x8(%rsp),%r15
lea    0x10(%rsp),%r12
nopw   0x0(%rax,%rax,1)
movsd  0x8(%rsp),%xmm0
subsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     1295 <main_double+0x165>
add    $0x1,%ebp
movsd  0x18(%rsp),%xmm0
mulsd  0xd8d(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r12,%rdi
mov    %r15,%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     1240 <main_double+0x110>
lea    0xdbc(%rip),%rdi
lea    0xdd5(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xdce(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe00(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %ebp,%edx
sub    %ebx,%edx
jle    1308 <main_double+0x1d8>
lea    0x1(%rbx),%r14d
cmp    %r14d,%ebp
jle    12ee <main_double+0x1be>
lea    0xe52(%rip),%rdi
lea    0xd91(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe5c(%rip),%rdi
lea    0xd7c(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
jmp    131d <main_double+0x1ed>
lea    0xdf4(%rip),%rdi
lea    0xd62(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
movsd  0xce3(%rip),%xmm1
movapd %xmm1,%xmm0
test   %ebx,%ebx
jle    13a9 <main_double+0x279>
lea    -0x1(%rbx),%ecx
mov    %ebx,%eax
and    $0x7,%eax
cmp    $0x7,%ecx
jae    1344 <main_double+0x214>
movsd  0xcc6(%rip),%xmm0
jmp    1385 <main_double+0x255>
and    $0xfffffff8,%ebx
movsd  0xcb9(%rip),%xmm0
movsd  0xca9(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
add    $0xfffffff8,%ebx
jne    1360 <main_double+0x230>
test   %eax,%eax
je     13a9 <main_double+0x279>
movsd  0xc6f(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  %xmm2,%xmm0
add    $0xffffffff,%eax
jne    13a0 <main_double+0x270>
movsd  0xc5f(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsp)
movsd  0xc51(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x18(%rsp)
movsd  0xc43(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0xc35(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x38(%rsp)
movsd  0xc27(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xc23(%rip),%xmm2
addsd  %xmm2,%xmm1
movsd  %xmm1,0x20(%rsp)
movsd  0xc19(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x40(%rsp)
movsd  0xc0b(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x30(%rsp)
mulsd  0xbfd(%rip),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x28(%rsp)
lea    0x8(%rsp),%rdi
lea    0x10(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     14b9 <main_double+0x389>
lea    0x38(%rsp),%rdi
lea    0x18(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     14b9 <main_double+0x389>
lea    0x30(%rsp),%rdi
lea    0x20(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     14b9 <main_double+0x389>
lea    0x28(%rsp),%rdi
lea    0x40(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     14b9 <main_double+0x389>
lea    0xcb6(%rip),%rdi
jmp    15ce <main_double+0x49e>
lea    0x8(%rsp),%rdi
lea    0x10(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     1515 <main_double+0x3e5>
lea    0x38(%rsp),%rdi
lea    0x10(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     1515 <main_double+0x3e5>
lea    0x30(%rsp),%rdi
lea    0x20(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     1515 <main_double+0x3e5>
lea    0x28(%rsp),%rdi
lea    0x20(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     1515 <main_double+0x3e5>
lea    0xc7f(%rip),%rdi
jmp    15ce <main_double+0x49e>
lea    0x8(%rsp),%rdi
lea    0x18(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     156e <main_double+0x43e>
lea    0x38(%rsp),%rdi
lea    0x18(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     156e <main_double+0x43e>
lea    0x30(%rsp),%rdi
lea    0x20(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     156e <main_double+0x43e>
lea    0x28(%rsp),%rdi
lea    0x20(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     156e <main_double+0x43e>
lea    0xc45(%rip),%rdi
jmp    15ce <main_double+0x49e>
lea    0x8(%rsp),%rdi
lea    0x10(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     15c7 <main_double+0x497>
lea    0x38(%rsp),%rdi
lea    0x10(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     15c7 <main_double+0x497>
lea    0x30(%rsp),%rdi
lea    0x40(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     15c7 <main_double+0x497>
lea    0x28(%rsp),%rdi
lea    0x40(%rsp),%rsi
call   1050 <equal_double@plt>
test   %rax,%rax
je     15c7 <main_double+0x497>
lea    0xc12(%rip),%rdi
jmp    15ce <main_double+0x49e>
lea    0xc35(%rip),%rdi
lea    0xaa3(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [32 x i8] c"/* Properties of type `%s': */\0A\00"
@.str.1 = [7 x i8] c"double\00"
@.str.2 = [66 x i8] c"/* Largest n for which 1+2^(-n) is exactly represented is %d. */\0A\00"
@.str.3 = [66 x i8] c"/* Largest n for which 1-2^(-n) is exactly represented is %d. */\0A\00"
@.str.4 = [47 x i8] c"#error \22No exponent jump at 1.0 for type %s!\22\0A\00"
@.str.5 = [31 x i8] c"/* Base for type `%s' is 2^%d\0A\00"
@.str.6 = [25 x i8] c"#define %s_mant_bits %d\0A\00"
@.str.7 = [37 x i8] c"#define %s_rounds rounds_to_nearest\0A\00"
@.str.8 = [34 x i8] c"#define %s_rounds rounds_to_zero\0A\00"
@.str.9 = [38 x i8] c"#define %s_rounds rounds_to_infinity\0A\00"
@.str.10 = [44 x i8] c"#define %s_rounds rounds_to_minus_infinity\0A\00"
@.str.11 = [45 x i8] c"#error \22Unknown rounding mode for type %s!\22\0A\00"
@.str.12 = [2 x i8] c"\0A\00"
define void @main_double() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca i32
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
store i32 -1, i32* %2
store i32 -1, i32* %3
store double 1.000000e+00, double* %4
store double 1.000000e+00, double* %5
br label %20
20: ; preds = %37, %0
%21 = load double, double* %4
%22 = load double, double* %5
%23 = fadd double %21, %22
store double %23, double* %6
%24 = call i64 @equal_double(double* %4, double* %6)
%25 = icmp ne i64 %24, 0
br i1 %25, label %26, label %27
26: ; preds = %20
br label %40
27: ; preds = %20
%28 = load double, double* %6
%29 = load double, double* %4
%30 = fsub double %28, %29
store double %30, double* %6
%31 = call i64 @equal_double(double* %5, double* %6)
%32 = icmp ne i64 %31, 0
br i1 %32, label %34, label %33
33: ; preds = %27
br label %40
34: ; preds = %27
%35 = load i32, i32* %2
%36 = add nsw i32 %35, 1
store i32 %36, i32* %2
br label %37
37: ; preds = %34
%38 = load double, double* %5
%39 = fmul double 5.000000e-01, %38
store double %39, double* %5
br label %20
40: ; preds = %33, %26
store double 1.000000e+00, double* %7
store double -1.000000e+00, double* %8
br label %41
41: ; preds = %58, %40
%42 = load double, double* %7
%43 = load double, double* %8
%44 = fadd double %42, %43
store double %44, double* %9
%45 = call i64 @equal_double(double* %7, double* %9)
%46 = icmp ne i64 %45, 0
br i1 %46, label %47, label %48
47: ; preds = %41
br label %61
48: ; preds = %41
%49 = load double, double* %9
%50 = load double, double* %7
%51 = fsub double %49, %50
store double %51, double* %9
%52 = call i64 @equal_double(double* %8, double* %9)
%53 = icmp ne i64 %52, 0
br i1 %53, label %55, label %54
54: ; preds = %48
br label %61
55: ; preds = %48
%56 = load i32, i32* %3
%57 = add nsw i32 %56, 1
store i32 %57, i32* %3
br label %58
58: ; preds = %55
%59 = load double, double* %8
%60 = fmul double 5.000000e-01, %59
store double %60, double* %8
br label %41
61: ; preds = %54, %47
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%63 = load i32, i32* %2
%64 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.2, i64 0, i64 0), i32 %63)
%65 = load i32, i32* %3
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.3, i64 0, i64 0), i32 %65)
%67 = load i32, i32* %3
%68 = load i32, i32* %2
%69 = icmp sle i32 %67, %68
br i1 %69, label %70, label %72
70: ; preds = %61
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
store i32 -1, i32* %1
br label %87
72: ; preds = %61
%73 = load i32, i32* %3
%74 = load i32, i32* %2
%75 = add nsw i32 %74, 1
%76 = icmp sgt i32 %73, %75
br i1 %76, label %77, label %82
77: ; preds = %72
%78 = load i32, i32* %3
%79 = load i32, i32* %2
%80 = sub nsw i32 %78, %79
%81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %80)
br label %82
82: ; preds = %77, %72
%83 = load i32, i32* %2
%84 = add nsw i32 %83, 1
store i32 %84, i32* %1
%85 = load i32, i32* %1
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %85)
br label %87
87: ; preds = %82, %70
store double 1.000000e+00, double* %11
store i32 0, i32* %10
br label %88
88: ; preds = %95, %87
%89 = load i32, i32* %10
%90 = load i32, i32* %2
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %98
92: ; preds = %88
%93 = load double, double* %11
%94 = fmul double 5.000000e-01, %93
store double %94, double* %11
br label %95
95: ; preds = %92
%96 = load i32, i32* %10
%97 = add nsw i32 %96, 1
store i32 %97, i32* %10
br label %88
98: ; preds = %88
%99 = load double, double* %11
%100 = call double @llvm.fmuladd.f64(double 5.000000e+00, double %99, double 1.000000e+00)
store double %100, double* %12
%101 = load double, double* %11
%102 = call double @llvm.fmuladd.f64(double 6.000000e+00, double %101, double 1.000000e+00)
store double %102, double* %13
%103 = load double, double* %11
%104 = call double @llvm.fmuladd.f64(double 5.400000e+00, double %103, double 1.000000e+00)
store double %104, double* %14
%105 = load double, double* %11
%106 = call double @llvm.fmuladd.f64(double 5.600000e+00, double %105, double 1.000000e+00)
store double %106, double* %15
%107 = load double, double* %11
%108 = call double @llvm.fmuladd.f64(double -5.000000e+00, double %107, double -1.000000e+00)
store double %108, double* %16
%109 = load double, double* %11
%110 = call double @llvm.fmuladd.f64(double -6.000000e+00, double %109, double -1.000000e+00)
store double %110, double* %17
%111 = load double, double* %11
%112 = call double @llvm.fmuladd.f64(double -5.400000e+00, double %111, double -1.000000e+00)
store double %112, double* %18
%113 = load double, double* %11
%114 = call double @llvm.fmuladd.f64(double -5.600000e+00, double %113, double -1.000000e+00)
store double %114, double* %19
%115 = call i64 @equal_double(double* %14, double* %12)
%116 = icmp ne i64 %115, 0
br i1 %116, label %117, label %128
117: ; preds = %98
%118 = call i64 @equal_double(double* %15, double* %13)
%119 = icmp ne i64 %118, 0
br i1 %119, label %120, label %128
120: ; preds = %117
%121 = call i64 @equal_double(double* %18, double* %16)
%122 = icmp ne i64 %121, 0
br i1 %122, label %123, label %128
123: ; preds = %120
%124 = call i64 @equal_double(double* %19, double* %17)
%125 = icmp ne i64 %124, 0
br i1 %125, label %126, label %128
126: ; preds = %123
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
br label %175
128: ; preds = %123, %120, %117, %98
%129 = call i64 @equal_double(double* %14, double* %12)
%130 = icmp ne i64 %129, 0
br i1 %130, label %131, label %142
131: ; preds = %128
%132 = call i64 @equal_double(double* %15, double* %12)
%133 = icmp ne i64 %132, 0
br i1 %133, label %134, label %142
134: ; preds = %131
%135 = call i64 @equal_double(double* %18, double* %16)
%136 = icmp ne i64 %135, 0
br i1 %136, label %137, label %142
137: ; preds = %134
%138 = call i64 @equal_double(double* %19, double* %16)
%139 = icmp ne i64 %138, 0
br i1 %139, label %140, label %142
140: ; preds = %137
%141 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
br label %174
142: ; preds = %137, %134, %131, %128
%143 = call i64 @equal_double(double* %14, double* %13)
%144 = icmp ne i64 %143, 0
br i1 %144, label %145, label %156
145: ; preds = %142
%146 = call i64 @equal_double(double* %15, double* %13)
%147 = icmp ne i64 %146, 0
br i1 %147, label %148, label %156
148: ; preds = %145
%149 = call i64 @equal_double(double* %18, double* %16)
%150 = icmp ne i64 %149, 0
br i1 %150, label %151, label %156
151: ; preds = %148
%152 = call i64 @equal_double(double* %19, double* %16)
%153 = icmp ne i64 %152, 0
br i1 %153, label %154, label %156
154: ; preds = %151
%155 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
br label %173
156: ; preds = %151, %148, %145, %142
%157 = call i64 @equal_double(double* %14, double* %12)
%158 = icmp ne i64 %157, 0
br i1 %158, label %159, label %170
159: ; preds = %156
%160 = call i64 @equal_double(double* %15, double* %12)
%161 = icmp ne i64 %160, 0
br i1 %161, label %162, label %170
162: ; preds = %159
%163 = call i64 @equal_double(double* %18, double* %17)
%164 = icmp ne i64 %163, 0
br i1 %164, label %165, label %170
165: ; preds = %162
%166 = call i64 @equal_double(double* %19, double* %17)
%167 = icmp ne i64 %166, 0
br i1 %167, label %168, label %170
168: ; preds = %165
%169 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
br label %172
170: ; preds = %165, %162, %159, %156
%171 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
br label %172
172: ; preds = %170, %168
br label %173
173: ; preds = %172, %154
br label %174
174: ; preds = %173, %140
br label %175
175: ; preds = %174, %126
%176 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.12, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [32 x i8] c"/* Properties of type `%s': */\0A\00"
@.str.1 = [7 x i8] c"double\00"
@.str.2 = [66 x i8] c"/* Largest n for which 1+2^(-n) is exactly represented is %d. */\0A\00"
@.str.3 = [66 x i8] c"/* Largest n for which 1-2^(-n) is exactly represented is %d. */\0A\00"
@.str.4 = [47 x i8] c"#error \22No exponent jump at 1.0 for type %s!\22\0A\00"
@.str.5 = [31 x i8] c"/* Base for type `%s' is 2^%d\0A\00"
@.str.6 = [25 x i8] c"#define %s_mant_bits %d\0A\00"
@.str.7 = [37 x i8] c"#define %s_rounds rounds_to_nearest\0A\00"
@.str.8 = [34 x i8] c"#define %s_rounds rounds_to_zero\0A\00"
@.str.9 = [38 x i8] c"#define %s_rounds rounds_to_infinity\0A\00"
@.str.10 = [44 x i8] c"#define %s_rounds rounds_to_minus_infinity\0A\00"
@.str.11 = [45 x i8] c"#error \22Unknown rounding mode for type %s!\22\0A\00"
define void @main_double() {
%1 = alloca double
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = bitcast double* %1 to i8*
store double 1.000000e+00, double* %1
%16 = bitcast double* %2 to i8*
%17 = bitcast double* %3 to i8*
store double 1.000000e+00, double* %2
store double 2.000000e+00, double* %3
%18 = call i64 @equal_double(double* %1, double* %3)
%19 = icmp eq i64 %18, 0
br i1 %19, label %20, label %35
20: ; preds = %0, %27
%21 = phi i32 [ %28, %27 ], [ -1, %0 ]
%22 = load double, double* %3
%23 = load double, double* %1
%24 = fsub double %22, %23
store double %24, double* %3
%25 = call i64 @equal_double(double* %2, double* %3)
%26 = icmp eq i64 %25, 0
br i1 %26, label %35, label %27
27: ; preds = %20
%28 = add nsw i32 %21, 1
%29 = load double, double* %2
%30 = fmul double %29, 5.000000e-01
store double %30, double* %2
%31 = load double, double* %1
%32 = fadd double %30, %31
store double %32, double* %3
%33 = call i64 @equal_double(double* %1, double* %3)
%34 = icmp eq i64 %33, 0
br i1 %34, label %20, label %35
35: ; preds = %27, %20, %0
%36 = phi i32 [ -1, %0 ], [ %21, %20 ], [ %28, %27 ]
%37 = bitcast double* %4 to i8*
store double 1.000000e+00, double* %4
%38 = bitcast double* %5 to i8*
%39 = bitcast double* %6 to i8*
store double -1.000000e+00, double* %5
store double 0.000000e+00, double* %6
%40 = call i64 @equal_double(double* %4, double* %6)
%41 = icmp eq i64 %40, 0
br i1 %41, label %42, label %57
42: ; preds = %35, %49
%43 = phi i32 [ %50, %49 ], [ -1, %35 ]
%44 = load double, double* %6
%45 = load double, double* %4
%46 = fsub double %44, %45
store double %46, double* %6
%47 = call i64 @equal_double(double* %5, double* %6)
%48 = icmp eq i64 %47, 0
br i1 %48, label %57, label %49
49: ; preds = %42
%50 = add nsw i32 %43, 1
%51 = load double, double* %5
%52 = fmul double %51, 5.000000e-01
store double %52, double* %5
%53 = load double, double* %4
%54 = fadd double %52, %53
store double %54, double* %6
%55 = call i64 @equal_double(double* %4, double* %6)
%56 = icmp eq i64 %55, 0
br i1 %56, label %42, label %57
57: ; preds = %49, %42, %35
%58 = phi i32 [ -1, %35 ], [ %43, %42 ], [ %50, %49 ]
%59 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%60 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.2, i64 0, i64 0), i32 %36)
%61 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.3, i64 0, i64 0), i32 %58)
%62 = icmp sgt i32 %58, %36
br i1 %62, label %65, label %63
63: ; preds = %57
%64 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
br label %73
65: ; preds = %57
%66 = add nsw i32 %36, 1
%67 = icmp sgt i32 %58, %66
br i1 %67, label %68, label %71
68: ; preds = %65
%69 = sub nsw i32 %58, %36
%70 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %69)
br label %71
71: ; preds = %68, %65
%72 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %66)
br label %73
73: ; preds = %71, %63
%74 = bitcast double* %7 to i8*
%75 = bitcast double* %8 to i8*
%76 = bitcast double* %9 to i8*
%77 = bitcast double* %10 to i8*
%78 = bitcast double* %11 to i8*
%79 = bitcast double* %12 to i8*
%80 = bitcast double* %13 to i8*
%81 = bitcast double* %14 to i8*
%82 = icmp sgt i32 %36, 0
br i1 %82, label %83, label %112
83: ; preds = %73
%84 = add i32 %36, -1
%85 = and i32 %36, 7
%86 = icmp ult i32 %84, 7
br i1 %86, label %102, label %87
87: ; preds = %83
%88 = and i32 %36, -8
br label %89
89: ; preds = %89, %87
%90 = phi double [ 1.000000e+00, %87 ], [ %99, %89 ]
%91 = phi i32 [ 0, %87 ], [ %100, %89 ]
%92 = fmul double %90, 5.000000e-01
%93 = fmul double %92, 5.000000e-01
%94 = fmul double %93, 5.000000e-01
%95 = fmul double %94, 5.000000e-01
%96 = fmul double %95, 5.000000e-01
%97 = fmul double %96, 5.000000e-01
%98 = fmul double %97, 5.000000e-01
%99 = fmul double %98, 5.000000e-01
%100 = add i32 %91, 8
%101 = icmp eq i32 %100, %88
br i1 %101, label %102, label %89
102: ; preds = %89, %83
%103 = phi double [ undef, %83 ], [ %99, %89 ]
%104 = phi double [ 1.000000e+00, %83 ], [ %99, %89 ]
%105 = icmp eq i32 %85, 0
br i1 %105, label %112, label %106
106: ; preds = %102, %106
%107 = phi double [ %109, %106 ], [ %104, %102 ]
%108 = phi i32 [ %110, %106 ], [ 0, %102 ]
%109 = fmul double %107, 5.000000e-01
%110 = add i32 %108, 1
%111 = icmp eq i32 %110, %85
br i1 %111, label %112, label %106
112: ; preds = %102, %106, %73
%113 = phi double [ 1.000000e+00, %73 ], [ %103, %102 ], [ %109, %106 ]
%114 = call double @llvm.fmuladd.f64(double %113, double 5.000000e+00, double 1.000000e+00)
store double %114, double* %7
%115 = call double @llvm.fmuladd.f64(double %113, double 6.000000e+00, double 1.000000e+00)
store double %115, double* %8
%116 = call double @llvm.fmuladd.f64(double %113, double 5.400000e+00, double 1.000000e+00)
store double %116, double* %9
%117 = call double @llvm.fmuladd.f64(double %113, double 5.600000e+00, double 1.000000e+00)
store double %117, double* %10
%118 = call double @llvm.fmuladd.f64(double %113, double -5.000000e+00, double -1.000000e+00)
store double %118, double* %11
%119 = call double @llvm.fmuladd.f64(double %113, double -6.000000e+00, double -1.000000e+00)
store double %119, double* %12
%120 = call double @llvm.fmuladd.f64(double %113, double -5.400000e+00, double -1.000000e+00)
store double %120, double* %13
%121 = call double @llvm.fmuladd.f64(double %113, double -5.600000e+00, double -1.000000e+00)
store double %121, double* %14
%122 = call i64 @equal_double(double* %9, double* %7)
%123 = icmp eq i64 %122, 0
br i1 %123, label %133, label %124
124: ; preds = %112
%125 = call i64 @equal_double(double* %10, double* %8)
%126 = icmp eq i64 %125, 0
br i1 %126, label %133, label %127
127: ; preds = %124
%128 = call i64 @equal_double(double* %13, double* %11)
%129 = icmp eq i64 %128, 0
br i1 %129, label %133, label %130
130: ; preds = %127
%131 = call i64 @equal_double(double* %14, double* %12)
%132 = icmp eq i64 %131, 0
br i1 %132, label %133, label %170
133: ; preds = %130, %127, %124, %112
%134 = call i64 @equal_double(double* %9, double* %7)
%135 = icmp eq i64 %134, 0
br i1 %135, label %145, label %136
136: ; preds = %133
%137 = call i64 @equal_double(double* %10, double* %7)
%138 = icmp eq i64 %137, 0
br i1 %138, label %145, label %139
139: ; preds = %136
%140 = call i64 @equal_double(double* %13, double* %11)
%141 = icmp eq i64 %140, 0
br i1 %141, label %145, label %142
142: ; preds = %139
%143 = call i64 @equal_double(double* %14, double* %11)
%144 = icmp eq i64 %143, 0
br i1 %144, label %145, label %170
145: ; preds = %142, %139, %136, %133
%146 = call i64 @equal_double(double* %9, double* %8)
%147 = icmp eq i64 %146, 0
br i1 %147, label %157, label %148
148: ; preds = %145
%149 = call i64 @equal_double(double* %10, double* %8)
%150 = icmp eq i64 %149, 0
br i1 %150, label %157, label %151
151: ; preds = %148
%152 = call i64 @equal_double(double* %13, double* %11)
%153 = icmp eq i64 %152, 0
br i1 %153, label %157, label %154
154: ; preds = %151
%155 = call i64 @equal_double(double* %14, double* %11)
%156 = icmp eq i64 %155, 0
br i1 %156, label %157, label %170
157: ; preds = %154, %151, %148, %145
%158 = call i64 @equal_double(double* %9, double* %7)
%159 = icmp eq i64 %158, 0
br i1 %159, label %169, label %160
160: ; preds = %157
%161 = call i64 @equal_double(double* %10, double* %7)
%162 = icmp eq i64 %161, 0
br i1 %162, label %169, label %163
163: ; preds = %160
%164 = call i64 @equal_double(double* %13, double* %12)
%165 = icmp eq i64 %164, 0
br i1 %165, label %169, label %166
166: ; preds = %163
%167 = call i64 @equal_double(double* %14, double* %12)
%168 = icmp eq i64 %167, 0
br i1 %168, label %169, label %170
169: ; preds = %166, %163, %160, %157
br label %170
170: ; preds = %166, %154, %142, %130, %169
%171 = phi i8* [ getelementptr inbounds ([45 x i8], [45 x i8]* @.str.11, i64 0, i64 0), %169 ], [ getelementptr inbounds ([37 x i8], [37 x i8]* @.str.7, i64 0, i64 0), %130 ], [ getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), %142 ], [ getelementptr inbounds ([38 x i8], [38 x i8]* @.str.9, i64 0, i64 0), %154 ], [ getelementptr inbounds ([44 x i8], [44 x i8]* @.str.10, i64 0, i64 0), %166 ]
%172 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) %171, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0))
%173 = call i32 @putchar(i32 10)
ret void
}