#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_float(float *, float *);
int /*<<< orphan*/ printf(char *, ...);
void main_float(void) {
  int mant_bits;
  int epsilon_bits = -1;
  int negepsilon_bits = -1;
  {
    float x = 1.0;
    float y;
    float z;
    for (y = 1.0;; y = 0.5 * y) {
      z = x + y;
      if (equal_float(&x, &z))
        break;
      z = z - x;
      if (!equal_float(&y, &z))
        break;
      epsilon_bits++;
    }
  }
  {
    float x = 1.0;
    float y;
    float z;
    for (y = -1.0;; y = 0.5 * y) {
      z = x + y;
      if (equal_float(&x, &z))
        break;
      z = z - x;
      if (!equal_float(&y, &z))
        break;
      negepsilon_bits++;
    }
  }
  printf("/* Properties of type `%s': */\n", "float");
  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", "float");
    mant_bits = -1;
  } else {
    if (negepsilon_bits > epsilon_bits + 1)
      printf("/* Base for type `%s' is 2^%d\n", "float",
             negepsilon_bits - epsilon_bits);
    mant_bits = epsilon_bits + 1;
    printf("#define %s_mant_bits %d\n", "float", mant_bits);
  }
  {
    int i;
    float 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_float(&ys1, &y1) && equal_float(&ys2, &y2) &&
        equal_float(&zs1, &z1) && equal_float(&zs2, &z2))
      printf("#define %s_rounds rounds_to_nearest\n", "float");
    else if (equal_float(&ys1, &y1) && equal_float(&ys2, &y1) &&
             equal_float(&zs1, &z1) && equal_float(&zs2, &z1))
      printf("#define %s_rounds rounds_to_zero\n", "float");
    else if (equal_float(&ys1, &y2) && equal_float(&ys2, &y2) &&
             equal_float(&zs1, &z1) && equal_float(&zs2, &z1))
      printf("#define %s_rounds rounds_to_infinity\n", "float");
    else if (equal_float(&ys1, &y1) && equal_float(&ys2, &y1) &&
             equal_float(&zs1, &z2) && equal_float(&zs2, &z2))
      printf("#define %s_rounds rounds_to_minus_infinity\n", "float");
    else
      printf("#error \"Unknown rounding mode for type %s!\"\n", "float");
  }
  printf("\n");
}


x86 assembly (clang, -O0):
<main_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0xffffffff,-0x8(%rbp)
movl   $0xffffffff,-0xc(%rbp)
movss  0xec2(%rip),%xmm0
movss  %xmm0,-0x10(%rbp)
movss  0xeb5(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x10(%rbp),%xmm0
addss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
lea    -0x10(%rbp),%rdi
lea    -0x18(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     117b <main_float+0x5b>
jmp    11d2 <main_float+0xb2>
movss  -0x18(%rbp),%xmm0
subss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
lea    -0x14(%rbp),%rdi
lea    -0x18(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
jne    11a6 <main_float+0x86>
jmp    11d2 <main_float+0xb2>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe48(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
jmp    1150 <main_float+0x30>
movss  0xe26(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  0xe1d(%rip),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x1c(%rbp),%xmm0
addss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
lea    -0x1c(%rbp),%rdi
lea    -0x24(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1217 <main_float+0xf7>
jmp    126e <main_float+0x14e>
movss  -0x24(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
lea    -0x20(%rbp),%rdi
lea    -0x24(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
jne    1242 <main_float+0x122>
jmp    126e <main_float+0x14e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
movss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdac(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x20(%rbp)
jmp    11ec <main_float+0xcc>
lea    0xdeb(%rip),%rdi
lea    0xe04(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%esi
lea    0xdf9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%esi
lea    0xe2a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     12d2 <main_float+0x1b2>
lea    0xe52(%rip),%rdi
lea    0xdc1(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    131f <main_float+0x1ff>
mov    -0xc(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    12fe <main_float+0x1de>
mov    -0xc(%rbp),%edx
sub    -0x8(%rbp),%edx
lea    0xe49(%rip),%rdi
lea    0xd89(%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    0xe47(%rip),%rdi
lea    0xd68(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
movss  0xcd9(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    136b <main_float+0x24b>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcb8(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1333 <main_float+0x213>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcdc(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xcb8(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcaa(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc8e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc78(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc64(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc3e(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc3a(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc0c(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xbe8(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbda(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xbbe(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xba8(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xb94(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb6e(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xb6a(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
lea    -0x38(%rbp),%rdi
lea    -0x30(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1531 <main_float+0x411>
lea    -0x3c(%rbp),%rdi
lea    -0x34(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1531 <main_float+0x411>
lea    -0x48(%rbp),%rdi
lea    -0x40(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1531 <main_float+0x411>
lea    -0x4c(%rbp),%rdi
lea    -0x44(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1531 <main_float+0x411>
lea    0xc53(%rip),%rdi
lea    0xb5b(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    16b7 <main_float+0x597>
lea    -0x38(%rbp),%rdi
lea    -0x30(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     15a7 <main_float+0x487>
lea    -0x3c(%rbp),%rdi
lea    -0x30(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     15a7 <main_float+0x487>
lea    -0x48(%rbp),%rdi
lea    -0x40(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     15a7 <main_float+0x487>
lea    -0x4c(%rbp),%rdi
lea    -0x40(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     15a7 <main_float+0x487>
lea    0xc02(%rip),%rdi
lea    0xae5(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    16b2 <main_float+0x592>
lea    -0x38(%rbp),%rdi
lea    -0x34(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     161d <main_float+0x4fd>
lea    -0x3c(%rbp),%rdi
lea    -0x34(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     161d <main_float+0x4fd>
lea    -0x48(%rbp),%rdi
lea    -0x40(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     161d <main_float+0x4fd>
lea    -0x4c(%rbp),%rdi
lea    -0x40(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     161d <main_float+0x4fd>
lea    0xbae(%rip),%rdi
lea    0xa6f(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    16ad <main_float+0x58d>
lea    -0x38(%rbp),%rdi
lea    -0x30(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1693 <main_float+0x573>
lea    -0x3c(%rbp),%rdi
lea    -0x30(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1693 <main_float+0x573>
lea    -0x48(%rbp),%rdi
lea    -0x44(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1693 <main_float+0x573>
lea    -0x4c(%rbp),%rdi
lea    -0x44(%rbp),%rsi
call   1040 <equal_float@plt>
cmp    $0x0,%rax
je     1693 <main_float+0x573>
lea    0xb5e(%rip),%rdi
lea    0x9f9(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    16a8 <main_float+0x588>
lea    0xb70(%rip),%rdi
lea    0x9df(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    16ad <main_float+0x58d>
jmp    16b2 <main_float+0x592>
jmp    16b7 <main_float+0x597>
lea    0xa79(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main_float>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x20,%rsp
movl   $0x3f800000,0x4(%rsp)
3f
movl   $0x3f800000,0x8(%rsp)
3f
movl   $0x40000000,(%rsp)
lea    0x4(%rsp),%rdi
mov    %rsp,%rsi
call   1050 <equal_float@plt>
mov    $0xffffffff,%ebp
mov    $0xffffffff,%ebx
test   %rax,%rax
jne    11e2 <main_float+0xb2>
mov    $0xffffffff,%ebx
lea    0x8(%rsp),%r14
mov    %rsp,%r15
lea    0x4(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rsp),%xmm0
subss  0x4(%rsp),%xmm0
movss  %xmm0,(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     11e2 <main_float+0xb2>
add    $0x1,%ebx
movss  0x8(%rsp),%xmm0
mulss  0xe3f(%rip),%xmm0
movss  %xmm0,0x8(%rsp)
addss  0x4(%rsp),%xmm0
movss  %xmm0,(%rsp)
mov    %r12,%rdi
mov    %r15,%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     1190 <main_float+0x60>
movl   $0x3f800000,0x4(%rsp)
3f
movl   $0xbf800000,0x8(%rsp)
bf
movl   $0x0,(%rsp)
lea    0x4(%rsp),%rdi
mov    %rsp,%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
jne    1272 <main_float+0x142>
mov    $0xffffffff,%ebp
lea    0x8(%rsp),%r14
mov    %rsp,%r15
lea    0x4(%rsp),%r12
nopl   (%rax)
movss  (%rsp),%xmm0
subss  0x4(%rsp),%xmm0
movss  %xmm0,(%rsp)
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     1272 <main_float+0x142>
add    $0x1,%ebp
movss  0x8(%rsp),%xmm0
mulss  0xdaf(%rip),%xmm0
movss  %xmm0,0x8(%rsp)
addss  0x4(%rsp),%xmm0
movss  %xmm0,(%rsp)
mov    %r12,%rdi
mov    %r15,%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     1220 <main_float+0xf0>
lea    0xde7(%rip),%rdi
lea    0xe00(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xdf8(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe2a(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %ebp,%edx
sub    %ebx,%edx
jle    12e5 <main_float+0x1b5>
lea    0x1(%rbx),%r14d
cmp    %r14d,%ebp
jle    12cb <main_float+0x19b>
lea    0xe7c(%rip),%rdi
lea    0xdbc(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe86(%rip),%rdi
lea    0xda7(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
jmp    12fa <main_float+0x1ca>
lea    0xe1e(%rip),%rdi
lea    0xd8d(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
movsd  0xd06(%rip),%xmm1
movapd %xmm1,%xmm0
test   %ebx,%ebx
jle    1381 <main_float+0x251>
lea    -0x1(%rbx),%ecx
mov    %ebx,%eax
and    $0x3,%eax
cmp    $0x3,%ecx
jae    1321 <main_float+0x1f1>
movsd  0xce9(%rip),%xmm0
jmp    135d <main_float+0x22d>
and    $0xfffffffc,%ebx
movsd  0xcdc(%rip),%xmm0
movsd  0xcdc(%rip),%xmm2
movss  0xcc4(%rip),%xmm3
nopl   0x0(%rax)
mulsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm3,%xmm0
cvtss2sd %xmm0,%xmm0
add    $0xfffffffc,%ebx
jne    1340 <main_float+0x210>
test   %eax,%eax
je     1381 <main_float+0x251>
movsd  0xca7(%rip),%xmm2
nopl   0x0(%rax)
mulsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
add    $0xffffffff,%eax
jne    1370 <main_float+0x240>
movsd  0xc8f(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x4(%rsp)
movsd  0xc7d(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x8(%rsp)
movsd  0xc6b(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%rsp)
movsd  0xc5a(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movsd  0xc4b(%rip),%xmm2
mulsd  %xmm0,%xmm2
movsd  0xc47(%rip),%xmm3
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm1,0x18(%rsp)
movss  %xmm2,0xc(%rsp)
movsd  0xc33(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm3,%xmm1
cvtsd2ss %xmm1,%xmm1
movsd  0xc27(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm1,0x1c(%rsp)
movss  %xmm2,0x14(%rsp)
mulsd  0xc0f(%rip),%xmm0
addsd  %xmm3,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
mov    %rsp,%rdi
lea    0x4(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     14b1 <main_float+0x381>
lea    0x18(%rsp),%rdi
lea    0x8(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     14b1 <main_float+0x381>
lea    0x14(%rsp),%rdi
lea    0xc(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     14b1 <main_float+0x381>
lea    0x10(%rsp),%rdi
lea    0x1c(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     14b1 <main_float+0x381>
lea    0xcc5(%rip),%rdi
jmp    15c0 <main_float+0x490>
mov    %rsp,%rdi
lea    0x4(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     150b <main_float+0x3db>
lea    0x18(%rsp),%rdi
lea    0x4(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     150b <main_float+0x3db>
lea    0x14(%rsp),%rdi
lea    0xc(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     150b <main_float+0x3db>
lea    0x10(%rsp),%rdi
lea    0xc(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     150b <main_float+0x3db>
lea    0xc90(%rip),%rdi
jmp    15c0 <main_float+0x490>
mov    %rsp,%rdi
lea    0x8(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     1562 <main_float+0x432>
lea    0x18(%rsp),%rdi
lea    0x8(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     1562 <main_float+0x432>
lea    0x14(%rsp),%rdi
lea    0xc(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     1562 <main_float+0x432>
lea    0x10(%rsp),%rdi
lea    0xc(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     1562 <main_float+0x432>
lea    0xc58(%rip),%rdi
jmp    15c0 <main_float+0x490>
mov    %rsp,%rdi
lea    0x4(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     15b9 <main_float+0x489>
lea    0x18(%rsp),%rdi
lea    0x4(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     15b9 <main_float+0x489>
lea    0x14(%rsp),%rdi
lea    0x1c(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     15b9 <main_float+0x489>
lea    0x10(%rsp),%rdi
lea    0x1c(%rsp),%rsi
call   1050 <equal_float@plt>
test   %rax,%rax
je     15b9 <main_float+0x489>
lea    0xc27(%rip),%rdi
jmp    15c0 <main_float+0x490>
lea    0xc4a(%rip),%rdi
lea    0xab9(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [32 x i8] c"/* Properties of type `%s': */\0A\00"
@.str.1 = [6 x i8] c"float\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_float() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
store i32 -1, i32* %2
store i32 -1, i32* %3
store float 1.000000e+00, float* %4
store float 1.000000e+00, float* %5
br label %20
20: ; preds = %37, %0
%21 = load float, float* %4
%22 = load float, float* %5
%23 = fadd float %21, %22
store float %23, float* %6
%24 = call i64 @equal_float(float* %4, float* %6)
%25 = icmp ne i64 %24, 0
br i1 %25, label %26, label %27
26: ; preds = %20
br label %42
27: ; preds = %20
%28 = load float, float* %6
%29 = load float, float* %4
%30 = fsub float %28, %29
store float %30, float* %6
%31 = call i64 @equal_float(float* %5, float* %6)
%32 = icmp ne i64 %31, 0
br i1 %32, label %34, label %33
33: ; preds = %27
br label %42
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 float, float* %5
%39 = fpext float %38 to double
%40 = fmul double 5.000000e-01, %39
%41 = fptrunc double %40 to float
store float %41, float* %5
br label %20
42: ; preds = %33, %26
store float 1.000000e+00, float* %7
store float -1.000000e+00, float* %8
br label %43
43: ; preds = %60, %42
%44 = load float, float* %7
%45 = load float, float* %8
%46 = fadd float %44, %45
store float %46, float* %9
%47 = call i64 @equal_float(float* %7, float* %9)
%48 = icmp ne i64 %47, 0
br i1 %48, label %49, label %50
49: ; preds = %43
br label %65
50: ; preds = %43
%51 = load float, float* %9
%52 = load float, float* %7
%53 = fsub float %51, %52
store float %53, float* %9
%54 = call i64 @equal_float(float* %8, float* %9)
%55 = icmp ne i64 %54, 0
br i1 %55, label %57, label %56
56: ; preds = %50
br label %65
57: ; preds = %50
%58 = load i32, i32* %3
%59 = add nsw i32 %58, 1
store i32 %59, i32* %3
br label %60
60: ; preds = %57
%61 = load float, float* %8
%62 = fpext float %61 to double
%63 = fmul double 5.000000e-01, %62
%64 = fptrunc double %63 to float
store float %64, float* %8
br label %43
65: ; preds = %56, %49
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
%67 = load i32, i32* %2
%68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.2, i64 0, i64 0), i32 %67)
%69 = load i32, i32* %3
%70 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.3, i64 0, i64 0), i32 %69)
%71 = load i32, i32* %3
%72 = load i32, i32* %2
%73 = icmp sle i32 %71, %72
br i1 %73, label %74, label %76
74: ; preds = %65
%75 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
store i32 -1, i32* %1
br label %91
76: ; preds = %65
%77 = load i32, i32* %3
%78 = load i32, i32* %2
%79 = add nsw i32 %78, 1
%80 = icmp sgt i32 %77, %79
br i1 %80, label %81, label %86
81: ; preds = %76
%82 = load i32, i32* %3
%83 = load i32, i32* %2
%84 = sub nsw i32 %82, %83
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32 %84)
br label %86
86: ; preds = %81, %76
%87 = load i32, i32* %2
%88 = add nsw i32 %87, 1
store i32 %88, i32* %1
%89 = load i32, i32* %1
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32 %89)
br label %91
91: ; preds = %86, %74
store float 1.000000e+00, float* %11
store i32 0, i32* %10
br label %92
92: ; preds = %101, %91
%93 = load i32, i32* %10
%94 = load i32, i32* %2
%95 = icmp slt i32 %93, %94
br i1 %95, label %96, label %104
96: ; preds = %92
%97 = load float, float* %11
%98 = fpext float %97 to double
%99 = fmul double 5.000000e-01, %98
%100 = fptrunc double %99 to float
store float %100, float* %11
br label %101
101: ; preds = %96
%102 = load i32, i32* %10
%103 = add nsw i32 %102, 1
store i32 %103, i32* %10
br label %92
104: ; preds = %92
%105 = load float, float* %11
%106 = fpext float %105 to double
%107 = call double @llvm.fmuladd.f64(double 5.000000e+00, double %106, double 1.000000e+00)
%108 = fptrunc double %107 to float
store float %108, float* %12
%109 = load float, float* %11
%110 = fpext float %109 to double
%111 = call double @llvm.fmuladd.f64(double 6.000000e+00, double %110, double 1.000000e+00)
%112 = fptrunc double %111 to float
store float %112, float* %13
%113 = load float, float* %11
%114 = fpext float %113 to double
%115 = call double @llvm.fmuladd.f64(double 5.400000e+00, double %114, double 1.000000e+00)
%116 = fptrunc double %115 to float
store float %116, float* %14
%117 = load float, float* %11
%118 = fpext float %117 to double
%119 = call double @llvm.fmuladd.f64(double 5.600000e+00, double %118, double 1.000000e+00)
%120 = fptrunc double %119 to float
store float %120, float* %15
%121 = load float, float* %11
%122 = fpext float %121 to double
%123 = call double @llvm.fmuladd.f64(double -5.000000e+00, double %122, double -1.000000e+00)
%124 = fptrunc double %123 to float
store float %124, float* %16
%125 = load float, float* %11
%126 = fpext float %125 to double
%127 = call double @llvm.fmuladd.f64(double -6.000000e+00, double %126, double -1.000000e+00)
%128 = fptrunc double %127 to float
store float %128, float* %17
%129 = load float, float* %11
%130 = fpext float %129 to double
%131 = call double @llvm.fmuladd.f64(double -5.400000e+00, double %130, double -1.000000e+00)
%132 = fptrunc double %131 to float
store float %132, float* %18
%133 = load float, float* %11
%134 = fpext float %133 to double
%135 = call double @llvm.fmuladd.f64(double -5.600000e+00, double %134, double -1.000000e+00)
%136 = fptrunc double %135 to float
store float %136, float* %19
%137 = call i64 @equal_float(float* %14, float* %12)
%138 = icmp ne i64 %137, 0
br i1 %138, label %139, label %150
139: ; preds = %104
%140 = call i64 @equal_float(float* %15, float* %13)
%141 = icmp ne i64 %140, 0
br i1 %141, label %142, label %150
142: ; preds = %139
%143 = call i64 @equal_float(float* %18, float* %16)
%144 = icmp ne i64 %143, 0
br i1 %144, label %145, label %150
145: ; preds = %142
%146 = call i64 @equal_float(float* %19, float* %17)
%147 = icmp ne i64 %146, 0
br i1 %147, label %148, label %150
148: ; preds = %145
%149 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
br label %197
150: ; preds = %145, %142, %139, %104
%151 = call i64 @equal_float(float* %14, float* %12)
%152 = icmp ne i64 %151, 0
br i1 %152, label %153, label %164
153: ; preds = %150
%154 = call i64 @equal_float(float* %15, float* %12)
%155 = icmp ne i64 %154, 0
br i1 %155, label %156, label %164
156: ; preds = %153
%157 = call i64 @equal_float(float* %18, float* %16)
%158 = icmp ne i64 %157, 0
br i1 %158, label %159, label %164
159: ; preds = %156
%160 = call i64 @equal_float(float* %19, float* %16)
%161 = icmp ne i64 %160, 0
br i1 %161, label %162, label %164
162: ; preds = %159
%163 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
br label %196
164: ; preds = %159, %156, %153, %150
%165 = call i64 @equal_float(float* %14, float* %13)
%166 = icmp ne i64 %165, 0
br i1 %166, label %167, label %178
167: ; preds = %164
%168 = call i64 @equal_float(float* %15, float* %13)
%169 = icmp ne i64 %168, 0
br i1 %169, label %170, label %178
170: ; preds = %167
%171 = call i64 @equal_float(float* %18, float* %16)
%172 = icmp ne i64 %171, 0
br i1 %172, label %173, label %178
173: ; preds = %170
%174 = call i64 @equal_float(float* %19, float* %16)
%175 = icmp ne i64 %174, 0
br i1 %175, label %176, label %178
176: ; preds = %173
%177 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
br label %195
178: ; preds = %173, %170, %167, %164
%179 = call i64 @equal_float(float* %14, float* %12)
%180 = icmp ne i64 %179, 0
br i1 %180, label %181, label %192
181: ; preds = %178
%182 = call i64 @equal_float(float* %15, float* %12)
%183 = icmp ne i64 %182, 0
br i1 %183, label %184, label %192
184: ; preds = %181
%185 = call i64 @equal_float(float* %18, float* %17)
%186 = icmp ne i64 %185, 0
br i1 %186, label %187, label %192
187: ; preds = %184
%188 = call i64 @equal_float(float* %19, float* %17)
%189 = icmp ne i64 %188, 0
br i1 %189, label %190, label %192
190: ; preds = %187
%191 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
br label %194
192: ; preds = %187, %184, %181, %178
%193 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
br label %194
194: ; preds = %192, %190
br label %195
195: ; preds = %194, %176
br label %196
196: ; preds = %195, %162
br label %197
197: ; preds = %196, %148
%198 = 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 = [6 x i8] c"float\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_float() {
%1 = alloca float
%2 = alloca float
%3 = alloca float
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = bitcast float* %1 to i8*
store float 1.000000e+00, float* %1
%16 = bitcast float* %2 to i8*
%17 = bitcast float* %3 to i8*
store float 1.000000e+00, float* %2
store float 2.000000e+00, float* %3
%18 = call i64 @equal_float(float* %1, float* %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 float, float* %3
%23 = load float, float* %1
%24 = fsub float %22, %23
store float %24, float* %3
%25 = call i64 @equal_float(float* %2, float* %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 float, float* %2
%30 = fmul float %29, 5.000000e-01
store float %30, float* %2
%31 = load float, float* %1
%32 = fadd float %30, %31
store float %32, float* %3
%33 = call i64 @equal_float(float* %1, float* %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 float* %4 to i8*
store float 1.000000e+00, float* %4
%38 = bitcast float* %5 to i8*
%39 = bitcast float* %6 to i8*
store float -1.000000e+00, float* %5
store float 0.000000e+00, float* %6
%40 = call i64 @equal_float(float* %4, float* %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 float, float* %6
%45 = load float, float* %4
%46 = fsub float %44, %45
store float %46, float* %6
%47 = call i64 @equal_float(float* %5, float* %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 float, float* %5
%52 = fmul float %51, 5.000000e-01
store float %52, float* %5
%53 = load float, float* %4
%54 = fadd float %52, %53
store float %54, float* %6
%55 = call i64 @equal_float(float* %4, float* %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 ([6 x i8], [6 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 ([6 x i8], [6 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 ([6 x i8], [6 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 ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32 %66)
br label %73
73: ; preds = %71, %63
%74 = bitcast float* %7 to i8*
%75 = bitcast float* %8 to i8*
%76 = bitcast float* %9 to i8*
%77 = bitcast float* %10 to i8*
%78 = bitcast float* %11 to i8*
%79 = bitcast float* %12 to i8*
%80 = bitcast float* %13 to i8*
%81 = bitcast float* %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, 3
%86 = icmp ult i32 %84, 3
br i1 %86, label %100, label %87
87: ; preds = %83
%88 = and i32 %36, -4
br label %89
89: ; preds = %89, %87
%90 = phi double [ 1.000000e+00, %87 ], [ %97, %89 ]
%91 = phi i32 [ 0, %87 ], [ %98, %89 ]
%92 = fmul double %90, 5.000000e-01
%93 = fptrunc double %92 to float
%94 = fmul float %93, 5.000000e-01
%95 = fmul float %94, 5.000000e-01
%96 = fmul float %95, 5.000000e-01
%97 = fpext float %96 to double
%98 = add i32 %91, 4
%99 = icmp eq i32 %98, %88
br i1 %99, label %100, label %89
100: ; preds = %89, %83
%101 = phi double [ undef, %83 ], [ %97, %89 ]
%102 = phi double [ 1.000000e+00, %83 ], [ %97, %89 ]
%103 = icmp eq i32 %85, 0
br i1 %103, label %112, label %104
104: ; preds = %100, %104
%105 = phi double [ %109, %104 ], [ %102, %100 ]
%106 = phi i32 [ %110, %104 ], [ 0, %100 ]
%107 = fmul double %105, 5.000000e-01
%108 = fptrunc double %107 to float
%109 = fpext float %108 to double
%110 = add i32 %106, 1
%111 = icmp eq i32 %110, %85
br i1 %111, label %112, label %104
112: ; preds = %100, %104, %73
%113 = phi double [ 1.000000e+00, %73 ], [ %101, %100 ], [ %109, %104 ]
%114 = call double @llvm.fmuladd.f64(double %113, double 5.000000e+00, double 1.000000e+00)
%115 = fptrunc double %114 to float
store float %115, float* %7
%116 = call double @llvm.fmuladd.f64(double %113, double 6.000000e+00, double 1.000000e+00)
%117 = fptrunc double %116 to float
store float %117, float* %8
%118 = call double @llvm.fmuladd.f64(double %113, double 5.400000e+00, double 1.000000e+00)
%119 = fptrunc double %118 to float
store float %119, float* %9
%120 = call double @llvm.fmuladd.f64(double %113, double 5.600000e+00, double 1.000000e+00)
%121 = fptrunc double %120 to float
store float %121, float* %10
%122 = call double @llvm.fmuladd.f64(double %113, double -5.000000e+00, double -1.000000e+00)
%123 = fptrunc double %122 to float
store float %123, float* %11
%124 = call double @llvm.fmuladd.f64(double %113, double -6.000000e+00, double -1.000000e+00)
%125 = fptrunc double %124 to float
store float %125, float* %12
%126 = call double @llvm.fmuladd.f64(double %113, double -5.400000e+00, double -1.000000e+00)
%127 = fptrunc double %126 to float
store float %127, float* %13
%128 = call double @llvm.fmuladd.f64(double %113, double -5.600000e+00, double -1.000000e+00)
%129 = fptrunc double %128 to float
store float %129, float* %14
%130 = call i64 @equal_float(float* %9, float* %7)
%131 = icmp eq i64 %130, 0
br i1 %131, label %141, label %132
132: ; preds = %112
%133 = call i64 @equal_float(float* %10, float* %8)
%134 = icmp eq i64 %133, 0
br i1 %134, label %141, label %135
135: ; preds = %132
%136 = call i64 @equal_float(float* %13, float* %11)
%137 = icmp eq i64 %136, 0
br i1 %137, label %141, label %138
138: ; preds = %135
%139 = call i64 @equal_float(float* %14, float* %12)
%140 = icmp eq i64 %139, 0
br i1 %140, label %141, label %178
141: ; preds = %138, %135, %132, %112
%142 = call i64 @equal_float(float* %9, float* %7)
%143 = icmp eq i64 %142, 0
br i1 %143, label %153, label %144
144: ; preds = %141
%145 = call i64 @equal_float(float* %10, float* %7)
%146 = icmp eq i64 %145, 0
br i1 %146, label %153, label %147
147: ; preds = %144
%148 = call i64 @equal_float(float* %13, float* %11)
%149 = icmp eq i64 %148, 0
br i1 %149, label %153, label %150
150: ; preds = %147
%151 = call i64 @equal_float(float* %14, float* %11)
%152 = icmp eq i64 %151, 0
br i1 %152, label %153, label %178
153: ; preds = %150, %147, %144, %141
%154 = call i64 @equal_float(float* %9, float* %8)
%155 = icmp eq i64 %154, 0
br i1 %155, label %165, label %156
156: ; preds = %153
%157 = call i64 @equal_float(float* %10, float* %8)
%158 = icmp eq i64 %157, 0
br i1 %158, label %165, label %159
159: ; preds = %156
%160 = call i64 @equal_float(float* %13, float* %11)
%161 = icmp eq i64 %160, 0
br i1 %161, label %165, label %162
162: ; preds = %159
%163 = call i64 @equal_float(float* %14, float* %11)
%164 = icmp eq i64 %163, 0
br i1 %164, label %165, label %178
165: ; preds = %162, %159, %156, %153
%166 = call i64 @equal_float(float* %9, float* %7)
%167 = icmp eq i64 %166, 0
br i1 %167, label %177, label %168
168: ; preds = %165
%169 = call i64 @equal_float(float* %10, float* %7)
%170 = icmp eq i64 %169, 0
br i1 %170, label %177, label %171
171: ; preds = %168
%172 = call i64 @equal_float(float* %13, float* %12)
%173 = icmp eq i64 %172, 0
br i1 %173, label %177, label %174
174: ; preds = %171
%175 = call i64 @equal_float(float* %14, float* %12)
%176 = icmp eq i64 %175, 0
br i1 %176, label %177, label %178
177: ; preds = %174, %171, %168, %165
br label %178
178: ; preds = %174, %162, %150, %138, %177
%179 = phi i8* [ getelementptr inbounds ([45 x i8], [45 x i8]* @.str.11, i64 0, i64 0), %177 ], [ getelementptr inbounds ([37 x i8], [37 x i8]* @.str.7, i64 0, i64 0), %138 ], [ getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0), %150 ], [ getelementptr inbounds ([38 x i8], [38 x i8]* @.str.9, i64 0, i64 0), %162 ], [ getelementptr inbounds ([44 x i8], [44 x i8]* @.str.10, i64 0, i64 0), %174 ]
%180 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) %179, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
%181 = call i32 @putchar(i32 10)
ret void
}