void check_float(void) {
  do {
    do {
      float a = 0.0f;
      float b = 0.0f;
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(0.0f, 0.0f);
      comparecf(cr, 0.0f, 0.0f);
      comparecf(cs, 0.0f, 0.0f);
    } while (0);
    do {
      float a = 0.0f;
      float b = -0.0f;
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(0.0f, -0.0f);
      comparecf(cr, 0.0f, -0.0f);
      comparecf(cs, 0.0f, -0.0f);
    } while (0);
    do {
      float a = 0.0f;
      float b = __builtin_nanf("");
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(0.0f, __builtin_nanf(""));
      comparecf(cr, 0.0f, __builtin_nanf(""));
      comparecf(cs, 0.0f, __builtin_nanf(""));
    } while (0);
    do {
      float a = 0.0f;
      float b = __builtin_inff();
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(0.0f, __builtin_inff());
      comparecf(cr, 0.0f, __builtin_inff());
      comparecf(cs, 0.0f, __builtin_inff());
    } while (0);
    do {
      float a = -0.0f;
      float b = 0.0f;
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(-0.0f, 0.0f);
      comparecf(cr, -0.0f, 0.0f);
      comparecf(cs, -0.0f, 0.0f);
    } while (0);
    do {
      float a = -0.0f;
      float b = -0.0f;
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(-0.0f, -0.0f);
      comparecf(cr, -0.0f, -0.0f);
      comparecf(cs, -0.0f, -0.0f);
    } while (0);
    do {
      float a = -0.0f;
      float b = __builtin_nanf("");
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(-0.0f, __builtin_nanf(""));
      comparecf(cr, -0.0f, __builtin_nanf(""));
      comparecf(cs, -0.0f, __builtin_nanf(""));
    } while (0);
    do {
      float a = -0.0f;
      float b = __builtin_inff();
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(-0.0f, __builtin_inff());
      comparecf(cr, -0.0f, __builtin_inff());
      comparecf(cs, -0.0f, __builtin_inff());
    } while (0);
    do {
      float a = __builtin_nanf("");
      float b = 0.0f;
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(__builtin_nanf(""), 0.0f);
      comparecf(cr, __builtin_nanf(""), 0.0f);
      comparecf(cs, __builtin_nanf(""), 0.0f);
    } while (0);
    do {
      float a = __builtin_nanf("");
      float b = -0.0f;
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(__builtin_nanf(""), -0.0f);
      comparecf(cr, __builtin_nanf(""), -0.0f);
      comparecf(cs, __builtin_nanf(""), -0.0f);
    } while (0);
    do {
      float a = __builtin_nanf("");
      float b = __builtin_nanf("");
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs =
          __builtin_complex(__builtin_nanf(""), __builtin_nanf(""));
      comparecf(cr, __builtin_nanf(""), __builtin_nanf(""));
      comparecf(cs, __builtin_nanf(""), __builtin_nanf(""));
    } while (0);
    do {
      float a = __builtin_nanf("");
      float b = __builtin_inff();
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs =
          __builtin_complex(__builtin_nanf(""), __builtin_inff());
      comparecf(cr, __builtin_nanf(""), __builtin_inff());
      comparecf(cs, __builtin_nanf(""), __builtin_inff());
    } while (0);
    do {
      float a = __builtin_inff();
      float b = 0.0f;
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(__builtin_inff(), 0.0f);
      comparecf(cr, __builtin_inff(), 0.0f);
      comparecf(cs, __builtin_inff(), 0.0f);
    } while (0);
    do {
      float a = __builtin_inff();
      float b = -0.0f;
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs = __builtin_complex(__builtin_inff(), -0.0f);
      comparecf(cr, __builtin_inff(), -0.0f);
      comparecf(cs, __builtin_inff(), -0.0f);
    } while (0);
    do {
      float a = __builtin_inff();
      float b = __builtin_nanf("");
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs =
          __builtin_complex(__builtin_inff(), __builtin_nanf(""));
      comparecf(cr, __builtin_inff(), __builtin_nanf(""));
      comparecf(cs, __builtin_inff(), __builtin_nanf(""));
    } while (0);
    do {
      float a = __builtin_inff();
      float b = __builtin_inff();
      _Complex float cr = __builtin_complex(a, b);
      static _Complex float cs =
          __builtin_complex(__builtin_inff(), __builtin_inff());
      comparecf(cr, __builtin_inff(), __builtin_inff());
      comparecf(cs, __builtin_inff(), __builtin_inff());
    } while (0);
  } while (0);
}


x86 assembly (clang, -O0):
<check_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0x200,%rsp
jmp    1120 <check_float+0x10>
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movss  -0x4(%rbp),%xmm1
movss  -0x8(%rbp),%xmm0
movss  %xmm1,-0x10(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movss  %xmm1,-0x18(%rbp)
movss  %xmm0,-0x14(%rbp)
movsd  -0x18(%rbp),%xmm0
xorps  %xmm2,%xmm2
mov    $0x3,%al
movaps %xmm2,%xmm1
call   1030 <comparecf@plt>
movss  0x2f34(%rip),%xmm1
movss  0x2f30(%rip),%xmm0
movss  %xmm1,-0x20(%rbp)
movss  %xmm0,-0x1c(%rbp)
movsd  -0x20(%rbp),%xmm0
xorps  %xmm2,%xmm2
mov    $0x3,%al
movaps %xmm2,%xmm1
call   1030 <comparecf@plt>
jmp    1199 <check_float+0x89>
movl   $0x0,-0x24(%rbp)
movl   $0x80000000,-0x28(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x28(%rbp),%xmm0
movss  %xmm1,-0x30(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
movss  %xmm1,-0x38(%rbp)
movss  %xmm0,-0x34(%rbp)
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
movsd  0xe21(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2e3a(%rip),%xmm1
movss  0x2e36(%rip),%xmm0
movss  %xmm1,-0x40(%rbp)
movss  %xmm0,-0x3c(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
movsd  0xdf0(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    121c <check_float+0x10c>
movl   $0x0,-0x44(%rbp)
movl   $0x7fc00000,-0x48(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
movss  %xmm1,-0x50(%rbp)
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x4c(%rbp),%xmm0
movss  %xmm1,-0x58(%rbp)
movss  %xmm0,-0x54(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
movsd  0xda6(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2dbf(%rip),%xmm1
movss  0x2dbb(%rip),%xmm0
movss  %xmm1,-0x60(%rbp)
movss  %xmm0,-0x5c(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
movsd  0xd75(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    129f <check_float+0x18f>
movl   $0x0,-0x64(%rbp)
movl   $0x7f800000,-0x68(%rbp)
movss  -0x64(%rbp),%xmm1
movss  -0x68(%rbp),%xmm0
movss  %xmm1,-0x70(%rbp)
movss  %xmm0,-0x6c(%rbp)
movss  -0x70(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
movss  %xmm1,-0x78(%rbp)
movss  %xmm0,-0x74(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
movsd  0xd2b(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2d44(%rip),%xmm1
movss  0x2d40(%rip),%xmm0
movss  %xmm1,-0x80(%rbp)
movss  %xmm0,-0x7c(%rbp)
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
movsd  0xcfa(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    1322 <check_float+0x212>
movl   $0x80000000,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
movss  -0x84(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm1,-0x90(%rbp)
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x90(%rbp),%xmm1
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm1,-0x98(%rbp)
ff
movss  %xmm0,-0x94(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  0xc7a(%rip),%xmm1
xorps  %xmm2,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2ca8(%rip),%xmm1
movss  0x2ca4(%rip),%xmm0
movss  %xmm1,-0xa0(%rbp)
ff
movss  %xmm0,-0x9c(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0xc40(%rip),%xmm1
xorps  %xmm2,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    13cf <check_float+0x2bf>
movl   $0x80000000,-0xa4(%rbp)
movl   $0x80000000,-0xa8(%rbp)
movss  -0xa4(%rbp),%xmm1
ff
movss  -0xa8(%rbp),%xmm0
ff
movss  %xmm1,-0xb0(%rbp)
ff
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xb0(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm0
ff
movss  %xmm1,-0xb8(%rbp)
ff
movss  %xmm0,-0xb4(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0xbcd(%rip),%xmm2
mov    $0x3,%al
movaps %xmm2,%xmm1
call   1030 <comparecf@plt>
movss  0x2c03(%rip),%xmm1
movss  0x2bff(%rip),%xmm0
movss  %xmm1,-0xc0(%rbp)
ff
movss  %xmm0,-0xbc(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0xb93(%rip),%xmm2
mov    $0x3,%al
movaps %xmm2,%xmm1
call   1030 <comparecf@plt>
jmp    147c <check_float+0x36c>
movl   $0x80000000,-0xc4(%rbp)
movl   $0x7fc00000,-0xc8(%rbp)
movss  -0xc4(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm0
ff
movss  %xmm1,-0xd0(%rbp)
ff
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xd0(%rbp),%xmm1
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  %xmm1,-0xd8(%rbp)
ff
movss  %xmm0,-0xd4(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  0xb20(%rip),%xmm1
movsd  0xb20(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2b59(%rip),%xmm1
movss  0x2b55(%rip),%xmm0
movss  %xmm1,-0xe0(%rbp)
ff
movss  %xmm0,-0xdc(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  0xae1(%rip),%xmm1
movsd  0xae1(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    1533 <check_float+0x423>
movl   $0x80000000,-0xe4(%rbp)
movl   $0x7f800000,-0xe8(%rbp)
movss  -0xe4(%rbp),%xmm1
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  %xmm1,-0xf0(%rbp)
ff
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xf0(%rbp),%xmm1
ff
movss  -0xec(%rbp),%xmm0
ff
movss  %xmm1,-0xf8(%rbp)
ff
movss  %xmm0,-0xf4(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  0xa69(%rip),%xmm1
movsd  0xa71(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2aaa(%rip),%xmm1
movss  0x2aa6(%rip),%xmm0
movss  %xmm1,-0x100(%rbp)
ff
movss  %xmm0,-0xfc(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  0xa2a(%rip),%xmm1
movsd  0xa32(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    15ea <check_float+0x4da>
movl   $0x7fc00000,-0x104(%rbp)
movl   $0x0,-0x108(%rbp)
movss  -0x104(%rbp),%xmm1
ff
movss  -0x108(%rbp),%xmm0
ff
movss  %xmm1,-0x110(%rbp)
ff
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x110(%rbp),%xmm1
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  %xmm1,-0x118(%rbp)
ff
movss  %xmm0,-0x114(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  0x9ba(%rip),%xmm1
xorps  %xmm2,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2a00(%rip),%xmm1
movss  0x29fc(%rip),%xmm0
movss  %xmm1,-0x120(%rbp)
ff
movss  %xmm0,-0x11c(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  0x980(%rip),%xmm1
xorps  %xmm2,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    1697 <check_float+0x587>
movl   $0x7fc00000,-0x124(%rbp)
movl   $0x80000000,-0x128(%rbp)
movss  -0x124(%rbp),%xmm1
ff
movss  -0x128(%rbp),%xmm0
ff
movss  %xmm1,-0x130(%rbp)
ff
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0x130(%rbp),%xmm1
ff
movss  -0x12c(%rbp),%xmm0
ff
movss  %xmm1,-0x138(%rbp)
ff
movss  %xmm0,-0x134(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  0x90d(%rip),%xmm1
movsd  0x8fd(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2956(%rip),%xmm1
movss  0x2952(%rip),%xmm0
movss  %xmm1,-0x140(%rbp)
ff
movss  %xmm0,-0x13c(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  0x8ce(%rip),%xmm1
movsd  0x8be(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    174e <check_float+0x63e>
movl   $0x7fc00000,-0x144(%rbp)
movl   $0x7fc00000,-0x148(%rbp)
movss  -0x144(%rbp),%xmm1
ff
movss  -0x148(%rbp),%xmm0
ff
movss  %xmm1,-0x150(%rbp)
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x150(%rbp),%xmm1
ff
movss  -0x14c(%rbp),%xmm0
ff
movss  %xmm1,-0x158(%rbp)
ff
movss  %xmm0,-0x154(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  0x856(%rip),%xmm2
mov    $0x3,%al
movaps %xmm2,%xmm1
call   1030 <comparecf@plt>
movss  0x28ac(%rip),%xmm1
movss  0x28a8(%rip),%xmm0
movss  %xmm1,-0x160(%rbp)
ff
movss  %xmm0,-0x15c(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  0x81c(%rip),%xmm2
mov    $0x3,%al
movaps %xmm2,%xmm1
call   1030 <comparecf@plt>
jmp    17fb <check_float+0x6eb>
movl   $0x7fc00000,-0x164(%rbp)
movl   $0x7f800000,-0x168(%rbp)
movss  -0x164(%rbp),%xmm1
ff
movss  -0x168(%rbp),%xmm0
ff
movss  %xmm1,-0x170(%rbp)
ff
movss  %xmm0,-0x16c(%rbp)
ff
movss  -0x170(%rbp),%xmm1
ff
movss  -0x16c(%rbp),%xmm0
ff
movss  %xmm1,-0x178(%rbp)
ff
movss  %xmm0,-0x174(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  0x7a9(%rip),%xmm1
movsd  0x7a9(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2802(%rip),%xmm1
movss  0x27fe(%rip),%xmm0
movss  %xmm1,-0x180(%rbp)
ff
movss  %xmm0,-0x17c(%rbp)
ff
movsd  -0x180(%rbp),%xmm0
ff
movsd  0x76a(%rip),%xmm1
movsd  0x76a(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    18b2 <check_float+0x7a2>
movl   $0x7f800000,-0x184(%rbp)
movl   $0x0,-0x188(%rbp)
movss  -0x184(%rbp),%xmm1
ff
movss  -0x188(%rbp),%xmm0
ff
movss  %xmm1,-0x190(%rbp)
ff
movss  %xmm0,-0x18c(%rbp)
ff
movss  -0x190(%rbp),%xmm1
ff
movss  -0x18c(%rbp),%xmm0
ff
movss  %xmm1,-0x198(%rbp)
ff
movss  %xmm0,-0x194(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
movsd  0x6fa(%rip),%xmm1
xorps  %xmm2,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x2758(%rip),%xmm1
movss  0x2754(%rip),%xmm0
movss  %xmm1,-0x1a0(%rbp)
ff
movss  %xmm0,-0x19c(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  0x6c0(%rip),%xmm1
xorps  %xmm2,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    195f <check_float+0x84f>
movl   $0x7f800000,-0x1a4(%rbp)
movl   $0x80000000,-0x1a8(%rbp)
movss  -0x1a4(%rbp),%xmm1
ff
movss  -0x1a8(%rbp),%xmm0
ff
movss  %xmm1,-0x1b0(%rbp)
ff
movss  %xmm0,-0x1ac(%rbp)
ff
movss  -0x1b0(%rbp),%xmm1
ff
movss  -0x1ac(%rbp),%xmm0
ff
movss  %xmm1,-0x1b8(%rbp)
ff
movss  %xmm0,-0x1b4(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  0x64d(%rip),%xmm1
movsd  0x635(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x26ae(%rip),%xmm1
movss  0x26aa(%rip),%xmm0
movss  %xmm1,-0x1c0(%rbp)
ff
movss  %xmm0,-0x1bc(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
movsd  0x60e(%rip),%xmm1
movsd  0x5f6(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    1a16 <check_float+0x906>
movl   $0x7f800000,-0x1c4(%rbp)
movl   $0x7fc00000,-0x1c8(%rbp)
movss  -0x1c4(%rbp),%xmm1
ff
movss  -0x1c8(%rbp),%xmm0
ff
movss  %xmm1,-0x1d0(%rbp)
ff
movss  %xmm0,-0x1cc(%rbp)
ff
movss  -0x1d0(%rbp),%xmm1
ff
movss  -0x1cc(%rbp),%xmm0
ff
movss  %xmm1,-0x1d8(%rbp)
ff
movss  %xmm0,-0x1d4(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  0x596(%rip),%xmm1
movsd  0x586(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0x25ff(%rip),%xmm1
movss  0x25fb(%rip),%xmm0
movss  %xmm1,-0x1e0(%rbp)
ff
movss  %xmm0,-0x1dc(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm0
ff
movsd  0x557(%rip),%xmm1
movsd  0x547(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
jmp    1acd <check_float+0x9bd>
movl   $0x7f800000,-0x1e4(%rbp)
movl   $0x7f800000,-0x1e8(%rbp)
movss  -0x1e4(%rbp),%xmm1
ff
movss  -0x1e8(%rbp),%xmm0
ff
movss  %xmm1,-0x1f0(%rbp)
ff
movss  %xmm0,-0x1ec(%rbp)
movss  -0x1f0(%rbp),%xmm1
ff
movss  -0x1ec(%rbp),%xmm0
ff
movss  %xmm1,-0x1f8(%rbp)
ff
movss  %xmm0,-0x1f4(%rbp)
ff
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  0x4df(%rip),%xmm2
mov    $0x3,%al
movaps %xmm2,%xmm1
call   1030 <comparecf@plt>
movss  0x2555(%rip),%xmm1
movss  0x2551(%rip),%xmm0
movss  %xmm1,-0x200(%rbp)
ff
movss  %xmm0,-0x1fc(%rbp)
ff
movsd  -0x200(%rbp),%xmm0
ff
movsd  0x4a5(%rip),%xmm2
mov    $0x3,%al
movaps %xmm2,%xmm1
call   1030 <comparecf@plt>
jmp    1b7a <check_float+0xa6a>
add    $0x200,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_float>:
push   %rax
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xec8(%rip),%xmm0
movsd  0xf80(%rip),%xmm2
xorps  %xmm1,%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
xorps  %xmm1,%xmm1
movaps 0xeac(%rip),%xmm0
movsd  0xf64(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xea6(%rip),%xmm0
movsd  0xf56(%rip),%xmm2
xorps  %xmm1,%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
xorps  %xmm1,%xmm1
movaps 0xe8a(%rip),%xmm0
movsd  0xf3a(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xe84(%rip),%xmm0
movsd  0xf2c(%rip),%xmm2
xorps  %xmm1,%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
xorps  %xmm1,%xmm1
movaps 0xe68(%rip),%xmm0
movsd  0xf10(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0xf09(%rip),%xmm0
xorps  %xmm2,%xmm2
movsd  0xee6(%rip),%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
xorps  %xmm2,%xmm2
movss  0xeec(%rip),%xmm0
movsd  0xecc(%rip),%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xe2e(%rip),%xmm0
movsd  0xeb6(%rip),%xmm1
movaps %xmm1,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xe15(%rip),%xmm0
movsd  0xe9d(%rip),%xmm1
movaps %xmm1,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xe0c(%rip),%xmm0
movsd  0xe84(%rip),%xmm1
movsd  0xe84(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xdee(%rip),%xmm0
movsd  0xe66(%rip),%xmm1
movsd  0xe66(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xde0(%rip),%xmm0
movsd  0xe48(%rip),%xmm1
movsd  0xe50(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xdc2(%rip),%xmm0
movsd  0xe2a(%rip),%xmm1
movsd  0xe32(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0xe2f(%rip),%xmm0
xorps  %xmm2,%xmm2
movsd  0xe10(%rip),%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
xorps  %xmm2,%xmm2
movss  0xe12(%rip),%xmm0
movsd  0xdf6(%rip),%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xd80(%rip),%xmm0
movsd  0xde0(%rip),%xmm1
movsd  0xdd0(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xd62(%rip),%xmm0
movsd  0xdc2(%rip),%xmm1
movsd  0xdb2(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xd54(%rip),%xmm0
movsd  0xda4(%rip),%xmm1
movaps %xmm1,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xd3b(%rip),%xmm0
movsd  0xd8b(%rip),%xmm1
movaps %xmm1,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xd32(%rip),%xmm0
movsd  0xd72(%rip),%xmm1
movsd  0xd72(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xd14(%rip),%xmm0
movsd  0xd54(%rip),%xmm1
movsd  0xd54(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movss  0xd55(%rip),%xmm0
xorps  %xmm2,%xmm2
movsd  0xd3a(%rip),%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
xorps  %xmm2,%xmm2
movss  0xd38(%rip),%xmm0
movsd  0xd20(%rip),%xmm1
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xcd2(%rip),%xmm0
movsd  0xd0a(%rip),%xmm1
movsd  0xcf2(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xcb4(%rip),%xmm0
movsd  0xcec(%rip),%xmm1
movsd  0xcd4(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xca6(%rip),%xmm0
movsd  0xcce(%rip),%xmm1
movsd  0xcbe(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xc88(%rip),%xmm0
movsd  0xcb0(%rip),%xmm1
movsd  0xca0(%rip),%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xc7a(%rip),%xmm0
movsd  0xc92(%rip),%xmm1
movaps %xmm1,%xmm2
mov    $0x3,%al
call   1030 <comparecf@plt>
movaps 0xc61(%rip),%xmm0
movsd  0xc79(%rip),%xmm1
movaps %xmm1,%xmm2
mov    $0x3,%al
pop    %rcx
jmp    1030 <comparecf@plt>

LLVM IR (-O0):
@check_float.cs = internal global { float, float } zeroinitializer
@check_float.cs.1 = internal global { float, float } { float 0.000000e+00, float -0.000000e+00 }
@check_float.cs.2 = internal global { float, float } { float 0.000000e+00, float 0x7FF8000000000000 }
@check_float.cs.3 = internal global { float, float } { float 0.000000e+00, float 0x7FF0000000000000 }
@check_float.cs.4 = internal global { float, float } { float -0.000000e+00, float 0.000000e+00 }
@check_float.cs.5 = internal global { float, float } { float -0.000000e+00, float -0.000000e+00 }
@check_float.cs.6 = internal global { float, float } { float -0.000000e+00, float 0x7FF8000000000000 }
@check_float.cs.7 = internal global { float, float } { float -0.000000e+00, float 0x7FF0000000000000 }
@check_float.cs.8 = internal global { float, float } { float 0x7FF8000000000000, float 0.000000e+00 }
@check_float.cs.9 = internal global { float, float } { float 0x7FF8000000000000, float -0.000000e+00 }
@check_float.cs.10 = internal global { float, float } { float 0x7FF8000000000000, float 0x7FF8000000000000 }
@check_float.cs.11 = internal global { float, float } { float 0x7FF8000000000000, float 0x7FF0000000000000 }
@check_float.cs.12 = internal global { float, float } { float 0x7FF0000000000000, float 0.000000e+00 }
@check_float.cs.13 = internal global { float, float } { float 0x7FF0000000000000, float -0.000000e+00 }
@check_float.cs.14 = internal global { float, float } { float 0x7FF0000000000000, float 0x7FF8000000000000 }
@check_float.cs.15 = internal global { float, float } { float 0x7FF0000000000000, float 0x7FF0000000000000 }
define void @check_float() {
%1 = alloca float
%2 = alloca float
%3 = alloca { float, float }
%4 = alloca { float, float }
%5 = alloca { float, float }
%6 = alloca float
%7 = alloca float
%8 = alloca { float, float }
%9 = alloca { float, float }
%10 = alloca { float, float }
%11 = alloca float
%12 = alloca float
%13 = alloca { float, float }
%14 = alloca { float, float }
%15 = alloca { float, float }
%16 = alloca float
%17 = alloca float
%18 = alloca { float, float }
%19 = alloca { float, float }
%20 = alloca { float, float }
%21 = alloca float
%22 = alloca float
%23 = alloca { float, float }
%24 = alloca { float, float }
%25 = alloca { float, float }
%26 = alloca float
%27 = alloca float
%28 = alloca { float, float }
%29 = alloca { float, float }
%30 = alloca { float, float }
%31 = alloca float
%32 = alloca float
%33 = alloca { float, float }
%34 = alloca { float, float }
%35 = alloca { float, float }
%36 = alloca float
%37 = alloca float
%38 = alloca { float, float }
%39 = alloca { float, float }
%40 = alloca { float, float }
%41 = alloca float
%42 = alloca float
%43 = alloca { float, float }
%44 = alloca { float, float }
%45 = alloca { float, float }
%46 = alloca float
%47 = alloca float
%48 = alloca { float, float }
%49 = alloca { float, float }
%50 = alloca { float, float }
%51 = alloca float
%52 = alloca float
%53 = alloca { float, float }
%54 = alloca { float, float }
%55 = alloca { float, float }
%56 = alloca float
%57 = alloca float
%58 = alloca { float, float }
%59 = alloca { float, float }
%60 = alloca { float, float }
%61 = alloca float
%62 = alloca float
%63 = alloca { float, float }
%64 = alloca { float, float }
%65 = alloca { float, float }
%66 = alloca float
%67 = alloca float
%68 = alloca { float, float }
%69 = alloca { float, float }
%70 = alloca { float, float }
%71 = alloca float
%72 = alloca float
%73 = alloca { float, float }
%74 = alloca { float, float }
%75 = alloca { float, float }
%76 = alloca float
%77 = alloca float
%78 = alloca { float, float }
%79 = alloca { float, float }
%80 = alloca { float, float }
br label %81
81: ; preds = %0
br label %82
82: ; preds = %81
store float 0.000000e+00, float* %1
store float 0.000000e+00, float* %2
%83 = load float, float* %1
%84 = load float, float* %2
%85 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 0
%86 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 1
store float %83, float* %85
store float %84, float* %86
%87 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 0
%88 = load float, float* %87
%89 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 1
%90 = load float, float* %89
%91 = getelementptr inbounds { float, float }, { float, float }* %4, i32 0, i32 0
%92 = getelementptr inbounds { float, float }, { float, float }* %4, i32 0, i32 1
store float %88, float* %91
store float %90, float* %92
%93 = bitcast { float, float }* %4 to <2 x float>*
%94 = load <2 x float>, <2 x float>* %93
%95 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %94, double 0.000000e+00, double 0.000000e+00)
%96 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs, i32 0, i32 0)
%97 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs, i32 0, i32 1)
%98 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 0
%99 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 1
store float %96, float* %98
store float %97, float* %99
%100 = bitcast { float, float }* %5 to <2 x float>*
%101 = load <2 x float>, <2 x float>* %100
%102 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %101, double 0.000000e+00, double 0.000000e+00)
br label %103
103: ; preds = %82
br label %104
104: ; preds = %103
store float 0.000000e+00, float* %6
store float -0.000000e+00, float* %7
%105 = load float, float* %6
%106 = load float, float* %7
%107 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 0
%108 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 1
store float %105, float* %107
store float %106, float* %108
%109 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 0
%110 = load float, float* %109
%111 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 1
%112 = load float, float* %111
%113 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 0
%114 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 1
store float %110, float* %113
store float %112, float* %114
%115 = bitcast { float, float }* %9 to <2 x float>*
%116 = load <2 x float>, <2 x float>* %115
%117 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %116, double 0.000000e+00, double -0.000000e+00)
%118 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.1, i32 0, i32 0)
%119 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.1, i32 0, i32 1)
%120 = getelementptr inbounds { float, float }, { float, float }* %10, i32 0, i32 0
%121 = getelementptr inbounds { float, float }, { float, float }* %10, i32 0, i32 1
store float %118, float* %120
store float %119, float* %121
%122 = bitcast { float, float }* %10 to <2 x float>*
%123 = load <2 x float>, <2 x float>* %122
%124 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %123, double 0.000000e+00, double -0.000000e+00)
br label %125
125: ; preds = %104
br label %126
126: ; preds = %125
store float 0.000000e+00, float* %11
store float 0x7FF8000000000000, float* %12
%127 = load float, float* %11
%128 = load float, float* %12
%129 = getelementptr inbounds { float, float }, { float, float }* %13, i32 0, i32 0
%130 = getelementptr inbounds { float, float }, { float, float }* %13, i32 0, i32 1
store float %127, float* %129
store float %128, float* %130
%131 = getelementptr inbounds { float, float }, { float, float }* %13, i32 0, i32 0
%132 = load float, float* %131
%133 = getelementptr inbounds { float, float }, { float, float }* %13, i32 0, i32 1
%134 = load float, float* %133
%135 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 0
%136 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 1
store float %132, float* %135
store float %134, float* %136
%137 = bitcast { float, float }* %14 to <2 x float>*
%138 = load <2 x float>, <2 x float>* %137
%139 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %138, double 0.000000e+00, double 0x7FF8000000000000)
%140 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.2, i32 0, i32 0)
%141 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.2, i32 0, i32 1)
%142 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 0
%143 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 1
store float %140, float* %142
store float %141, float* %143
%144 = bitcast { float, float }* %15 to <2 x float>*
%145 = load <2 x float>, <2 x float>* %144
%146 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %145, double 0.000000e+00, double 0x7FF8000000000000)
br label %147
147: ; preds = %126
br label %148
148: ; preds = %147
store float 0.000000e+00, float* %16
store float 0x7FF0000000000000, float* %17
%149 = load float, float* %16
%150 = load float, float* %17
%151 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 0
%152 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 1
store float %149, float* %151
store float %150, float* %152
%153 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 0
%154 = load float, float* %153
%155 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 1
%156 = load float, float* %155
%157 = getelementptr inbounds { float, float }, { float, float }* %19, i32 0, i32 0
%158 = getelementptr inbounds { float, float }, { float, float }* %19, i32 0, i32 1
store float %154, float* %157
store float %156, float* %158
%159 = bitcast { float, float }* %19 to <2 x float>*
%160 = load <2 x float>, <2 x float>* %159
%161 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %160, double 0.000000e+00, double 0x7FF0000000000000)
%162 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.3, i32 0, i32 0)
%163 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.3, i32 0, i32 1)
%164 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 0
%165 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 1
store float %162, float* %164
store float %163, float* %165
%166 = bitcast { float, float }* %20 to <2 x float>*
%167 = load <2 x float>, <2 x float>* %166
%168 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %167, double 0.000000e+00, double 0x7FF0000000000000)
br label %169
169: ; preds = %148
br label %170
170: ; preds = %169
store float -0.000000e+00, float* %21
store float 0.000000e+00, float* %22
%171 = load float, float* %21
%172 = load float, float* %22
%173 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 0
%174 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 1
store float %171, float* %173
store float %172, float* %174
%175 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 0
%176 = load float, float* %175
%177 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 1
%178 = load float, float* %177
%179 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 0
%180 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 1
store float %176, float* %179
store float %178, float* %180
%181 = bitcast { float, float }* %24 to <2 x float>*
%182 = load <2 x float>, <2 x float>* %181
%183 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %182, double -0.000000e+00, double 0.000000e+00)
%184 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.4, i32 0, i32 0)
%185 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.4, i32 0, i32 1)
%186 = getelementptr inbounds { float, float }, { float, float }* %25, i32 0, i32 0
%187 = getelementptr inbounds { float, float }, { float, float }* %25, i32 0, i32 1
store float %184, float* %186
store float %185, float* %187
%188 = bitcast { float, float }* %25 to <2 x float>*
%189 = load <2 x float>, <2 x float>* %188
%190 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %189, double -0.000000e+00, double 0.000000e+00)
br label %191
191: ; preds = %170
br label %192
192: ; preds = %191
store float -0.000000e+00, float* %26
store float -0.000000e+00, float* %27
%193 = load float, float* %26
%194 = load float, float* %27
%195 = getelementptr inbounds { float, float }, { float, float }* %28, i32 0, i32 0
%196 = getelementptr inbounds { float, float }, { float, float }* %28, i32 0, i32 1
store float %193, float* %195
store float %194, float* %196
%197 = getelementptr inbounds { float, float }, { float, float }* %28, i32 0, i32 0
%198 = load float, float* %197
%199 = getelementptr inbounds { float, float }, { float, float }* %28, i32 0, i32 1
%200 = load float, float* %199
%201 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 0
%202 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 1
store float %198, float* %201
store float %200, float* %202
%203 = bitcast { float, float }* %29 to <2 x float>*
%204 = load <2 x float>, <2 x float>* %203
%205 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %204, double -0.000000e+00, double -0.000000e+00)
%206 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.5, i32 0, i32 0)
%207 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.5, i32 0, i32 1)
%208 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 0
%209 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 1
store float %206, float* %208
store float %207, float* %209
%210 = bitcast { float, float }* %30 to <2 x float>*
%211 = load <2 x float>, <2 x float>* %210
%212 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %211, double -0.000000e+00, double -0.000000e+00)
br label %213
213: ; preds = %192
br label %214
214: ; preds = %213
store float -0.000000e+00, float* %31
store float 0x7FF8000000000000, float* %32
%215 = load float, float* %31
%216 = load float, float* %32
%217 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 0
%218 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 1
store float %215, float* %217
store float %216, float* %218
%219 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 0
%220 = load float, float* %219
%221 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 1
%222 = load float, float* %221
%223 = getelementptr inbounds { float, float }, { float, float }* %34, i32 0, i32 0
%224 = getelementptr inbounds { float, float }, { float, float }* %34, i32 0, i32 1
store float %220, float* %223
store float %222, float* %224
%225 = bitcast { float, float }* %34 to <2 x float>*
%226 = load <2 x float>, <2 x float>* %225
%227 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %226, double -0.000000e+00, double 0x7FF8000000000000)
%228 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.6, i32 0, i32 0)
%229 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.6, i32 0, i32 1)
%230 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 0
%231 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 1
store float %228, float* %230
store float %229, float* %231
%232 = bitcast { float, float }* %35 to <2 x float>*
%233 = load <2 x float>, <2 x float>* %232
%234 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %233, double -0.000000e+00, double 0x7FF8000000000000)
br label %235
235: ; preds = %214
br label %236
236: ; preds = %235
store float -0.000000e+00, float* %36
store float 0x7FF0000000000000, float* %37
%237 = load float, float* %36
%238 = load float, float* %37
%239 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 0
%240 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 1
store float %237, float* %239
store float %238, float* %240
%241 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 0
%242 = load float, float* %241
%243 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 1
%244 = load float, float* %243
%245 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 0
%246 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 1
store float %242, float* %245
store float %244, float* %246
%247 = bitcast { float, float }* %39 to <2 x float>*
%248 = load <2 x float>, <2 x float>* %247
%249 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %248, double -0.000000e+00, double 0x7FF0000000000000)
%250 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.7, i32 0, i32 0)
%251 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.7, i32 0, i32 1)
%252 = getelementptr inbounds { float, float }, { float, float }* %40, i32 0, i32 0
%253 = getelementptr inbounds { float, float }, { float, float }* %40, i32 0, i32 1
store float %250, float* %252
store float %251, float* %253
%254 = bitcast { float, float }* %40 to <2 x float>*
%255 = load <2 x float>, <2 x float>* %254
%256 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %255, double -0.000000e+00, double 0x7FF0000000000000)
br label %257
257: ; preds = %236
br label %258
258: ; preds = %257
store float 0x7FF8000000000000, float* %41
store float 0.000000e+00, float* %42
%259 = load float, float* %41
%260 = load float, float* %42
%261 = getelementptr inbounds { float, float }, { float, float }* %43, i32 0, i32 0
%262 = getelementptr inbounds { float, float }, { float, float }* %43, i32 0, i32 1
store float %259, float* %261
store float %260, float* %262
%263 = getelementptr inbounds { float, float }, { float, float }* %43, i32 0, i32 0
%264 = load float, float* %263
%265 = getelementptr inbounds { float, float }, { float, float }* %43, i32 0, i32 1
%266 = load float, float* %265
%267 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 0
%268 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 1
store float %264, float* %267
store float %266, float* %268
%269 = bitcast { float, float }* %44 to <2 x float>*
%270 = load <2 x float>, <2 x float>* %269
%271 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %270, double 0x7FF8000000000000, double 0.000000e+00)
%272 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.8, i32 0, i32 0)
%273 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.8, i32 0, i32 1)
%274 = getelementptr inbounds { float, float }, { float, float }* %45, i32 0, i32 0
%275 = getelementptr inbounds { float, float }, { float, float }* %45, i32 0, i32 1
store float %272, float* %274
store float %273, float* %275
%276 = bitcast { float, float }* %45 to <2 x float>*
%277 = load <2 x float>, <2 x float>* %276
%278 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %277, double 0x7FF8000000000000, double 0.000000e+00)
br label %279
279: ; preds = %258
br label %280
280: ; preds = %279
store float 0x7FF8000000000000, float* %46
store float -0.000000e+00, float* %47
%281 = load float, float* %46
%282 = load float, float* %47
%283 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 0
%284 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 1
store float %281, float* %283
store float %282, float* %284
%285 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 0
%286 = load float, float* %285
%287 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 1
%288 = load float, float* %287
%289 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 0
%290 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 1
store float %286, float* %289
store float %288, float* %290
%291 = bitcast { float, float }* %49 to <2 x float>*
%292 = load <2 x float>, <2 x float>* %291
%293 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %292, double 0x7FF8000000000000, double -0.000000e+00)
%294 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.9, i32 0, i32 0)
%295 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.9, i32 0, i32 1)
%296 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 0
%297 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 1
store float %294, float* %296
store float %295, float* %297
%298 = bitcast { float, float }* %50 to <2 x float>*
%299 = load <2 x float>, <2 x float>* %298
%300 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %299, double 0x7FF8000000000000, double -0.000000e+00)
br label %301
301: ; preds = %280
br label %302
302: ; preds = %301
store float 0x7FF8000000000000, float* %51
store float 0x7FF8000000000000, float* %52
%303 = load float, float* %51
%304 = load float, float* %52
%305 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 0
%306 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 1
store float %303, float* %305
store float %304, float* %306
%307 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 0
%308 = load float, float* %307
%309 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 1
%310 = load float, float* %309
%311 = getelementptr inbounds { float, float }, { float, float }* %54, i32 0, i32 0
%312 = getelementptr inbounds { float, float }, { float, float }* %54, i32 0, i32 1
store float %308, float* %311
store float %310, float* %312
%313 = bitcast { float, float }* %54 to <2 x float>*
%314 = load <2 x float>, <2 x float>* %313
%315 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %314, double 0x7FF8000000000000, double 0x7FF8000000000000)
%316 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.10, i32 0, i32 0)
%317 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.10, i32 0, i32 1)
%318 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 0
%319 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 1
store float %316, float* %318
store float %317, float* %319
%320 = bitcast { float, float }* %55 to <2 x float>*
%321 = load <2 x float>, <2 x float>* %320
%322 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %321, double 0x7FF8000000000000, double 0x7FF8000000000000)
br label %323
323: ; preds = %302
br label %324
324: ; preds = %323
store float 0x7FF8000000000000, float* %56
store float 0x7FF0000000000000, float* %57
%325 = load float, float* %56
%326 = load float, float* %57
%327 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 0
%328 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 1
store float %325, float* %327
store float %326, float* %328
%329 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 0
%330 = load float, float* %329
%331 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 1
%332 = load float, float* %331
%333 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 0
%334 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 1
store float %330, float* %333
store float %332, float* %334
%335 = bitcast { float, float }* %59 to <2 x float>*
%336 = load <2 x float>, <2 x float>* %335
%337 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %336, double 0x7FF8000000000000, double 0x7FF0000000000000)
%338 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.11, i32 0, i32 0)
%339 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.11, i32 0, i32 1)
%340 = getelementptr inbounds { float, float }, { float, float }* %60, i32 0, i32 0
%341 = getelementptr inbounds { float, float }, { float, float }* %60, i32 0, i32 1
store float %338, float* %340
store float %339, float* %341
%342 = bitcast { float, float }* %60 to <2 x float>*
%343 = load <2 x float>, <2 x float>* %342
%344 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %343, double 0x7FF8000000000000, double 0x7FF0000000000000)
br label %345
345: ; preds = %324
br label %346
346: ; preds = %345
store float 0x7FF0000000000000, float* %61
store float 0.000000e+00, float* %62
%347 = load float, float* %61
%348 = load float, float* %62
%349 = getelementptr inbounds { float, float }, { float, float }* %63, i32 0, i32 0
%350 = getelementptr inbounds { float, float }, { float, float }* %63, i32 0, i32 1
store float %347, float* %349
store float %348, float* %350
%351 = getelementptr inbounds { float, float }, { float, float }* %63, i32 0, i32 0
%352 = load float, float* %351
%353 = getelementptr inbounds { float, float }, { float, float }* %63, i32 0, i32 1
%354 = load float, float* %353
%355 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 0
%356 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 1
store float %352, float* %355
store float %354, float* %356
%357 = bitcast { float, float }* %64 to <2 x float>*
%358 = load <2 x float>, <2 x float>* %357
%359 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %358, double 0x7FF0000000000000, double 0.000000e+00)
%360 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.12, i32 0, i32 0)
%361 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.12, i32 0, i32 1)
%362 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 0
%363 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 1
store float %360, float* %362
store float %361, float* %363
%364 = bitcast { float, float }* %65 to <2 x float>*
%365 = load <2 x float>, <2 x float>* %364
%366 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %365, double 0x7FF0000000000000, double 0.000000e+00)
br label %367
367: ; preds = %346
br label %368
368: ; preds = %367
store float 0x7FF0000000000000, float* %66
store float -0.000000e+00, float* %67
%369 = load float, float* %66
%370 = load float, float* %67
%371 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 0
%372 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 1
store float %369, float* %371
store float %370, float* %372
%373 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 0
%374 = load float, float* %373
%375 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 1
%376 = load float, float* %375
%377 = getelementptr inbounds { float, float }, { float, float }* %69, i32 0, i32 0
%378 = getelementptr inbounds { float, float }, { float, float }* %69, i32 0, i32 1
store float %374, float* %377
store float %376, float* %378
%379 = bitcast { float, float }* %69 to <2 x float>*
%380 = load <2 x float>, <2 x float>* %379
%381 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %380, double 0x7FF0000000000000, double -0.000000e+00)
%382 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.13, i32 0, i32 0)
%383 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.13, i32 0, i32 1)
%384 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 0
%385 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 1
store float %382, float* %384
store float %383, float* %385
%386 = bitcast { float, float }* %70 to <2 x float>*
%387 = load <2 x float>, <2 x float>* %386
%388 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %387, double 0x7FF0000000000000, double -0.000000e+00)
br label %389
389: ; preds = %368
br label %390
390: ; preds = %389
store float 0x7FF0000000000000, float* %71
store float 0x7FF8000000000000, float* %72
%391 = load float, float* %71
%392 = load float, float* %72
%393 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 0
%394 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 1
store float %391, float* %393
store float %392, float* %394
%395 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 0
%396 = load float, float* %395
%397 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 1
%398 = load float, float* %397
%399 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 0
%400 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 1
store float %396, float* %399
store float %398, float* %400
%401 = bitcast { float, float }* %74 to <2 x float>*
%402 = load <2 x float>, <2 x float>* %401
%403 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %402, double 0x7FF0000000000000, double 0x7FF8000000000000)
%404 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.14, i32 0, i32 0)
%405 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.14, i32 0, i32 1)
%406 = getelementptr inbounds { float, float }, { float, float }* %75, i32 0, i32 0
%407 = getelementptr inbounds { float, float }, { float, float }* %75, i32 0, i32 1
store float %404, float* %406
store float %405, float* %407
%408 = bitcast { float, float }* %75 to <2 x float>*
%409 = load <2 x float>, <2 x float>* %408
%410 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %409, double 0x7FF0000000000000, double 0x7FF8000000000000)
br label %411
411: ; preds = %390
br label %412
412: ; preds = %411
store float 0x7FF0000000000000, float* %76
store float 0x7FF0000000000000, float* %77
%413 = load float, float* %76
%414 = load float, float* %77
%415 = getelementptr inbounds { float, float }, { float, float }* %78, i32 0, i32 0
%416 = getelementptr inbounds { float, float }, { float, float }* %78, i32 0, i32 1
store float %413, float* %415
store float %414, float* %416
%417 = getelementptr inbounds { float, float }, { float, float }* %78, i32 0, i32 0
%418 = load float, float* %417
%419 = getelementptr inbounds { float, float }, { float, float }* %78, i32 0, i32 1
%420 = load float, float* %419
%421 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 0
%422 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 1
store float %418, float* %421
store float %420, float* %422
%423 = bitcast { float, float }* %79 to <2 x float>*
%424 = load <2 x float>, <2 x float>* %423
%425 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %424, double 0x7FF0000000000000, double 0x7FF0000000000000)
%426 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.15, i32 0, i32 0)
%427 = load float, float* getelementptr inbounds ({ float, float }, { float, float }* @check_float.cs.15, i32 0, i32 1)
%428 = getelementptr inbounds { float, float }, { float, float }* %80, i32 0, i32 0
%429 = getelementptr inbounds { float, float }, { float, float }* %80, i32 0, i32 1
store float %426, float* %428
store float %427, float* %429
%430 = bitcast { float, float }* %80 to <2 x float>*
%431 = load <2 x float>, <2 x float>* %430
%432 = call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> %431, double 0x7FF0000000000000, double 0x7FF0000000000000)
br label %433
433: ; preds = %412
br label %434
434: ; preds = %433
ret void
}

LLVM IR (-O2):
define void @check_float() {
%1 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> zeroinitializer, double 0.000000e+00, double 0.000000e+00)
%2 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> zeroinitializer, double 0.000000e+00, double 0.000000e+00)
%3 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0.000000e+00, float -0.000000e+00>, double 0.000000e+00, double -0.000000e+00)
%4 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0.000000e+00, float -0.000000e+00>, double 0.000000e+00, double -0.000000e+00)
%5 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0.000000e+00, float 0x7FF8000000000000>, double 0.000000e+00, double 0x7FF8000000000000)
%6 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0.000000e+00, float 0x7FF8000000000000>, double 0.000000e+00, double 0x7FF8000000000000)
%7 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0.000000e+00, float 0x7FF0000000000000>, double 0.000000e+00, double 0x7FF0000000000000)
%8 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0.000000e+00, float 0x7FF0000000000000>, double 0.000000e+00, double 0x7FF0000000000000)
%9 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float -0.000000e+00, float 0.000000e+00>, double -0.000000e+00, double 0.000000e+00)
%10 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float -0.000000e+00, float 0.000000e+00>, double -0.000000e+00, double 0.000000e+00)
%11 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float -0.000000e+00, float -0.000000e+00>, double -0.000000e+00, double -0.000000e+00)
%12 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float -0.000000e+00, float -0.000000e+00>, double -0.000000e+00, double -0.000000e+00)
%13 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float -0.000000e+00, float 0x7FF8000000000000>, double -0.000000e+00, double 0x7FF8000000000000)
%14 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float -0.000000e+00, float 0x7FF8000000000000>, double -0.000000e+00, double 0x7FF8000000000000)
%15 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float -0.000000e+00, float 0x7FF0000000000000>, double -0.000000e+00, double 0x7FF0000000000000)
%16 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float -0.000000e+00, float 0x7FF0000000000000>, double -0.000000e+00, double 0x7FF0000000000000)
%17 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF8000000000000, float 0.000000e+00>, double 0x7FF8000000000000, double 0.000000e+00)
%18 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF8000000000000, float 0.000000e+00>, double 0x7FF8000000000000, double 0.000000e+00)
%19 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF8000000000000, float -0.000000e+00>, double 0x7FF8000000000000, double -0.000000e+00)
%20 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF8000000000000, float -0.000000e+00>, double 0x7FF8000000000000, double -0.000000e+00)
%21 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, double 0x7FF8000000000000, double 0x7FF8000000000000)
%22 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF8000000000000, float 0x7FF8000000000000>, double 0x7FF8000000000000, double 0x7FF8000000000000)
%23 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF8000000000000, float 0x7FF0000000000000>, double 0x7FF8000000000000, double 0x7FF0000000000000)
%24 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF8000000000000, float 0x7FF0000000000000>, double 0x7FF8000000000000, double 0x7FF0000000000000)
%25 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF0000000000000, float 0.000000e+00>, double 0x7FF0000000000000, double 0.000000e+00)
%26 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF0000000000000, float 0.000000e+00>, double 0x7FF0000000000000, double 0.000000e+00)
%27 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF0000000000000, float -0.000000e+00>, double 0x7FF0000000000000, double -0.000000e+00)
%28 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF0000000000000, float -0.000000e+00>, double 0x7FF0000000000000, double -0.000000e+00)
%29 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF0000000000000, float 0x7FF8000000000000>, double 0x7FF0000000000000, double 0x7FF8000000000000)
%30 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF0000000000000, float 0x7FF8000000000000>, double 0x7FF0000000000000, double 0x7FF8000000000000)
%31 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000>, double 0x7FF0000000000000, double 0x7FF0000000000000)
%32 = tail call i32 (<2 x float>, double, double, ...) bitcast (i32 (...)* @comparecf to i32 (<2 x float>, double, double, ...)*)(<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000>, double 0x7FF0000000000000, double 0x7FF0000000000000)
ret void
}