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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ ctest_assert_fmt(int, char *, int, char *, char *, char *,
                                    char *, char *, double, char *, double);
scalar_t__ ctest_toggle_inversion();
void test_assert_float() {
  float a = 0.0004f, b = 0.0003f, c = 0.0004f;
  do {
    double xv = (a);
    double yv = (c);
    ctest_assert_fmt(
        xv == yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        183,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", "==", "c", "a", xv, "c", yv);
  } while (0);
  do {
    double xv = (a);
    double yv = (b);
    ctest_assert_fmt(
        xv != yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        184,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", "!=", "b", "a", xv, "b", yv);
  } while (0);
  do {
    double xv = (a);
    double yv = (b);
    ctest_assert_fmt(
        xv > yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        185,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", ">", "b", "a", xv, "b", yv);
  } while (0);
  do {
    double xv = (a);
    double yv = (b);
    ctest_assert_fmt(
        xv >= yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        186,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", ">=", "b", "a", xv, "b", yv);
  } while (0);
  do {
    double xv = (a);
    double yv = (c);
    ctest_assert_fmt(
        xv >= yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        187,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", ">=", "c", "a", xv, "c", yv);
  } while (0);
  do {
    double xv = (b);
    double yv = (a);
    ctest_assert_fmt(
        xv < yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        188,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "b", "<", "a", "b", xv, "a", yv);
  } while (0);
  do {
    double xv = (b);
    double yv = (a);
    ctest_assert_fmt(
        xv <= yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        189,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "b", "<=", "a", "b", xv, "a", yv);
  } while (0);
  do {
    double xv = (c);
    double yv = (a);
    ctest_assert_fmt(
        xv <= yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        190,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "c", "<=", "a", "c", xv, "a", yv);
  } while (0);
  while (ctest_toggle_inversion()) {
    do {
      double xv = (a);
      double yv = (b);
      ctest_assert_fmt(xv == yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       193,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "a", "==", "b", "a", xv, "b", yv);
    } while (0);
    do {
      double xv = (a);
      double yv = (c);
      ctest_assert_fmt(xv != yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       194,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "a", "!=", "c", "a", xv, "c", yv);
    } while (0);
    do {
      double xv = (a);
      double yv = (c);
      ctest_assert_fmt(xv > yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       195,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "a", ">", "c", "a", xv, "c", yv);
    } while (0);
    do {
      double xv = (b);
      double yv = (c);
      ctest_assert_fmt(xv > yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       196,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "b", ">", "c", "b", xv, "c", yv);
    } while (0);
    do {
      double xv = (b);
      double yv = (a);
      ctest_assert_fmt(xv >= yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       197,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "b", ">=", "a", "b", xv, "a", yv);
    } while (0);
    do {
      double xv = (c);
      double yv = (a);
      ctest_assert_fmt(xv < yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       198,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "c", "<", "a", "c", xv, "a", yv);
    } while (0);
    do {
      double xv = (c);
      double yv = (b);
      ctest_assert_fmt(xv < yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       199,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "c", "<", "b", "c", xv, "b", yv);
    } while (0);
    do {
      double xv = (a);
      double yv = (b);
      ctest_assert_fmt(xv <= yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       200,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "a", "<=", "b", "a", xv, "b", yv);
    } while (0);
  }
  do {
    double xv = (a);
    double yv = (c);
    ctest_assert_fmt(
        xv == yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        203,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", "==", "c", "a", xv, "c", yv);
  } while (0);
  do {
    double xv = (a);
    double yv = (b);
    ctest_assert_fmt(
        xv != yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        204,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", "!=", "b", "a", xv, "b", yv);
  } while (0);
  do {
    double xv = (a);
    double yv = (b);
    ctest_assert_fmt(
        xv > yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        205,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", ">", "b", "a", xv, "b", yv);
  } while (0);
  do {
    double xv = (a);
    double yv = (b);
    ctest_assert_fmt(
        xv >= yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        206,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", ">=", "b", "a", xv, "b", yv);
  } while (0);
  do {
    double xv = (a);
    double yv = (c);
    ctest_assert_fmt(
        xv >= yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        207,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "a", ">=", "c", "a", xv, "c", yv);
  } while (0);
  do {
    double xv = (b);
    double yv = (a);
    ctest_assert_fmt(
        xv < yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        208,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "b", "<", "a", "b", xv, "a", yv);
  } while (0);
  do {
    double xv = (b);
    double yv = (a);
    ctest_assert_fmt(
        xv <= yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        209,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "b", "<=", "a", "b", xv, "a", yv);
  } while (0);
  do {
    double xv = (c);
    double yv = (a);
    ctest_assert_fmt(
        xv <= yv,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        210,
        "%s %s %s with %s="
        "%lf"
        " and %s="
        "%lf",
        "c", "<=", "a", "c", xv, "a", yv);
  } while (0);
  while (ctest_toggle_inversion()) {
    do {
      double xv = (a);
      double yv = (b);
      ctest_assert_fmt(xv == yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       213,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "a", "==", "b", "a", xv, "b", yv);
    } while (0);
    do {
      double xv = (a);
      double yv = (c);
      ctest_assert_fmt(xv != yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       214,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "a", "!=", "c", "a", xv, "c", yv);
    } while (0);
    do {
      double xv = (a);
      double yv = (c);
      ctest_assert_fmt(xv > yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       215,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "a", ">", "c", "a", xv, "c", yv);
    } while (0);
    do {
      double xv = (b);
      double yv = (c);
      ctest_assert_fmt(xv > yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       216,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "b", ">", "c", "b", xv, "c", yv);
    } while (0);
    do {
      double xv = (b);
      double yv = (a);
      ctest_assert_fmt(xv >= yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       217,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "b", ">=", "a", "b", xv, "a", yv);
    } while (0);
    do {
      double xv = (c);
      double yv = (a);
      ctest_assert_fmt(xv < yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       218,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "c", "<", "a", "c", xv, "a", yv);
    } while (0);
    do {
      double xv = (c);
      double yv = (b);
      ctest_assert_fmt(xv < yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       219,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "c", "<", "b", "c", xv, "b", yv);
    } while (0);
    do {
      double xv = (a);
      double yv = (b);
      ctest_assert_fmt(xv <= yv,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       220,
                       "%s %s %s with %s="
                       "%lf"
                       " and %s="
                       "%lf",
                       "a", "<=", "b", "a", xv, "b", yv);
    } while (0);
  }
}


x86 assembly (clang, -O0):
<test_assert_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0x230,%rsp
movss  0x1ecd(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  0x1ec4(%rip),%xmm0
movss  %xmm0,-0x8(%rbp)
movss  0x1eb3(%rip),%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
lea    0x1e72(%rip),%rsi
mov    $0xb7,%edx
lea    0x1eeb(%rip),%rcx
lea    0x1f04(%rip),%r10
lea    0x1eff(%rip),%r9
lea    0x1ed4(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    11d2 <test_assert_float+0xb2>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x28(%rbp),%xmm0
ucomisd -0x30(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x28(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
lea    0x1df2(%rip),%rsi
mov    $0xb8,%edx
lea    0x1e6b(%rip),%rcx
lea    0x1e84(%rip),%r10
lea    0x1e82(%rip),%r9
lea    0x1e7e(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1252 <test_assert_float+0x132>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
lea    0x1d77(%rip),%rsi
mov    $0xb9,%edx
lea    0x1df0(%rip),%rcx
lea    0x1e09(%rip),%r10
lea    0x1e0c(%rip),%r9
lea    0x1e03(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    12cd <test_assert_float+0x1ad>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
lea    0x1cfc(%rip),%rsi
mov    $0xba,%edx
lea    0x1d75(%rip),%rcx
lea    0x1d8e(%rip),%r10
lea    0x1d93(%rip),%r9
lea    0x1d88(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1348 <test_assert_float+0x228>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x60(%rbp),%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
lea    0x1c81(%rip),%rsi
mov    $0xbb,%edx
lea    0x1cfa(%rip),%rcx
lea    0x1d13(%rip),%r10
lea    0x1d18(%rip),%r9
lea    0x1ce3(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    13c3 <test_assert_float+0x2a3>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
lea    0x1c02(%rip),%rsi
mov    $0xbc,%edx
lea    0x1c7b(%rip),%rcx
lea    0x1c9c(%rip),%r10
lea    0x1c9c(%rip),%r9
lea    0x1c86(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1442 <test_assert_float+0x322>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
lea    0x1b83(%rip),%rsi
mov    $0xbd,%edx
lea    0x1bfc(%rip),%rcx
lea    0x1c1d(%rip),%r10
lea    0x1c1f(%rip),%r9
lea    0x1c07(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    14c1 <test_assert_float+0x3a1>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
lea    0x1af2(%rip),%rsi
mov    $0xbe,%edx
lea    0x1b6b(%rip),%rcx
lea    0x1b62(%rip),%r10
lea    0x1b8e(%rip),%r9
lea    0x1b76(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1552 <test_assert_float+0x432>
mov    $0x0,%al
call   1040 <ctest_toggle_inversion@plt>
cmp    $0x0,%rax
je     19e6 <test_assert_float+0x8c6>
jmp    1568 <test_assert_float+0x448>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
lea    0x1a4a(%rip),%rsi
mov    $0xc1,%edx
lea    0x1ac3(%rip),%rcx
lea    0x1adc(%rip),%r10
lea    0x1ad7(%rip),%r9
lea    0x1ad6(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    15fa <test_assert_float+0x4da>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
setne  %al
setp   %cl
or     %cl,%al
and    $0x1,%al
movzbl %al,%edi
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
lea    0x19b8(%rip),%rsi
mov    $0xc2,%edx
lea    0x1a31(%rip),%rcx
lea    0x1a4a(%rip),%r10
lea    0x1a48(%rip),%r9
lea    0x1a1a(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    168c <test_assert_float+0x56c>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
ucomisd -0xc0(%rbp),%xmm0
ff
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
lea    0x192b(%rip),%rsi
mov    $0xc3,%edx
lea    0x19a4(%rip),%rcx
lea    0x19bd(%rip),%r10
lea    0x19c0(%rip),%r9
lea    0x198d(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1719 <test_assert_float+0x5f9>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
ucomisd -0xd0(%rbp),%xmm0
ff
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
lea    0x189e(%rip),%rsi
mov    $0xc4,%edx
lea    0x1917(%rip),%rcx
lea    0x1938(%rip),%r10
lea    0x1933(%rip),%r9
lea    0x1900(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    17a6 <test_assert_float+0x686>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd -0xe0(%rbp),%xmm0
ff
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
lea    0x1811(%rip),%rsi
mov    $0xc5,%edx
lea    0x188a(%rip),%rcx
lea    0x18ab(%rip),%r10
lea    0x18a8(%rip),%r9
lea    0x1895(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1833 <test_assert_float+0x713>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm1
ff
movsd  -0xf0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm1
ff
lea    0x1780(%rip),%rsi
mov    $0xc6,%edx
lea    0x17f9(%rip),%rcx
lea    0x17f0(%rip),%r10
lea    0x181a(%rip),%r9
lea    0x1804(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    18c4 <test_assert_float+0x7a4>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm1
ff
lea    0x16ef(%rip),%rsi
mov    $0xc7,%edx
lea    0x1768(%rip),%rcx
lea    0x175f(%rip),%r10
lea    0x1789(%rip),%r9
lea    0x177b(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1955 <test_assert_float+0x835>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x108(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
lea    0x165e(%rip),%rsi
mov    $0xc8,%edx
lea    0x16d7(%rip),%rcx
lea    0x16f0(%rip),%r10
lea    0x16fa(%rip),%r9
lea    0x16ea(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1552 <test_assert_float+0x432>
jmp    19eb <test_assert_float+0x8cb>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
ucomisd -0x120(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
lea    0x15c7(%rip),%rsi
mov    $0xcb,%edx
lea    0x1640(%rip),%rcx
lea    0x1659(%rip),%r10
lea    0x1654(%rip),%r9
lea    0x1629(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1a7d <test_assert_float+0x95d>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
ucomisd -0x130(%rbp),%xmm0
ff
setne  %al
setp   %cl
or     %cl,%al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm1
ff
lea    0x1535(%rip),%rsi
mov    $0xcc,%edx
lea    0x15ae(%rip),%rcx
lea    0x15c7(%rip),%r10
lea    0x15c5(%rip),%r9
lea    0x15c1(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1b0f <test_assert_float+0x9ef>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
ucomisd -0x140(%rbp),%xmm0
ff
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm1
ff
lea    0x14a8(%rip),%rsi
mov    $0xcd,%edx
lea    0x1521(%rip),%rcx
lea    0x153a(%rip),%r10
lea    0x153d(%rip),%r9
lea    0x1534(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1b9c <test_assert_float+0xa7c>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd -0x150(%rbp),%xmm0
ff
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x148(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm1
ff
lea    0x141b(%rip),%rsi
mov    $0xce,%edx
lea    0x1494(%rip),%rcx
lea    0x14ad(%rip),%r10
lea    0x14b2(%rip),%r9
lea    0x14a7(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1c29 <test_assert_float+0xb09>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
ucomisd -0x160(%rbp),%xmm0
ff
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x158(%rbp),%xmm0
ff
movsd  -0x160(%rbp),%xmm1
ff
lea    0x138e(%rip),%rsi
mov    $0xcf,%edx
lea    0x1407(%rip),%rcx
lea    0x1420(%rip),%r10
lea    0x1425(%rip),%r9
lea    0x13f0(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1cb6 <test_assert_float+0xb96>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x168(%rbp),%xmm1
ff
movsd  -0x170(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x168(%rbp),%xmm0
ff
movsd  -0x170(%rbp),%xmm1
ff
lea    0x12fd(%rip),%rsi
mov    $0xd0,%edx
lea    0x1376(%rip),%rcx
lea    0x1397(%rip),%r10
lea    0x1397(%rip),%r9
lea    0x1381(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1d47 <test_assert_float+0xc27>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x178(%rbp),%xmm1
ff
movsd  -0x180(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x178(%rbp),%xmm0
ff
movsd  -0x180(%rbp),%xmm1
ff
lea    0x126c(%rip),%rsi
mov    $0xd1,%edx
lea    0x12e5(%rip),%rcx
lea    0x1306(%rip),%r10
lea    0x1308(%rip),%r9
lea    0x12f0(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1dd8 <test_assert_float+0xcb8>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x188(%rbp),%xmm1
ff
movsd  -0x190(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x188(%rbp),%xmm0
ff
movsd  -0x190(%rbp),%xmm1
ff
lea    0x11db(%rip),%rsi
mov    $0xd2,%edx
lea    0x1254(%rip),%rcx
lea    0x124b(%rip),%r10
lea    0x1277(%rip),%r9
lea    0x125f(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1e69 <test_assert_float+0xd49>
mov    $0x0,%al
call   1040 <ctest_toggle_inversion@plt>
cmp    $0x0,%rax
je     22fd <test_assert_float+0x11dd>
jmp    1e7f <test_assert_float+0xd5f>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
ucomisd -0x1a0(%rbp),%xmm0
ff
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x198(%rbp),%xmm0
ff
movsd  -0x1a0(%rbp),%xmm1
ff
lea    0x1133(%rip),%rsi
mov    $0xd5,%edx
lea    0x11ac(%rip),%rcx
lea    0x11c5(%rip),%r10
lea    0x11c0(%rip),%r9
lea    0x11bf(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1f11 <test_assert_float+0xdf1>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm0
ff
ucomisd -0x1b0(%rbp),%xmm0
ff
setne  %al
setp   %cl
or     %cl,%al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x1a8(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm1
ff
lea    0x10a1(%rip),%rsi
mov    $0xd6,%edx
lea    0x111a(%rip),%rcx
lea    0x1133(%rip),%r10
lea    0x1131(%rip),%r9
lea    0x1103(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1fa3 <test_assert_float+0xe83>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
ucomisd -0x1c0(%rbp),%xmm0
ff
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  -0x1c0(%rbp),%xmm1
ff
lea    0x1014(%rip),%rsi
mov    $0xd7,%edx
lea    0x108d(%rip),%rcx
lea    0x10a6(%rip),%r10
lea    0x10a9(%rip),%r9
lea    0x1076(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    2030 <test_assert_float+0xf10>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
ucomisd -0x1d0(%rbp),%xmm0
ff
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x1d0(%rbp),%xmm1
ff
lea    0xf87(%rip),%rsi
mov    $0xd8,%edx
lea    0x1000(%rip),%rcx
lea    0x1021(%rip),%r10
lea    0x101c(%rip),%r9
lea    0xfe9(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    20bd <test_assert_float+0xf9d>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
ucomisd -0x1e0(%rbp),%xmm0
ff
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  -0x1e0(%rbp),%xmm1
ff
lea    0xefa(%rip),%rsi
mov    $0xd9,%edx
lea    0xf73(%rip),%rcx
lea    0xf94(%rip),%r10
lea    0xf91(%rip),%r9
lea    0xf7e(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    214a <test_assert_float+0x102a>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm1
ff
movsd  -0x1f0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x1e8(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm1
ff
lea    0xe69(%rip),%rsi
mov    $0xda,%edx
lea    0xee2(%rip),%rcx
lea    0xed9(%rip),%r10
lea    0xf03(%rip),%r9
lea    0xeed(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    21db <test_assert_float+0x10bb>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x1f8(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  -0x200(%rbp),%xmm1
ff
lea    0xdd8(%rip),%rsi
mov    $0xdb,%edx
lea    0xe51(%rip),%rcx
lea    0xe48(%rip),%r10
lea    0xe72(%rip),%r9
lea    0xe64(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    226c <test_assert_float+0x114c>
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x208(%rbp),%xmm1
ff
movsd  -0x210(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
movsd  -0x208(%rbp),%xmm0
ff
movsd  -0x210(%rbp),%xmm1
ff
lea    0xd47(%rip),%rsi
mov    $0xdc,%edx
lea    0xdc0(%rip),%rcx
lea    0xdd9(%rip),%r10
lea    0xde3(%rip),%r9
lea    0xdd3(%rip),%rax
mov    %r10,%r8
mov    %rax,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <ctest_assert_fmt@plt>
jmp    1e69 <test_assert_float+0xd49>
add    $0x230,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_assert_float>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
sub    $0x8,%rsp
lea    0xf5d(%rip),%r14
lea    0xf78(%rip),%r12
lea    0xecc(%rip),%rbp
lea    0xf4a(%rip),%r13
lea    0xf65(%rip),%r9
movsd  0xea6(%rip),%xmm0
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xb7,%edx
mov    %r13,%rcx
mov    %r12,%r8
movaps %xmm0,%xmm1
push   %r14
push   %r12
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xf37(%rip),%r15
lea    0xf2d(%rip),%r9
movsd  0xe73(%rip),%xmm1
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xb8,%edx
mov    %r13,%rcx
mov    %r12,%r8
movsd  0xe50(%rip),%xmm0
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xef9(%rip),%r9
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xb9,%edx
mov    %r13,%rcx
mov    %r12,%r8
movsd  0xe1f(%rip),%xmm0
movsd  0xe1f(%rip),%xmm1
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xec2(%rip),%rbx
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xba,%edx
mov    %r13,%rcx
mov    %r12,%r8
mov    %rbx,%r9
movsd  0xde3(%rip),%xmm0
movsd  0xde3(%rip),%xmm1
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xbb,%edx
mov    %r13,%rcx
mov    %r12,%r8
mov    %rbx,%r9
movsd  0xdae(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r14
push   %r12
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xe59(%rip),%r9
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xbc,%edx
mov    %r13,%rcx
mov    %r15,%r8
movsd  0xd82(%rip),%xmm0
movsd  0xd72(%rip),%xmm1
push   %r12
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xe22(%rip),%rbx
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xbd,%edx
mov    %r13,%rcx
mov    %r15,%r8
mov    %rbx,%r9
movsd  0xd46(%rip),%xmm0
movsd  0xd36(%rip),%xmm1
push   %r12
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xbe,%edx
mov    %r13,%rcx
mov    %r14,%r8
mov    %rbx,%r9
movsd  0xd09(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r12
push   %r14
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x20,%rsp
xor    %eax,%eax
call   1040 <ctest_toggle_inversion@plt>
test   %rax,%rax
je     14e3 <test_assert_float+0x3c3>
lea    0xcf0(%rip),%r13
lea    0xd6e(%rip),%rbx
nopw   0x0(%rax,%rax,1)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xc1,%edx
mov    %rbx,%rcx
mov    %r12,%r8
lea    0xd6c(%rip),%r9
movsd  0xcad(%rip),%xmm0
movsd  0xcad(%rip),%xmm1
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xc2,%edx
mov    %rbx,%rcx
mov    %r12,%r8
lea    0xd39(%rip),%r9
movsd  0xc77(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r14
push   %r12
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xc3,%edx
mov    %rbx,%rcx
mov    %r12,%r8
lea    0xd0d(%rip),%rbp
mov    %rbp,%r9
movsd  0xc43(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r14
push   %r12
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xc4,%edx
mov    %rbx,%rcx
mov    %r15,%r8
mov    %rbp,%r9
movsd  0xc1e(%rip),%xmm0
movsd  0xc0e(%rip),%xmm1
push   %r14
push   %r15
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xc5,%edx
mov    %rbx,%rcx
mov    %r15,%r8
lea    0xca9(%rip),%r9
movsd  0xbe8(%rip),%xmm0
movsd  0xbd8(%rip),%xmm1
push   %r12
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xc6,%edx
mov    %rbx,%rcx
mov    %r14,%r8
lea    0xc76(%rip),%rbp
mov    %rbp,%r9
movsd  0xba7(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r12
push   %r14
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xc7,%edx
mov    %rbx,%rcx
mov    %r14,%r8
mov    %rbp,%r9
movsd  0xb7a(%rip),%xmm0
movsd  0xb7a(%rip),%xmm1
push   %r15
push   %r14
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xc8,%edx
mov    %rbx,%rcx
mov    %r12,%r8
lea    0xc12(%rip),%r9
movsd  0xb44(%rip),%xmm0
movsd  0xb44(%rip),%xmm1
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x20,%rsp
xor    %eax,%eax
call   1040 <ctest_toggle_inversion@plt>
test   %rax,%rax
jne    1330 <test_assert_float+0x210>
sub    $0x8,%rsp
lea    0xb22(%rip),%rbp
lea    0xba0(%rip),%r13
lea    0xbbb(%rip),%r9
movsd  0xafc(%rip),%xmm0
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xcb,%edx
mov    %r13,%rcx
mov    %r12,%r8
movaps %xmm0,%xmm1
push   %r14
push   %r12
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xb8a(%rip),%r9
movsd  0xad0(%rip),%xmm1
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xcc,%edx
mov    %r13,%rcx
mov    %r12,%r8
movsd  0xaad(%rip),%xmm0
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xb56(%rip),%r9
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xcd,%edx
mov    %r13,%rcx
mov    %r12,%r8
movsd  0xa7c(%rip),%xmm0
movsd  0xa7c(%rip),%xmm1
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xb1f(%rip),%rbx
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xce,%edx
mov    %r13,%rcx
mov    %r12,%r8
mov    %rbx,%r9
movsd  0xa40(%rip),%xmm0
movsd  0xa40(%rip),%xmm1
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xcf,%edx
mov    %r13,%rcx
mov    %r12,%r8
mov    %rbx,%r9
movsd  0xa0b(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r14
push   %r12
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xab6(%rip),%r9
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xd0,%edx
mov    %r13,%rcx
mov    %r15,%r8
movsd  0x9df(%rip),%xmm0
movsd  0x9cf(%rip),%xmm1
push   %r12
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
lea    0xa7f(%rip),%rbx
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xd1,%edx
mov    %r13,%rcx
mov    %r15,%r8
mov    %rbx,%r9
movsd  0x9a3(%rip),%xmm0
movsd  0x993(%rip),%xmm1
push   %r12
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
mov    $0x1,%edi
mov    %rbp,%rsi
mov    $0xd2,%edx
mov    %r13,%rcx
mov    %r14,%r8
mov    %rbx,%r9
movsd  0x966(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r12
push   %r14
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x20,%rsp
xor    %eax,%eax
call   1040 <ctest_toggle_inversion@plt>
test   %rax,%rax
je     1883 <test_assert_float+0x763>
lea    0x94d(%rip),%r13
lea    0x9cb(%rip),%rbx
nopw   0x0(%rax,%rax,1)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xd5,%edx
mov    %rbx,%rcx
mov    %r12,%r8
lea    0x9cc(%rip),%r9
movsd  0x90d(%rip),%xmm0
movsd  0x90d(%rip),%xmm1
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xd6,%edx
mov    %rbx,%rcx
mov    %r12,%r8
lea    0x999(%rip),%r9
movsd  0x8d7(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r14
push   %r12
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xd7,%edx
mov    %rbx,%rcx
mov    %r12,%r8
lea    0x96d(%rip),%rbp
mov    %rbp,%r9
movsd  0x8a3(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r14
push   %r12
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xd8,%edx
mov    %rbx,%rcx
mov    %r15,%r8
mov    %rbp,%r9
movsd  0x87e(%rip),%xmm0
movsd  0x86e(%rip),%xmm1
push   %r14
push   %r15
push   %r14
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xd9,%edx
mov    %rbx,%rcx
mov    %r15,%r8
lea    0x909(%rip),%r9
movsd  0x848(%rip),%xmm0
movsd  0x838(%rip),%xmm1
push   %r12
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xda,%edx
mov    %rbx,%rcx
mov    %r14,%r8
lea    0x8d6(%rip),%rbp
mov    %rbp,%r9
movsd  0x807(%rip),%xmm0
movaps %xmm0,%xmm1
push   %r12
push   %r14
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xdb,%edx
mov    %rbx,%rcx
mov    %r14,%r8
mov    %rbp,%r9
movsd  0x7da(%rip),%xmm0
movsd  0x7da(%rip),%xmm1
push   %r15
push   %r14
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x18,%rsp
xor    %edi,%edi
mov    %r13,%rsi
mov    $0xdc,%edx
mov    %rbx,%rcx
mov    %r12,%r8
lea    0x872(%rip),%r9
movsd  0x7a4(%rip),%xmm0
movsd  0x7a4(%rip),%xmm1
push   %r15
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x20,%rsp
xor    %eax,%eax
call   1040 <ctest_toggle_inversion@plt>
test   %rax,%rax
jne    16d0 <test_assert_float+0x5b0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [133 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c\00"
@.str.1 = [32 x i8] c"%s %s %s with %s=%lf and %s=%lf\00"
@.str.2 = [2 x i8] c"a\00"
@.str.3 = [3 x i8] c"==\00"
@.str.4 = [2 x i8] c"c\00"
@.str.5 = [3 x i8] c"!=\00"
@.str.6 = [2 x i8] c"b\00"
@.str.7 = [2 x i8] c">\00"
@.str.8 = [3 x i8] c">=\00"
@.str.9 = [2 x i8] c"<\00"
@.str.10 = [3 x i8] c"<=\00"
define void @test_assert_float() {
%1 = alloca float
%2 = alloca float
%3 = alloca float
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
store float 0x3F3A36E2E0000000, float* %1
store float 0x3F33A92A40000000, float* %2
store float 0x3F3A36E2E0000000, float* %3
br label %68
68: ; preds = %0
%69 = load float, float* %1
%70 = fpext float %69 to double
store double %70, double* %4
%71 = load float, float* %3
%72 = fpext float %71 to double
store double %72, double* %5
%73 = load double, double* %4
%74 = load double, double* %5
%75 = fcmp oeq double %73, %74
%76 = zext i1 %75 to i32
%77 = load double, double* %4
%78 = load double, double* %5
%79 = call i32 @ctest_assert_fmt(i32 %76, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 183, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %77, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %78)
br label %80
80: ; preds = %68
br label %81
81: ; preds = %80
%82 = load float, float* %1
%83 = fpext float %82 to double
store double %83, double* %6
%84 = load float, float* %2
%85 = fpext float %84 to double
store double %85, double* %7
%86 = load double, double* %6
%87 = load double, double* %7
%88 = fcmp une double %86, %87
%89 = zext i1 %88 to i32
%90 = load double, double* %6
%91 = load double, double* %7
%92 = call i32 @ctest_assert_fmt(i32 %89, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 184, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %90, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %91)
br label %93
93: ; preds = %81
br label %94
94: ; preds = %93
%95 = load float, float* %1
%96 = fpext float %95 to double
store double %96, double* %8
%97 = load float, float* %2
%98 = fpext float %97 to double
store double %98, double* %9
%99 = load double, double* %8
%100 = load double, double* %9
%101 = fcmp ogt double %99, %100
%102 = zext i1 %101 to i32
%103 = load double, double* %8
%104 = load double, double* %9
%105 = call i32 @ctest_assert_fmt(i32 %102, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 185, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %103, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %104)
br label %106
106: ; preds = %94
br label %107
107: ; preds = %106
%108 = load float, float* %1
%109 = fpext float %108 to double
store double %109, double* %10
%110 = load float, float* %2
%111 = fpext float %110 to double
store double %111, double* %11
%112 = load double, double* %10
%113 = load double, double* %11
%114 = fcmp oge double %112, %113
%115 = zext i1 %114 to i32
%116 = load double, double* %10
%117 = load double, double* %11
%118 = call i32 @ctest_assert_fmt(i32 %115, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 186, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %116, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %117)
br label %119
119: ; preds = %107
br label %120
120: ; preds = %119
%121 = load float, float* %1
%122 = fpext float %121 to double
store double %122, double* %12
%123 = load float, float* %3
%124 = fpext float %123 to double
store double %124, double* %13
%125 = load double, double* %12
%126 = load double, double* %13
%127 = fcmp oge double %125, %126
%128 = zext i1 %127 to i32
%129 = load double, double* %12
%130 = load double, double* %13
%131 = call i32 @ctest_assert_fmt(i32 %128, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 187, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %129, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %130)
br label %132
132: ; preds = %120
br label %133
133: ; preds = %132
%134 = load float, float* %2
%135 = fpext float %134 to double
store double %135, double* %14
%136 = load float, float* %1
%137 = fpext float %136 to double
store double %137, double* %15
%138 = load double, double* %14
%139 = load double, double* %15
%140 = fcmp olt double %138, %139
%141 = zext i1 %140 to i32
%142 = load double, double* %14
%143 = load double, double* %15
%144 = call i32 @ctest_assert_fmt(i32 %141, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 188, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %142, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %143)
br label %145
145: ; preds = %133
br label %146
146: ; preds = %145
%147 = load float, float* %2
%148 = fpext float %147 to double
store double %148, double* %16
%149 = load float, float* %1
%150 = fpext float %149 to double
store double %150, double* %17
%151 = load double, double* %16
%152 = load double, double* %17
%153 = fcmp ole double %151, %152
%154 = zext i1 %153 to i32
%155 = load double, double* %16
%156 = load double, double* %17
%157 = call i32 @ctest_assert_fmt(i32 %154, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 189, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %155, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %156)
br label %158
158: ; preds = %146
br label %159
159: ; preds = %158
%160 = load float, float* %3
%161 = fpext float %160 to double
store double %161, double* %18
%162 = load float, float* %1
%163 = fpext float %162 to double
store double %163, double* %19
%164 = load double, double* %18
%165 = load double, double* %19
%166 = fcmp ole double %164, %165
%167 = zext i1 %166 to i32
%168 = load double, double* %18
%169 = load double, double* %19
%170 = call i32 @ctest_assert_fmt(i32 %167, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 190, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %168, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %169)
br label %171
171: ; preds = %159
br label %172
172: ; preds = %279, %171
%173 = call i64 (...) @ctest_toggle_inversion()
%174 = icmp ne i64 %173, 0
br i1 %174, label %175, label %280
175: ; preds = %172
br label %176
176: ; preds = %175
%177 = load float, float* %1
%178 = fpext float %177 to double
store double %178, double* %20
%179 = load float, float* %2
%180 = fpext float %179 to double
store double %180, double* %21
%181 = load double, double* %20
%182 = load double, double* %21
%183 = fcmp oeq double %181, %182
%184 = zext i1 %183 to i32
%185 = load double, double* %20
%186 = load double, double* %21
%187 = call i32 @ctest_assert_fmt(i32 %184, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 193, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %185, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %186)
br label %188
188: ; preds = %176
br label %189
189: ; preds = %188
%190 = load float, float* %1
%191 = fpext float %190 to double
store double %191, double* %22
%192 = load float, float* %3
%193 = fpext float %192 to double
store double %193, double* %23
%194 = load double, double* %22
%195 = load double, double* %23
%196 = fcmp une double %194, %195
%197 = zext i1 %196 to i32
%198 = load double, double* %22
%199 = load double, double* %23
%200 = call i32 @ctest_assert_fmt(i32 %197, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 194, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %198, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %199)
br label %201
201: ; preds = %189
br label %202
202: ; preds = %201
%203 = load float, float* %1
%204 = fpext float %203 to double
store double %204, double* %24
%205 = load float, float* %3
%206 = fpext float %205 to double
store double %206, double* %25
%207 = load double, double* %24
%208 = load double, double* %25
%209 = fcmp ogt double %207, %208
%210 = zext i1 %209 to i32
%211 = load double, double* %24
%212 = load double, double* %25
%213 = call i32 @ctest_assert_fmt(i32 %210, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 195, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %211, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %212)
br label %214
214: ; preds = %202
br label %215
215: ; preds = %214
%216 = load float, float* %2
%217 = fpext float %216 to double
store double %217, double* %26
%218 = load float, float* %3
%219 = fpext float %218 to double
store double %219, double* %27
%220 = load double, double* %26
%221 = load double, double* %27
%222 = fcmp ogt double %220, %221
%223 = zext i1 %222 to i32
%224 = load double, double* %26
%225 = load double, double* %27
%226 = call i32 @ctest_assert_fmt(i32 %223, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 196, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %224, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %225)
br label %227
227: ; preds = %215
br label %228
228: ; preds = %227
%229 = load float, float* %2
%230 = fpext float %229 to double
store double %230, double* %28
%231 = load float, float* %1
%232 = fpext float %231 to double
store double %232, double* %29
%233 = load double, double* %28
%234 = load double, double* %29
%235 = fcmp oge double %233, %234
%236 = zext i1 %235 to i32
%237 = load double, double* %28
%238 = load double, double* %29
%239 = call i32 @ctest_assert_fmt(i32 %236, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 197, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %237, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %238)
br label %240
240: ; preds = %228
br label %241
241: ; preds = %240
%242 = load float, float* %3
%243 = fpext float %242 to double
store double %243, double* %30
%244 = load float, float* %1
%245 = fpext float %244 to double
store double %245, double* %31
%246 = load double, double* %30
%247 = load double, double* %31
%248 = fcmp olt double %246, %247
%249 = zext i1 %248 to i32
%250 = load double, double* %30
%251 = load double, double* %31
%252 = call i32 @ctest_assert_fmt(i32 %249, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 198, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %250, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %251)
br label %253
253: ; preds = %241
br label %254
254: ; preds = %253
%255 = load float, float* %3
%256 = fpext float %255 to double
store double %256, double* %32
%257 = load float, float* %2
%258 = fpext float %257 to double
store double %258, double* %33
%259 = load double, double* %32
%260 = load double, double* %33
%261 = fcmp olt double %259, %260
%262 = zext i1 %261 to i32
%263 = load double, double* %32
%264 = load double, double* %33
%265 = call i32 @ctest_assert_fmt(i32 %262, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 199, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %263, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %264)
br label %266
266: ; preds = %254
br label %267
267: ; preds = %266
%268 = load float, float* %1
%269 = fpext float %268 to double
store double %269, double* %34
%270 = load float, float* %2
%271 = fpext float %270 to double
store double %271, double* %35
%272 = load double, double* %34
%273 = load double, double* %35
%274 = fcmp ole double %272, %273
%275 = zext i1 %274 to i32
%276 = load double, double* %34
%277 = load double, double* %35
%278 = call i32 @ctest_assert_fmt(i32 %275, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 200, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %276, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %277)
br label %279
279: ; preds = %267
br label %172
280: ; preds = %172
br label %281
281: ; preds = %280
%282 = load float, float* %1
%283 = fpext float %282 to double
store double %283, double* %36
%284 = load float, float* %3
%285 = fpext float %284 to double
store double %285, double* %37
%286 = load double, double* %36
%287 = load double, double* %37
%288 = fcmp oeq double %286, %287
%289 = zext i1 %288 to i32
%290 = load double, double* %36
%291 = load double, double* %37
%292 = call i32 @ctest_assert_fmt(i32 %289, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 203, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %290, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %291)
br label %293
293: ; preds = %281
br label %294
294: ; preds = %293
%295 = load float, float* %1
%296 = fpext float %295 to double
store double %296, double* %38
%297 = load float, float* %2
%298 = fpext float %297 to double
store double %298, double* %39
%299 = load double, double* %38
%300 = load double, double* %39
%301 = fcmp une double %299, %300
%302 = zext i1 %301 to i32
%303 = load double, double* %38
%304 = load double, double* %39
%305 = call i32 @ctest_assert_fmt(i32 %302, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 204, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %303, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %304)
br label %306
306: ; preds = %294
br label %307
307: ; preds = %306
%308 = load float, float* %1
%309 = fpext float %308 to double
store double %309, double* %40
%310 = load float, float* %2
%311 = fpext float %310 to double
store double %311, double* %41
%312 = load double, double* %40
%313 = load double, double* %41
%314 = fcmp ogt double %312, %313
%315 = zext i1 %314 to i32
%316 = load double, double* %40
%317 = load double, double* %41
%318 = call i32 @ctest_assert_fmt(i32 %315, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 205, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %316, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %317)
br label %319
319: ; preds = %307
br label %320
320: ; preds = %319
%321 = load float, float* %1
%322 = fpext float %321 to double
store double %322, double* %42
%323 = load float, float* %2
%324 = fpext float %323 to double
store double %324, double* %43
%325 = load double, double* %42
%326 = load double, double* %43
%327 = fcmp oge double %325, %326
%328 = zext i1 %327 to i32
%329 = load double, double* %42
%330 = load double, double* %43
%331 = call i32 @ctest_assert_fmt(i32 %328, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 206, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %329, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %330)
br label %332
332: ; preds = %320
br label %333
333: ; preds = %332
%334 = load float, float* %1
%335 = fpext float %334 to double
store double %335, double* %44
%336 = load float, float* %3
%337 = fpext float %336 to double
store double %337, double* %45
%338 = load double, double* %44
%339 = load double, double* %45
%340 = fcmp oge double %338, %339
%341 = zext i1 %340 to i32
%342 = load double, double* %44
%343 = load double, double* %45
%344 = call i32 @ctest_assert_fmt(i32 %341, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 207, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %342, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %343)
br label %345
345: ; preds = %333
br label %346
346: ; preds = %345
%347 = load float, float* %2
%348 = fpext float %347 to double
store double %348, double* %46
%349 = load float, float* %1
%350 = fpext float %349 to double
store double %350, double* %47
%351 = load double, double* %46
%352 = load double, double* %47
%353 = fcmp olt double %351, %352
%354 = zext i1 %353 to i32
%355 = load double, double* %46
%356 = load double, double* %47
%357 = call i32 @ctest_assert_fmt(i32 %354, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 208, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %355, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %356)
br label %358
358: ; preds = %346
br label %359
359: ; preds = %358
%360 = load float, float* %2
%361 = fpext float %360 to double
store double %361, double* %48
%362 = load float, float* %1
%363 = fpext float %362 to double
store double %363, double* %49
%364 = load double, double* %48
%365 = load double, double* %49
%366 = fcmp ole double %364, %365
%367 = zext i1 %366 to i32
%368 = load double, double* %48
%369 = load double, double* %49
%370 = call i32 @ctest_assert_fmt(i32 %367, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 209, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %368, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %369)
br label %371
371: ; preds = %359
br label %372
372: ; preds = %371
%373 = load float, float* %3
%374 = fpext float %373 to double
store double %374, double* %50
%375 = load float, float* %1
%376 = fpext float %375 to double
store double %376, double* %51
%377 = load double, double* %50
%378 = load double, double* %51
%379 = fcmp ole double %377, %378
%380 = zext i1 %379 to i32
%381 = load double, double* %50
%382 = load double, double* %51
%383 = call i32 @ctest_assert_fmt(i32 %380, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 210, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %381, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %382)
br label %384
384: ; preds = %372
br label %385
385: ; preds = %492, %384
%386 = call i64 (...) @ctest_toggle_inversion()
%387 = icmp ne i64 %386, 0
br i1 %387, label %388, label %493
388: ; preds = %385
br label %389
389: ; preds = %388
%390 = load float, float* %1
%391 = fpext float %390 to double
store double %391, double* %52
%392 = load float, float* %2
%393 = fpext float %392 to double
store double %393, double* %53
%394 = load double, double* %52
%395 = load double, double* %53
%396 = fcmp oeq double %394, %395
%397 = zext i1 %396 to i32
%398 = load double, double* %52
%399 = load double, double* %53
%400 = call i32 @ctest_assert_fmt(i32 %397, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 213, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %398, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %399)
br label %401
401: ; preds = %389
br label %402
402: ; preds = %401
%403 = load float, float* %1
%404 = fpext float %403 to double
store double %404, double* %54
%405 = load float, float* %3
%406 = fpext float %405 to double
store double %406, double* %55
%407 = load double, double* %54
%408 = load double, double* %55
%409 = fcmp une double %407, %408
%410 = zext i1 %409 to i32
%411 = load double, double* %54
%412 = load double, double* %55
%413 = call i32 @ctest_assert_fmt(i32 %410, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 214, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %411, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %412)
br label %414
414: ; preds = %402
br label %415
415: ; preds = %414
%416 = load float, float* %1
%417 = fpext float %416 to double
store double %417, double* %56
%418 = load float, float* %3
%419 = fpext float %418 to double
store double %419, double* %57
%420 = load double, double* %56
%421 = load double, double* %57
%422 = fcmp ogt double %420, %421
%423 = zext i1 %422 to i32
%424 = load double, double* %56
%425 = load double, double* %57
%426 = call i32 @ctest_assert_fmt(i32 %423, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 215, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %424, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %425)
br label %427
427: ; preds = %415
br label %428
428: ; preds = %427
%429 = load float, float* %2
%430 = fpext float %429 to double
store double %430, double* %58
%431 = load float, float* %3
%432 = fpext float %431 to double
store double %432, double* %59
%433 = load double, double* %58
%434 = load double, double* %59
%435 = fcmp ogt double %433, %434
%436 = zext i1 %435 to i32
%437 = load double, double* %58
%438 = load double, double* %59
%439 = call i32 @ctest_assert_fmt(i32 %436, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 216, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %437, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %438)
br label %440
440: ; preds = %428
br label %441
441: ; preds = %440
%442 = load float, float* %2
%443 = fpext float %442 to double
store double %443, double* %60
%444 = load float, float* %1
%445 = fpext float %444 to double
store double %445, double* %61
%446 = load double, double* %60
%447 = load double, double* %61
%448 = fcmp oge double %446, %447
%449 = zext i1 %448 to i32
%450 = load double, double* %60
%451 = load double, double* %61
%452 = call i32 @ctest_assert_fmt(i32 %449, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 217, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %450, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %451)
br label %453
453: ; preds = %441
br label %454
454: ; preds = %453
%455 = load float, float* %3
%456 = fpext float %455 to double
store double %456, double* %62
%457 = load float, float* %1
%458 = fpext float %457 to double
store double %458, double* %63
%459 = load double, double* %62
%460 = load double, double* %63
%461 = fcmp olt double %459, %460
%462 = zext i1 %461 to i32
%463 = load double, double* %62
%464 = load double, double* %63
%465 = call i32 @ctest_assert_fmt(i32 %462, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 218, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %463, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %464)
br label %466
466: ; preds = %454
br label %467
467: ; preds = %466
%468 = load float, float* %3
%469 = fpext float %468 to double
store double %469, double* %64
%470 = load float, float* %2
%471 = fpext float %470 to double
store double %471, double* %65
%472 = load double, double* %64
%473 = load double, double* %65
%474 = fcmp olt double %472, %473
%475 = zext i1 %474 to i32
%476 = load double, double* %64
%477 = load double, double* %65
%478 = call i32 @ctest_assert_fmt(i32 %475, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 219, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double %476, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %477)
br label %479
479: ; preds = %467
br label %480
480: ; preds = %479
%481 = load float, float* %1
%482 = fpext float %481 to double
store double %482, double* %66
%483 = load float, float* %2
%484 = fpext float %483 to double
store double %484, double* %67
%485 = load double, double* %66
%486 = load double, double* %67
%487 = fcmp ole double %485, %486
%488 = zext i1 %487 to i32
%489 = load double, double* %66
%490 = load double, double* %67
%491 = call i32 @ctest_assert_fmt(i32 %488, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 220, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double %489, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double %490)
br label %492
492: ; preds = %480
br label %385
493: ; preds = %385
ret void
}

LLVM IR (-O2):
@.str = [133 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c\00"
@.str.1 = [32 x i8] c"%s %s %s with %s=%lf and %s=%lf\00"
@.str.2 = [2 x i8] c"a\00"
@.str.3 = [3 x i8] c"==\00"
@.str.4 = [2 x i8] c"c\00"
@.str.5 = [3 x i8] c"!=\00"
@.str.6 = [2 x i8] c"b\00"
@.str.7 = [2 x i8] c">\00"
@.str.8 = [3 x i8] c">=\00"
@.str.9 = [2 x i8] c"<\00"
@.str.10 = [3 x i8] c"<=\00"
define void @test_assert_float() {
%1 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 183, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%2 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 184, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%3 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 185, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%4 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 186, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%5 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 187, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%6 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 188, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%7 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 189, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%8 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 190, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%9 = tail call i64 (...) @ctest_toggle_inversion()
%10 = icmp eq i64 %9, 0
br i1 %10, label %22, label %11
11: ; preds = %0, %11
%12 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 193, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%13 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 194, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%14 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 195, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%15 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 196, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%16 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 197, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%17 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 198, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%18 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 199, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%19 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 200, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%20 = tail call i64 (...) @ctest_toggle_inversion()
%21 = icmp eq i64 %20, 0
br i1 %21, label %22, label %11
22: ; preds = %11, %0
%23 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 203, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%24 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 204, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%25 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 205, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%26 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 206, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%27 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 207, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%28 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 208, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%29 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 209, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%30 = tail call i32 @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 210, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%31 = tail call i64 (...) @ctest_toggle_inversion()
%32 = icmp eq i64 %31, 0
br i1 %32, label %44, label %33
33: ; preds = %22, %33
%34 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 213, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%35 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 214, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%36 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 215, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%37 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 216, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000)
%38 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 217, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%39 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 218, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000)
%40 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 219, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%41 = tail call i32 @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str, i64 0, i64 0), i32 220, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), double 0x3F3A36E2E0000000, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), double 0x3F33A92A40000000)
%42 = tail call i64 (...) @ctest_toggle_inversion()
%43 = icmp eq i64 %42, 0
br i1 %43, label %44, label %33
44: ; preds = %33, %22
ret void
}