#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 *, ...);
scalar_t__ ctest_toggle_inversion();
scalar_t__ strcmp(char *, char *);
void test_assert_strings() {
  const char *a = "Bogozity";
  const char *b = "Arclamp";
  const char *c = "Bogozity";
  const char *e = "";
  const char *n = NULL;
  do {
    char *xv = (void *)(a);
    char *yv = (void *)(c);
    ctest_assert_fmt(
        strcmp(xv, yv) == 0,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        233, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "eq", "c", "a", xv,
        "c", yv);
  } while (0);
  do {
    char *xv = (void *)(a);
    char *yv = (void *)(b);
    ctest_assert_fmt(
        strcmp(xv, yv) != 0,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        234, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "ne", "b", "a", xv,
        "b", yv);
  } while (0);
  do {
    char *xv = (void *)(a);
    char *yv = (void *)(b);
    ctest_assert_fmt(
        strcmp(xv, yv) > 0,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        235, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "gt", "b", "a", xv,
        "b", yv);
  } while (0);
  do {
    char *xv = (void *)(a);
    char *yv = (void *)(b);
    ctest_assert_fmt(
        strcmp(xv, yv) >= 0,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        236, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "ge", "b", "a", xv,
        "b", yv);
  } while (0);
  do {
    char *xv = (void *)(a);
    char *yv = (void *)(c);
    ctest_assert_fmt(
        strcmp(xv, yv) >= 0,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        237, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "ge", "c", "a", xv,
        "c", yv);
  } while (0);
  do {
    char *xv = (void *)(b);
    char *yv = (void *)(a);
    ctest_assert_fmt(
        strcmp(xv, yv) < 0,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        238, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "b", "lt", "a", "b", xv,
        "a", yv);
  } while (0);
  do {
    char *xv = (void *)(b);
    char *yv = (void *)(a);
    ctest_assert_fmt(
        strcmp(xv, yv) <= 0,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        239, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "b", "le", "a", "b", xv,
        "a", yv);
  } while (0);
  do {
    char *xv = (void *)(c);
    char *yv = (void *)(a);
    ctest_assert_fmt(
        strcmp(xv, yv) <= 0,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/bronson/ctest/refs/heads/master/ctassert.c",
        240, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "c", "le", "a", "c", xv,
        "a", yv);
  } while (0);
  while (ctest_toggle_inversion()) {
    do {
      char *xv = (void *)(a);
      char *yv = (void *)(b);
      ctest_assert_fmt(strcmp(xv, yv) == 0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       243, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "eq",
                       "b", "a", xv, "b", yv);
    } while (0);
    do {
      char *xv = (void *)(a);
      char *yv = (void *)(c);
      ctest_assert_fmt(strcmp(xv, yv) != 0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       244, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "ne",
                       "c", "a", xv, "c", yv);
    } while (0);
    do {
      char *xv = (void *)(a);
      char *yv = (void *)(c);
      ctest_assert_fmt(strcmp(xv, yv) > 0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       245, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "gt",
                       "c", "a", xv, "c", yv);
    } while (0);
    do {
      char *xv = (void *)(b);
      char *yv = (void *)(c);
      ctest_assert_fmt(strcmp(xv, yv) > 0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       246, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "b", "gt",
                       "c", "b", xv, "c", yv);
    } while (0);
    do {
      char *xv = (void *)(b);
      char *yv = (void *)(a);
      ctest_assert_fmt(strcmp(xv, yv) >= 0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       247, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "b", "ge",
                       "a", "b", xv, "a", yv);
    } while (0);
    do {
      char *xv = (void *)(c);
      char *yv = (void *)(a);
      ctest_assert_fmt(strcmp(xv, yv) < 0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       248, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "c", "lt",
                       "a", "c", xv, "a", yv);
    } while (0);
    do {
      char *xv = (void *)(c);
      char *yv = (void *)(b);
      ctest_assert_fmt(strcmp(xv, yv) < 0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       249, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "c", "lt",
                       "b", "c", xv, "b", yv);
    } while (0);
    do {
      char *xv = (void *)(a);
      char *yv = (void *)(b);
      ctest_assert_fmt(strcmp(xv, yv) <= 0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       250, "%s %s %s with %s=\"%s\" and %s=\"%s\"", "a", "le",
                       "b", "a", xv, "b", yv);
    } while (0);
  }
  do {
    char *pv = (void *)(e);
    if (!(pv)) {
      ctest_assert_fmt(0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       253,
                       "e"
                       " is empty with "
                       "e"
                       " set to NULL");
    } else if ((pv)[0]) {
      ctest_assert_fmt(0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       253, "%s is empty with %s set to \"%s\"", "e", "e", pv);
    } else
      ctest_assert_fmt(1,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       253, "%s is empty with %s[0]=0", "e", "e");
  } while (0);
  while (ctest_toggle_inversion()) {
    do {
      char *pv = (void *)(a);
      if (!(pv)) {
        ctest_assert_fmt(0,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         255,
                         "a"
                         " is empty with "
                         "a"
                         " set to NULL");
      } else if ((pv)[0]) {
        ctest_assert_fmt(0,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         255, "%s is empty with %s set to \"%s\"", "a", "a",
                         pv);
      } else
        ctest_assert_fmt(1,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         255, "%s is empty with %s[0]=0", "a", "a");
    } while (0);
    do {
      char *pv = (void *)(n);
      if (!(pv)) {
        ctest_assert_fmt(0,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         256,
                         "n"
                         " is empty with "
                         "n"
                         " set to NULL");
      } else if ((pv)[0]) {
        ctest_assert_fmt(0,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         256, "%s is empty with %s set to \"%s\"", "n", "n",
                         pv);
      } else
        ctest_assert_fmt(1,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         256, "%s is empty with %s[0]=0", "n", "n");
    } while (0);
  }
  do {
    char *pv = (void *)(a);
    if (!(pv)) {
      ctest_assert_fmt(0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       259, "%s is nonempty with %s set to NULL", "a", "a");
    } else if (!(pv)[0]) {
      ctest_assert_fmt(0,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       259, "%s is nonempty with %s[0] set to 0", "a", "a");
    } else
      ctest_assert_fmt(1,
                       "/scratch/repos/new/home/jordi_armengol_estape/"
                       "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                       "ctest/refs/heads/master/ctassert.c",
                       259, "%s is empty with %s set to \"%s\"", "a", "a", pv);
  } while (0);
  while (ctest_toggle_inversion()) {
    do {
      char *pv = (void *)(e);
      if (!(pv)) {
        ctest_assert_fmt(0,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         261, "%s is nonempty with %s set to NULL", "e", "e");
      } else if (!(pv)[0]) {
        ctest_assert_fmt(0,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         261, "%s is nonempty with %s[0] set to 0", "e", "e");
      } else
        ctest_assert_fmt(1,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         261, "%s is empty with %s set to \"%s\"", "e", "e",
                         pv);
    } while (0);
    do {
      char *pv = (void *)(n);
      if (!(pv)) {
        ctest_assert_fmt(0,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         262, "%s is nonempty with %s set to NULL", "n", "n");
      } else if (!(pv)[0]) {
        ctest_assert_fmt(0,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         262, "%s is nonempty with %s[0] set to 0", "n", "n");
      } else
        ctest_assert_fmt(1,
                         "/scratch/repos/new/home/jordi_armengol_estape/"
                         "c-scraper/outputs/2022-01-22/02-19-57/repos/bronson/"
                         "ctest/refs/heads/master/ctassert.c",
                         262, "%s is empty with %s set to \"%s\"", "n", "n",
                         pv);
    } while (0);
  }
}


x86 assembly (clang, -O0):
<test_assert_strings>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x188,%rsp
lea    0xebd(%rip),%rax
mov    %rax,-0x10(%rbp)
lea    0xebb(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    0xea7(%rip),%rax
mov    %rax,-0x20(%rbp)
lea    0xfa7(%rip),%rax
mov    %rax,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x38(%rbp),%r11
mov    -0x40(%rbp),%rax
lea    0xe69(%rip),%rsi
mov    $0xe9,%edx
lea    0xee2(%rip),%rcx
lea    0xefd(%rip),%rbx
lea    0xef8(%rip),%r9
lea    0xecb(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    11f0 <test_assert_strings+0xc0>
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x48(%rbp),%r11
mov    -0x50(%rbp),%rax
lea    0xde9(%rip),%rsi
mov    $0xea,%edx
lea    0xe62(%rip),%rcx
lea    0xe7d(%rip),%rbx
lea    0xe7b(%rip),%r9
lea    0xe77(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1270 <test_assert_strings+0x140>
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setg   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x58(%rbp),%r11
mov    -0x60(%rbp),%rax
lea    0xd69(%rip),%rsi
mov    $0xeb,%edx
lea    0xde2(%rip),%rcx
lea    0xdfd(%rip),%rbx
lea    0xe00(%rip),%r9
lea    0xdf7(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    12f0 <test_assert_strings+0x1c0>
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setge  %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x68(%rbp),%r11
mov    -0x70(%rbp),%rax
lea    0xce9(%rip),%rsi
mov    $0xec,%edx
lea    0xd62(%rip),%rcx
lea    0xd7d(%rip),%rbx
lea    0xd83(%rip),%r9
lea    0xd77(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1370 <test_assert_strings+0x240>
mov    -0x10(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0x80(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setge  %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x78(%rbp),%r11
mov    -0x80(%rbp),%rax
lea    0xc69(%rip),%rsi
mov    $0xed,%edx
lea    0xce2(%rip),%rcx
lea    0xcfd(%rip),%rbx
lea    0xd03(%rip),%r9
lea    0xccb(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    13f0 <test_assert_strings+0x2c0>
mov    -0x18(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rdi
mov    -0x90(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x88(%rbp),%r11
mov    -0x90(%rbp),%rax
lea    0xbd7(%rip),%rsi
mov    $0xee,%edx
lea    0xc50(%rip),%rcx
lea    0xc73(%rip),%rbx
lea    0xc74(%rip),%r9
lea    0xc5d(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1482 <test_assert_strings+0x352>
mov    -0x18(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setle  %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x98(%rbp),%r11
mov    -0xa0(%rbp),%rax
lea    0xb45(%rip),%rsi
mov    $0xef,%edx
lea    0xbbe(%rip),%rcx
lea    0xbe1(%rip),%rbx
lea    0xbe5(%rip),%r9
lea    0xbcb(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1514 <test_assert_strings+0x3e4>
mov    -0x20(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xa8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setle  %al
and    $0x1,%al
movzbl %al,%edi
mov    -0xa8(%rbp),%r11
mov    -0xb0(%rbp),%rax
lea    0xab3(%rip),%rsi
mov    $0xf0,%edx
lea    0xb2c(%rip),%rcx
lea    0xb23(%rip),%rbx
lea    0xb53(%rip),%r9
lea    0xb39(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    15a6 <test_assert_strings+0x476>
mov    $0x0,%al
call   1050 <ctest_toggle_inversion@plt>
cmp    $0x0,%rax
je     1a4c <test_assert_strings+0x91c>
jmp    15bc <test_assert_strings+0x48c>
mov    -0x10(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xb8(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0xb8(%rbp),%r11
mov    -0xc0(%rbp),%rax
lea    0xa0b(%rip),%rsi
mov    $0xf3,%edx
lea    0xa84(%rip),%rcx
lea    0xa9f(%rip),%rbx
lea    0xa9a(%rip),%r9
lea    0xa99(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    164e <test_assert_strings+0x51e>
mov    -0x10(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc8(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
mov    -0xc8(%rbp),%r11
mov    -0xd0(%rbp),%rax
lea    0x979(%rip),%rsi
mov    $0xf4,%edx
lea    0x9f2(%rip),%rcx
lea    0xa0d(%rip),%rbx
lea    0xa0b(%rip),%r9
lea    0x9db(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    16e0 <test_assert_strings+0x5b0>
mov    -0x10(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xd8(%rbp),%rdi
mov    -0xe0(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setg   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0xd8(%rbp),%r11
mov    -0xe0(%rbp),%rax
lea    0x8e7(%rip),%rsi
mov    $0xf5,%edx
lea    0x960(%rip),%rcx
lea    0x97b(%rip),%rbx
lea    0x97e(%rip),%r9
lea    0x949(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1772 <test_assert_strings+0x642>
mov    -0x18(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xe8(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setg   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0xe8(%rbp),%r11
mov    -0xf0(%rbp),%rax
lea    0x855(%rip),%rsi
mov    $0xf6,%edx
lea    0x8ce(%rip),%rcx
lea    0x8f1(%rip),%rbx
lea    0x8ec(%rip),%r9
lea    0x8b7(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1804 <test_assert_strings+0x6d4>
mov    -0x18(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0xf8(%rbp),%rdi
mov    -0x100(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setge  %al
and    $0x1,%al
movzbl %al,%edi
mov    -0xf8(%rbp),%r11
mov    -0x100(%rbp),%rax
lea    0x7c3(%rip),%rsi
mov    $0xf7,%edx
lea    0x83c(%rip),%rcx
lea    0x85f(%rip),%rbx
lea    0x85d(%rip),%r9
lea    0x849(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1896 <test_assert_strings+0x766>
mov    -0x20(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x108(%rbp),%rdi
mov    -0x110(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x108(%rbp),%r11
mov    -0x110(%rbp),%rax
lea    0x731(%rip),%rsi
mov    $0xf8,%edx
lea    0x7aa(%rip),%rcx
lea    0x7a1(%rip),%rbx
lea    0x7ce(%rip),%r9
lea    0x7b7(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1928 <test_assert_strings+0x7f8>
mov    -0x20(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x118(%rbp),%rdi
mov    -0x120(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x118(%rbp),%r11
mov    -0x120(%rbp),%rax
lea    0x69f(%rip),%rsi
mov    $0xf9,%edx
lea    0x718(%rip),%rcx
lea    0x70f(%rip),%rbx
lea    0x73c(%rip),%r9
lea    0x72d(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    19ba <test_assert_strings+0x88a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x128(%rbp),%rdi
mov    -0x130(%rbp),%rsi
call   1040 <strcmp@plt>
cmp    $0x0,%rax
setle  %al
and    $0x1,%al
movzbl %al,%edi
mov    -0x128(%rbp),%r11
mov    -0x130(%rbp),%rax
lea    0x60d(%rip),%rsi
mov    $0xfa,%edx
lea    0x686(%rip),%rcx
lea    0x6a1(%rip),%rbx
lea    0x6ad(%rip),%r9
lea    0x69b(%rip),%r10
mov    %rbx,%r8
mov    %r10,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    15a6 <test_assert_strings+0x476>
jmp    1a51 <test_assert_strings+0x921>
mov    -0x28(%rbp),%rax
mov    %rax,-0x138(%rbp)
cmpq   $0x0,-0x138(%rbp)
jne    1a8b <test_assert_strings+0x95b>
xor    %edi,%edi
lea    0x59e(%rip),%rsi
mov    $0xfd,%edx
lea    0x64f(%rip),%rcx
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1aff <test_assert_strings+0x9cf>
mov    -0x138(%rbp),%rax
cmpb   $0x0,(%rax)
je     1ad1 <test_assert_strings+0x9a1>
mov    -0x138(%rbp),%rax
xor    %edi,%edi
lea    0x566(%rip),%rsi
mov    $0xfd,%edx
lea    0x635(%rip),%rcx
lea    0x608(%rip),%r9
mov    %r9,%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1afa <test_assert_strings+0x9ca>
mov    $0x1,%edi
lea    0x534(%rip),%rsi
mov    $0xfd,%edx
lea    0x623(%rip),%rcx
lea    0x5d6(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1aff <test_assert_strings+0x9cf>
jmp    1b04 <test_assert_strings+0x9d4>
jmp    1b09 <test_assert_strings+0x9d9>
mov    $0x0,%al
call   1050 <ctest_toggle_inversion@plt>
cmp    $0x0,%rax
je     1c8f <test_assert_strings+0xb5f>
jmp    1b1f <test_assert_strings+0x9ef>
mov    -0x10(%rbp),%rax
mov    %rax,-0x140(%rbp)
cmpq   $0x0,-0x140(%rbp)
jne    1b59 <test_assert_strings+0xa29>
xor    %edi,%edi
lea    0x4d0(%rip),%rsi
mov    $0xff,%edx
lea    0x5d8(%rip),%rcx
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1bcd <test_assert_strings+0xa9d>
mov    -0x140(%rbp),%rax
cmpb   $0x0,(%rax)
je     1b9f <test_assert_strings+0xa6f>
mov    -0x140(%rbp),%rax
xor    %edi,%edi
lea    0x498(%rip),%rsi
mov    $0xff,%edx
lea    0x567(%rip),%rcx
lea    0x52c(%rip),%r9
mov    %r9,%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1bc8 <test_assert_strings+0xa98>
mov    $0x1,%edi
lea    0x466(%rip),%rsi
mov    $0xff,%edx
lea    0x555(%rip),%rcx
lea    0x4fa(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1bcd <test_assert_strings+0xa9d>
jmp    1bd2 <test_assert_strings+0xaa2>
jmp    1bd7 <test_assert_strings+0xaa7>
mov    -0x30(%rbp),%rax
mov    %rax,-0x148(%rbp)
cmpq   $0x0,-0x148(%rbp)
jne    1c11 <test_assert_strings+0xae1>
xor    %edi,%edi
lea    0x418(%rip),%rsi
mov    $0x100,%edx
lea    0x53e(%rip),%rcx
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1c85 <test_assert_strings+0xb55>
mov    -0x148(%rbp),%rax
cmpb   $0x0,(%rax)
je     1c57 <test_assert_strings+0xb27>
mov    -0x148(%rbp),%rax
xor    %edi,%edi
lea    0x3e0(%rip),%rsi
mov    $0x100,%edx
lea    0x4af(%rip),%rcx
lea    0x51d(%rip),%r9
mov    %r9,%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1c80 <test_assert_strings+0xb50>
mov    $0x1,%edi
lea    0x3ae(%rip),%rsi
mov    $0x100,%edx
lea    0x49d(%rip),%rcx
lea    0x4eb(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1c85 <test_assert_strings+0xb55>
jmp    1c8a <test_assert_strings+0xb5a>
jmp    1b09 <test_assert_strings+0x9d9>
jmp    1c94 <test_assert_strings+0xb64>
mov    -0x10(%rbp),%rax
mov    %rax,-0x150(%rbp)
cmpq   $0x0,-0x150(%rbp)
jne    1cd8 <test_assert_strings+0xba8>
xor    %edi,%edi
lea    0x35b(%rip),%rsi
mov    $0x103,%edx
lea    0x4a1(%rip),%rcx
lea    0x3ef(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1d4c <test_assert_strings+0xc1c>
mov    -0x150(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1d13 <test_assert_strings+0xbe3>
xor    %edi,%edi
lea    0x320(%rip),%rsi
mov    $0x103,%edx
lea    0x489(%rip),%rcx
lea    0x3b4(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1d47 <test_assert_strings+0xc17>
mov    -0x150(%rbp),%rax
mov    $0x1,%edi
lea    0x2eb(%rip),%rsi
mov    $0x103,%edx
lea    0x3ba(%rip),%rcx
lea    0x37f(%rip),%r9
mov    %r9,%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1d4c <test_assert_strings+0xc1c>
jmp    1d51 <test_assert_strings+0xc21>
jmp    1d56 <test_assert_strings+0xc26>
mov    $0x0,%al
call   1050 <ctest_toggle_inversion@plt>
cmp    $0x0,%rax
je     1ef0 <test_assert_strings+0xdc0>
jmp    1d6c <test_assert_strings+0xc3c>
mov    -0x28(%rbp),%rax
mov    %rax,-0x158(%rbp)
cmpq   $0x0,-0x158(%rbp)
jne    1db0 <test_assert_strings+0xc80>
xor    %edi,%edi
lea    0x283(%rip),%rsi
mov    $0x105,%edx
lea    0x3c9(%rip),%rcx
lea    0x325(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1e24 <test_assert_strings+0xcf4>
mov    -0x158(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1deb <test_assert_strings+0xcbb>
xor    %edi,%edi
lea    0x248(%rip),%rsi
mov    $0x105,%edx
lea    0x3b1(%rip),%rcx
lea    0x2ea(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1e1f <test_assert_strings+0xcef>
mov    -0x158(%rbp),%rax
mov    $0x1,%edi
lea    0x213(%rip),%rsi
mov    $0x105,%edx
lea    0x2e2(%rip),%rcx
lea    0x2b5(%rip),%r9
mov    %r9,%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1e24 <test_assert_strings+0xcf4>
jmp    1e29 <test_assert_strings+0xcf9>
jmp    1e2e <test_assert_strings+0xcfe>
mov    -0x30(%rbp),%rax
mov    %rax,-0x160(%rbp)
cmpq   $0x0,-0x160(%rbp)
jne    1e72 <test_assert_strings+0xd42>
xor    %edi,%edi
lea    0x1c1(%rip),%rsi
mov    $0x106,%edx
lea    0x307(%rip),%rcx
lea    0x2fe(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1ee6 <test_assert_strings+0xdb6>
mov    -0x160(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1ead <test_assert_strings+0xd7d>
xor    %edi,%edi
lea    0x186(%rip),%rsi
mov    $0x106,%edx
lea    0x2ef(%rip),%rcx
lea    0x2c3(%rip),%r9
mov    %r9,%r8
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1ee1 <test_assert_strings+0xdb1>
mov    -0x160(%rbp),%rax
mov    $0x1,%edi
lea    0x151(%rip),%rsi
mov    $0x106,%edx
lea    0x220(%rip),%rcx
lea    0x28e(%rip),%r9
mov    %r9,%r8
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <ctest_assert_fmt@plt>
jmp    1ee6 <test_assert_strings+0xdb6>
jmp    1eeb <test_assert_strings+0xdbb>
jmp    1d56 <test_assert_strings+0xc26>
add    $0x188,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_assert_strings>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
lea    0xebe(%rip),%r13
mov    %r13,%rdi
mov    %r13,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
sub    $0x8,%rsp
lea    0xf33(%rip),%rbp
lea    0xf50(%rip),%r12
lea    0xea2(%rip),%rbx
lea    0xf20(%rip),%r14
lea    0xf3d(%rip),%r9
mov    %rbx,%rsi
mov    $0xe9,%edx
mov    %r14,%rcx
mov    %r12,%r8
xor    %eax,%eax
push   %r13
push   %rbp
push   %r13
push   %r12
push   %rbp
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
lea    0xe64(%rip),%rbp
mov    %r13,%rdi
mov    %rbp,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
setne  %dil
sub    $0x8,%rsp
lea    0xefc(%rip),%r15
lea    0xef2(%rip),%r9
mov    %rbx,%rsi
mov    $0xea,%edx
mov    %r14,%rcx
mov    %r12,%r8
xor    %eax,%eax
push   %rbp
push   %r15
push   %r13
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r13,%rdi
mov    %rbp,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
setg   %dil
sub    $0x8,%rsp
lea    0xeb6(%rip),%r9
mov    %rbx,%rsi
mov    $0xeb,%edx
mov    %r14,%rcx
mov    %r12,%r8
xor    %eax,%eax
push   %rbp
push   %r15
push   %r13
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r13,%rdi
mov    %rbp,%rsi
call   1040 <strcmp@plt>
shr    $0x3f,%rax
xor    $0x1,%eax
sub    $0x8,%rsp
lea    0xe7a(%rip),%r9
mov    %eax,%edi
mov    %rbx,%rsi
mov    $0xec,%edx
mov    %r14,%rcx
mov    %r12,%r8
xor    %eax,%eax
push   %rbp
push   %r15
push   %r13
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r13,%rdi
mov    %r13,%rsi
call   1040 <strcmp@plt>
shr    $0x3f,%rax
xor    $0x1,%eax
sub    $0x8,%rsp
mov    %eax,%edi
mov    %rbx,%rsi
mov    $0xed,%edx
mov    %r14,%rcx
mov    %r12,%r8
lea    0xe29(%rip),%r9
xor    %eax,%eax
push   %r13
lea    0xded(%rip),%rbx
push   %rbx
push   %r13
push   %r12
push   %rbx
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %rbp,%rdi
mov    %r13,%rsi
call   1040 <strcmp@plt>
shr    $0x3f,%rax
sub    $0x8,%rsp
lea    0xdf8(%rip),%r9
mov    %eax,%edi
lea    0xd38(%rip),%rsi
mov    %rsi,%rbx
mov    $0xee,%edx
mov    %r14,%rcx
mov    %r15,%r8
xor    %eax,%eax
push   %r13
push   %r12
push   %rbp
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %rbp,%rdi
mov    %r13,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
setle  %dil
sub    $0x8,%rsp
lea    0xdb1(%rip),%r9
mov    %rbx,%rsi
mov    $0xef,%edx
mov    %r14,%rcx
mov    %r15,%r8
xor    %eax,%eax
push   %r13
push   %r12
push   %rbp
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r13,%rdi
mov    %r13,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
setle  %dil
sub    $0x8,%rsp
mov    %rbx,%rsi
mov    $0xf0,%edx
mov    %r14,%rcx
lea    0xd2e(%rip),%r8
lea    0xd5e(%rip),%r9
xor    %eax,%eax
push   %r13
push   %r12
push   %r13
push   %r8
push   %r12
nopl   0x0(%rax)
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
xor    %eax,%eax
call   1050 <ctest_toggle_inversion@plt>
test   %rax,%rax
je     1627 <test_assert_strings+0x4f7>
mov    %r13,%rdi
mov    %rbp,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
sub    $0x8,%rsp
lea    0xc59(%rip),%rsi
mov    $0xf3,%edx
mov    %r13,%r14
lea    0xccf(%rip),%r13
mov    %r13,%rcx
mov    %r12,%r8
lea    0xce6(%rip),%r9
xor    %eax,%eax
push   %rbp
push   %r15
push   %r14
push   %r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r14,%rdi
mov    %r14,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
setne  %dil
sub    $0x8,%rsp
lea    0xc0a(%rip),%rbp
mov    %rbp,%rsi
mov    $0xf4,%edx
mov    %r13,%rcx
mov    %r12,%r8
lea    0xca1(%rip),%r9
xor    %eax,%eax
push   %r14
mov    %r12,%r15
lea    0xc6a(%rip),%r12
push   %r12
push   %r14
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r14,%rdi
mov    %r14,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
setg   %dil
sub    $0x8,%rsp
mov    %rbp,%rsi
mov    $0xf5,%edx
mov    %r13,%rcx
mov    %r15,%r8
lea    0xc5a(%rip),%rbp
mov    %rbp,%r9
xor    %eax,%eax
push   %r14
push   %r12
push   %r14
push   %r15
push   %r12
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
lea    0xb82(%rip),%rdi
mov    %r14,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
setg   %dil
sub    $0x8,%rsp
lea    0xb6e(%rip),%r12
mov    %r12,%rsi
mov    $0xf6,%edx
mov    %r13,%rcx
lea    0xc0b(%rip),%r8
mov    %rbp,%r9
xor    %eax,%eax
push   %r14
lea    0xbd1(%rip),%rbx
push   %rbx
lea    0xb3e(%rip),%rbp
push   %rbp
lea    0xbed(%rip),%rbp
push   %rbp
push   %rbx
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
lea    0xb24(%rip),%rdi
mov    %r14,%rsi
call   1040 <strcmp@plt>
shr    $0x3f,%rax
xor    $0x1,%eax
sub    $0x8,%rsp
mov    %eax,%edi
mov    %r12,%rsi
mov    $0xf7,%edx
mov    %r13,%rcx
mov    %r13,%rbx
lea    0xbb1(%rip),%r8
lea    0xbaf(%rip),%r9
xor    %eax,%eax
push   %r14
push   %r15
lea    0xae6(%rip),%rbp
push   %rbp
lea    0xb95(%rip),%rbp
push   %rbp
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r14,%rdi
mov    %r14,%rsi
call   1040 <strcmp@plt>
shr    $0x3f,%rax
sub    $0x8,%rsp
mov    %eax,%edi
mov    %r12,%rbp
mov    %r12,%rsi
mov    $0xf8,%edx
mov    %r13,%rcx
lea    0xb33(%rip),%r8
lea    0xb60(%rip),%r13
mov    %r13,%r9
xor    %eax,%eax
push   %r14
push   %r15
push   %r14
push   %r8
mov    %r8,%r12
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r14,%rdi
lea    0xa7c(%rip),%rsi
call   1040 <strcmp@plt>
shr    $0x3f,%rax
sub    $0x8,%rsp
mov    %eax,%edi
mov    %rbp,%rsi
mov    $0xf9,%edx
mov    %rbx,%rcx
mov    %r12,%r8
mov    %r13,%r9
xor    %eax,%eax
lea    0xa53(%rip),%rbp
push   %rbp
lea    0xb02(%rip),%rbp
push   %rbp
push   %r14
push   %r12
mov    %r15,%r12
lea    0xaf3(%rip),%r15
lea    0xa35(%rip),%rbp
push   %r15
call   1030 <ctest_assert_fmt@plt>
add    $0x30,%rsp
mov    %r14,%rdi
mov    %rbp,%rsi
call   1040 <strcmp@plt>
xor    %edi,%edi
test   %rax,%rax
setle  %dil
sub    $0x8,%rsp
lea    0xa13(%rip),%rsi
mov    $0xfa,%edx
lea    0xa8c(%rip),%rcx
mov    %r14,%r13
mov    %r12,%r8
lea    0xab4(%rip),%r9
xor    %eax,%eax
push   %rbp
push   %r15
push   %r14
push   %r12
push   %r15
jmp    1380 <test_assert_strings+0x250>
lea    0x9e3(%rip),%rsi
lea    0xab9(%rip),%rcx
lea    0xa8a(%rip),%r8
mov    $0x1,%edi
mov    $0xfd,%edx
mov    %r8,%r9
xor    %eax,%eax
call   1030 <ctest_assert_fmt@plt>
xor    %eax,%eax
call   1050 <ctest_toggle_inversion@plt>
test   %rax,%rax
je     16c4 <test_assert_strings+0x594>
lea    0x9ae(%rip),%r15
lea    0xa64(%rip),%r14
lea    0xa47(%rip),%rbp
lea    0xa8f(%rip),%r12
nopl   0x0(%rax,%rax,1)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r15,%rsi
mov    $0xff,%edx
mov    %r14,%rcx
mov    %rbp,%r8
mov    %rbp,%r9
xor    %eax,%eax
push   %r13
call   1030 <ctest_assert_fmt@plt>
add    $0x10,%rsp
xor    %edi,%edi
mov    %r15,%rsi
mov    $0x100,%edx
mov    %r12,%rcx
xor    %eax,%eax
call   1030 <ctest_assert_fmt@plt>
xor    %eax,%eax
call   1050 <ctest_toggle_inversion@plt>
test   %rax,%rax
jne    1680 <test_assert_strings+0x550>
sub    $0x8,%rsp
lea    0x942(%rip),%rsi
lea    0x9f8(%rip),%rcx
lea    0x9db(%rip),%r8
mov    $0x1,%edi
mov    $0x103,%edx
mov    %r8,%r9
xor    %eax,%eax
push   %r13
call   1030 <ctest_assert_fmt@plt>
add    $0x10,%rsp
xor    %eax,%eax
call   1050 <ctest_toggle_inversion@plt>
test   %rax,%rax
je     1770 <test_assert_strings+0x640>
lea    0x907(%rip),%r12
lea    0xa39(%rip),%r14
lea    0x9ae(%rip),%rbp
lea    0xa08(%rip),%r15
lea    0x9ff(%rip),%rbx
cs nopw 0x0(%rax,%rax,1)
xor    %edi,%edi
mov    %r12,%rsi
mov    $0x105,%edx
mov    %r14,%rcx
mov    %rbp,%r8
mov    %rbp,%r9
xor    %eax,%eax
call   1030 <ctest_assert_fmt@plt>
xor    %edi,%edi
mov    %r12,%rsi
mov    $0x106,%edx
mov    %r15,%rcx
mov    %rbx,%r8
mov    %rbx,%r9
xor    %eax,%eax
call   1030 <ctest_assert_fmt@plt>
xor    %eax,%eax
call   1050 <ctest_toggle_inversion@plt>
test   %rax,%rax
jne    1730 <test_assert_strings+0x600>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [9 x i8] c"Bogozity\00"
@.str.1 = [8 x i8] c"Arclamp\00"
@.str.2 = [1 x i8] zeroinitializer
@.str.3 = [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.4 = [34 x i8] c"%s %s %s with %s=\22%s\22 and %s=\22%s\22\00"
@.str.5 = [2 x i8] c"a\00"
@.str.6 = [3 x i8] c"eq\00"
@.str.7 = [2 x i8] c"c\00"
@.str.8 = [3 x i8] c"ne\00"
@.str.9 = [2 x i8] c"b\00"
@.str.10 = [3 x i8] c"gt\00"
@.str.11 = [3 x i8] c"ge\00"
@.str.12 = [3 x i8] c"lt\00"
@.str.13 = [3 x i8] c"le\00"
@.str.14 = [30 x i8] c"e is empty with e set to NULL\00"
@.str.15 = [32 x i8] c"%s is empty with %s set to \22%s\22\00"
@.str.16 = [2 x i8] c"e\00"
@.str.17 = [25 x i8] c"%s is empty with %s[0]=0\00"
@.str.18 = [30 x i8] c"a is empty with a set to NULL\00"
@.str.19 = [30 x i8] c"n is empty with n set to NULL\00"
@.str.20 = [2 x i8] c"n\00"
@.str.21 = [35 x i8] c"%s is nonempty with %s set to NULL\00"
@.str.22 = [35 x i8] c"%s is nonempty with %s[0] set to 0\00"
define void @test_assert_strings() {
%1 = alloca i8*
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i8*
%21 = alloca i8*
%22 = alloca i8*
%23 = alloca i8*
%24 = alloca i8*
%25 = alloca i8*
%26 = alloca i8*
%27 = alloca i8*
%28 = alloca i8*
%29 = alloca i8*
%30 = alloca i8*
%31 = alloca i8*
%32 = alloca i8*
%33 = alloca i8*
%34 = alloca i8*
%35 = alloca i8*
%36 = alloca i8*
%37 = alloca i8*
%38 = alloca i8*
%39 = alloca i8*
%40 = alloca i8*
%41 = alloca i8*
%42 = alloca i8*
%43 = alloca i8*
store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8** %1
store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8** %2
store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8** %3
store i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i64 0, i64 0), i8** %4
store i8* null, i8** %5
br label %44
44: ; preds = %0
%45 = load i8*, i8** %1
store i8* %45, i8** %6
%46 = load i8*, i8** %3
store i8* %46, i8** %7
%47 = load i8*, i8** %6
%48 = load i8*, i8** %7
%49 = call i64 @strcmp(i8* %47, i8* %48)
%50 = icmp eq i64 %49, 0
%51 = zext i1 %50 to i32
%52 = load i8*, i8** %6
%53 = load i8*, i8** %7
%54 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %51, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 233, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 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.5, i64 0, i64 0), i8* %52, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* %53)
br label %55
55: ; preds = %44
br label %56
56: ; preds = %55
%57 = load i8*, i8** %1
store i8* %57, i8** %8
%58 = load i8*, i8** %2
store i8* %58, i8** %9
%59 = load i8*, i8** %8
%60 = load i8*, i8** %9
%61 = call i64 @strcmp(i8* %59, i8* %60)
%62 = icmp ne i64 %61, 0
%63 = zext i1 %62 to i32
%64 = load i8*, i8** %8
%65 = load i8*, i8** %9
%66 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %63, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 234, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, 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.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %64, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %65)
br label %67
67: ; preds = %56
br label %68
68: ; preds = %67
%69 = load i8*, i8** %1
store i8* %69, i8** %10
%70 = load i8*, i8** %2
store i8* %70, i8** %11
%71 = load i8*, i8** %10
%72 = load i8*, i8** %11
%73 = call i64 @strcmp(i8* %71, i8* %72)
%74 = icmp sgt i64 %73, 0
%75 = zext i1 %74 to i32
%76 = load i8*, i8** %10
%77 = load i8*, i8** %11
%78 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %75, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 235, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, 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.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %76, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %77)
br label %79
79: ; preds = %68
br label %80
80: ; preds = %79
%81 = load i8*, i8** %1
store i8* %81, i8** %12
%82 = load i8*, i8** %2
store i8* %82, i8** %13
%83 = load i8*, i8** %12
%84 = load i8*, i8** %13
%85 = call i64 @strcmp(i8* %83, i8* %84)
%86 = icmp sge i64 %85, 0
%87 = zext i1 %86 to i32
%88 = load i8*, i8** %12
%89 = load i8*, i8** %13
%90 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %87, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 236, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, 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.5, i64 0, i64 0), i8* %88, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %89)
br label %91
91: ; preds = %80
br label %92
92: ; preds = %91
%93 = load i8*, i8** %1
store i8* %93, i8** %14
%94 = load i8*, i8** %3
store i8* %94, i8** %15
%95 = load i8*, i8** %14
%96 = load i8*, i8** %15
%97 = call i64 @strcmp(i8* %95, i8* %96)
%98 = icmp sge i64 %97, 0
%99 = zext i1 %98 to i32
%100 = load i8*, i8** %14
%101 = load i8*, i8** %15
%102 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %99, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 237, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, 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.5, i64 0, i64 0), i8* %100, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* %101)
br label %103
103: ; preds = %92
br label %104
104: ; preds = %103
%105 = load i8*, i8** %2
store i8* %105, i8** %16
%106 = load i8*, i8** %1
store i8* %106, i8** %17
%107 = load i8*, i8** %16
%108 = load i8*, i8** %17
%109 = call i64 @strcmp(i8* %107, i8* %108)
%110 = icmp slt i64 %109, 0
%111 = zext i1 %110 to i32
%112 = load i8*, i8** %16
%113 = load i8*, i8** %17
%114 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %111, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 238, i8* getelementptr inbounds ([34 x i8], [34 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 ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %112, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %113)
br label %115
115: ; preds = %104
br label %116
116: ; preds = %115
%117 = load i8*, i8** %2
store i8* %117, i8** %18
%118 = load i8*, i8** %1
store i8* %118, i8** %19
%119 = load i8*, i8** %18
%120 = load i8*, i8** %19
%121 = call i64 @strcmp(i8* %119, i8* %120)
%122 = icmp sle i64 %121, 0
%123 = zext i1 %122 to i32
%124 = load i8*, i8** %18
%125 = load i8*, i8** %19
%126 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %123, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 239, i8* getelementptr inbounds ([34 x i8], [34 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 ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %124, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %125)
br label %127
127: ; preds = %116
br label %128
128: ; preds = %127
%129 = load i8*, i8** %3
store i8* %129, i8** %20
%130 = load i8*, i8** %1
store i8* %130, i8** %21
%131 = load i8*, i8** %20
%132 = load i8*, i8** %21
%133 = call i64 @strcmp(i8* %131, i8* %132)
%134 = icmp sle i64 %133, 0
%135 = zext i1 %134 to i32
%136 = load i8*, i8** %20
%137 = load i8*, i8** %21
%138 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %135, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 240, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* %136, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %137)
br label %139
139: ; preds = %128
br label %140
140: ; preds = %239, %139
%141 = call i64 (...) @ctest_toggle_inversion()
%142 = icmp ne i64 %141, 0
br i1 %142, label %143, label %240
143: ; preds = %140
br label %144
144: ; preds = %143
%145 = load i8*, i8** %1
store i8* %145, i8** %22
%146 = load i8*, i8** %2
store i8* %146, i8** %23
%147 = load i8*, i8** %22
%148 = load i8*, i8** %23
%149 = call i64 @strcmp(i8* %147, i8* %148)
%150 = icmp eq i64 %149, 0
%151 = zext i1 %150 to i32
%152 = load i8*, i8** %22
%153 = load i8*, i8** %23
%154 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %151, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 243, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 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.5, i64 0, i64 0), i8* %152, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %153)
br label %155
155: ; preds = %144
br label %156
156: ; preds = %155
%157 = load i8*, i8** %1
store i8* %157, i8** %24
%158 = load i8*, i8** %3
store i8* %158, i8** %25
%159 = load i8*, i8** %24
%160 = load i8*, i8** %25
%161 = call i64 @strcmp(i8* %159, i8* %160)
%162 = icmp ne i64 %161, 0
%163 = zext i1 %162 to i32
%164 = load i8*, i8** %24
%165 = load i8*, i8** %25
%166 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %163, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 244, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, 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.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %164, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* %165)
br label %167
167: ; preds = %156
br label %168
168: ; preds = %167
%169 = load i8*, i8** %1
store i8* %169, i8** %26
%170 = load i8*, i8** %3
store i8* %170, i8** %27
%171 = load i8*, i8** %26
%172 = load i8*, i8** %27
%173 = call i64 @strcmp(i8* %171, i8* %172)
%174 = icmp sgt i64 %173, 0
%175 = zext i1 %174 to i32
%176 = load i8*, i8** %26
%177 = load i8*, i8** %27
%178 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %175, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 245, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, 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.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %176, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* %177)
br label %179
179: ; preds = %168
br label %180
180: ; preds = %179
%181 = load i8*, i8** %2
store i8* %181, i8** %28
%182 = load i8*, i8** %3
store i8* %182, i8** %29
%183 = load i8*, i8** %28
%184 = load i8*, i8** %29
%185 = call i64 @strcmp(i8* %183, i8* %184)
%186 = icmp sgt i64 %185, 0
%187 = zext i1 %186 to i32
%188 = load i8*, i8** %28
%189 = load i8*, i8** %29
%190 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %187, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 246, i8* getelementptr inbounds ([34 x i8], [34 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 ([3 x i8], [3 x i8]* @.str.10, 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.9, i64 0, i64 0), i8* %188, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* %189)
br label %191
191: ; preds = %180
br label %192
192: ; preds = %191
%193 = load i8*, i8** %2
store i8* %193, i8** %30
%194 = load i8*, i8** %1
store i8* %194, i8** %31
%195 = load i8*, i8** %30
%196 = load i8*, i8** %31
%197 = call i64 @strcmp(i8* %195, i8* %196)
%198 = icmp sge i64 %197, 0
%199 = zext i1 %198 to i32
%200 = load i8*, i8** %30
%201 = load i8*, i8** %31
%202 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %199, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 247, i8* getelementptr inbounds ([34 x i8], [34 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 ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %200, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %201)
br label %203
203: ; preds = %192
br label %204
204: ; preds = %203
%205 = load i8*, i8** %3
store i8* %205, i8** %32
%206 = load i8*, i8** %1
store i8* %206, i8** %33
%207 = load i8*, i8** %32
%208 = load i8*, i8** %33
%209 = call i64 @strcmp(i8* %207, i8* %208)
%210 = icmp slt i64 %209, 0
%211 = zext i1 %210 to i32
%212 = load i8*, i8** %32
%213 = load i8*, i8** %33
%214 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %211, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 248, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* %212, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %213)
br label %215
215: ; preds = %204
br label %216
216: ; preds = %215
%217 = load i8*, i8** %3
store i8* %217, i8** %34
%218 = load i8*, i8** %2
store i8* %218, i8** %35
%219 = load i8*, i8** %34
%220 = load i8*, i8** %35
%221 = call i64 @strcmp(i8* %219, i8* %220)
%222 = icmp slt i64 %221, 0
%223 = zext i1 %222 to i32
%224 = load i8*, i8** %34
%225 = load i8*, i8** %35
%226 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %223, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 249, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, 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.7, i64 0, i64 0), i8* %224, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %225)
br label %227
227: ; preds = %216
br label %228
228: ; preds = %227
%229 = load i8*, i8** %1
store i8* %229, i8** %36
%230 = load i8*, i8** %2
store i8* %230, i8** %37
%231 = load i8*, i8** %36
%232 = load i8*, i8** %37
%233 = call i64 @strcmp(i8* %231, i8* %232)
%234 = icmp sle i64 %233, 0
%235 = zext i1 %234 to i32
%236 = load i8*, i8** %36
%237 = load i8*, i8** %37
%238 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %235, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 250, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, 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.5, i64 0, i64 0), i8* %236, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* %237)
br label %239
239: ; preds = %228
br label %140
240: ; preds = %140
br label %241
241: ; preds = %240
%242 = load i8*, i8** %4
store i8* %242, i8** %38
%243 = load i8*, i8** %38
%244 = icmp ne i8* %243, null
br i1 %244, label %247, label %245
245: ; preds = %241
%246 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 253, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.14, i64 0, i64 0))
br label %258
247: ; preds = %241
%248 = load i8*, i8** %38
%249 = getelementptr inbounds i8, i8* %248, i64 0
%250 = load i8, i8* %249
%251 = icmp ne i8 %250, 0
br i1 %251, label %252, label %255
252: ; preds = %247
%253 = load i8*, i8** %38
%254 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 253, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* %253)
br label %257
255: ; preds = %247
%256 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 253, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
br label %257
257: ; preds = %255, %252
br label %258
258: ; preds = %257, %245
br label %259
259: ; preds = %258
br label %260
260: ; preds = %301, %259
%261 = call i64 (...) @ctest_toggle_inversion()
%262 = icmp ne i64 %261, 0
br i1 %262, label %263, label %302
263: ; preds = %260
br label %264
264: ; preds = %263
%265 = load i8*, i8** %1
store i8* %265, i8** %39
%266 = load i8*, i8** %39
%267 = icmp ne i8* %266, null
br i1 %267, label %270, label %268
268: ; preds = %264
%269 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 255, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.18, i64 0, i64 0))
br label %281
270: ; preds = %264
%271 = load i8*, i8** %39
%272 = getelementptr inbounds i8, i8* %271, i64 0
%273 = load i8, i8* %272
%274 = icmp ne i8 %273, 0
br i1 %274, label %275, label %278
275: ; preds = %270
%276 = load i8*, i8** %39
%277 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 255, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %276)
br label %280
278: ; preds = %270
%279 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 255, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %280
280: ; preds = %278, %275
br label %281
281: ; preds = %280, %268
br label %282
282: ; preds = %281
br label %283
283: ; preds = %282
%284 = load i8*, i8** %5
store i8* %284, i8** %40
%285 = load i8*, i8** %40
%286 = icmp ne i8* %285, null
br i1 %286, label %289, label %287
287: ; preds = %283
%288 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 256, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.19, i64 0, i64 0))
br label %300
289: ; preds = %283
%290 = load i8*, i8** %40
%291 = getelementptr inbounds i8, i8* %290, i64 0
%292 = load i8, i8* %291
%293 = icmp ne i8 %292, 0
br i1 %293, label %294, label %297
294: ; preds = %289
%295 = load i8*, i8** %40
%296 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 256, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* %295)
br label %299
297: ; preds = %289
%298 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 256, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
br label %299
299: ; preds = %297, %294
br label %300
300: ; preds = %299, %287
br label %301
301: ; preds = %300
br label %260
302: ; preds = %260
br label %303
303: ; preds = %302
%304 = load i8*, i8** %1
store i8* %304, i8** %41
%305 = load i8*, i8** %41
%306 = icmp ne i8* %305, null
br i1 %306, label %309, label %307
307: ; preds = %303
%308 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 259, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %320
309: ; preds = %303
%310 = load i8*, i8** %41
%311 = getelementptr inbounds i8, i8* %310, i64 0
%312 = load i8, i8* %311
%313 = icmp ne i8 %312, 0
br i1 %313, label %316, label %314
314: ; preds = %309
%315 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 259, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %319
316: ; preds = %309
%317 = load i8*, i8** %41
%318 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 259, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* %317)
br label %319
319: ; preds = %316, %314
br label %320
320: ; preds = %319, %307
br label %321
321: ; preds = %320
br label %322
322: ; preds = %363, %321
%323 = call i64 (...) @ctest_toggle_inversion()
%324 = icmp ne i64 %323, 0
br i1 %324, label %325, label %364
325: ; preds = %322
br label %326
326: ; preds = %325
%327 = load i8*, i8** %4
store i8* %327, i8** %42
%328 = load i8*, i8** %42
%329 = icmp ne i8* %328, null
br i1 %329, label %332, label %330
330: ; preds = %326
%331 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 261, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
br label %343
332: ; preds = %326
%333 = load i8*, i8** %42
%334 = getelementptr inbounds i8, i8* %333, i64 0
%335 = load i8, i8* %334
%336 = icmp ne i8 %335, 0
br i1 %336, label %339, label %337
337: ; preds = %332
%338 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 261, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
br label %342
339: ; preds = %332
%340 = load i8*, i8** %42
%341 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 261, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* %340)
br label %342
342: ; preds = %339, %337
br label %343
343: ; preds = %342, %330
br label %344
344: ; preds = %343
br label %345
345: ; preds = %344
%346 = load i8*, i8** %5
store i8* %346, i8** %43
%347 = load i8*, i8** %43
%348 = icmp ne i8* %347, null
br i1 %348, label %351, label %349
349: ; preds = %345
%350 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 262, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
br label %362
351: ; preds = %345
%352 = load i8*, i8** %43
%353 = getelementptr inbounds i8, i8* %352, i64 0
%354 = load i8, i8* %353
%355 = icmp ne i8 %354, 0
br i1 %355, label %358, label %356
356: ; preds = %351
%357 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 262, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
br label %361
358: ; preds = %351
%359 = load i8*, i8** %43
%360 = call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 262, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* %359)
br label %361
361: ; preds = %358, %356
br label %362
362: ; preds = %361, %349
br label %363
363: ; preds = %362
br label %322
364: ; preds = %322
ret void
}

LLVM IR (-O2):
@.str = [9 x i8] c"Bogozity\00"
@.str.1 = [8 x i8] c"Arclamp\00"
@.str.3 = [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.4 = [34 x i8] c"%s %s %s with %s=\22%s\22 and %s=\22%s\22\00"
@.str.5 = [2 x i8] c"a\00"
@.str.6 = [3 x i8] c"eq\00"
@.str.7 = [2 x i8] c"c\00"
@.str.8 = [3 x i8] c"ne\00"
@.str.9 = [2 x i8] c"b\00"
@.str.10 = [3 x i8] c"gt\00"
@.str.11 = [3 x i8] c"ge\00"
@.str.12 = [3 x i8] c"lt\00"
@.str.13 = [3 x i8] c"le\00"
@.str.15 = [32 x i8] c"%s is empty with %s set to \22%s\22\00"
@.str.16 = [2 x i8] c"e\00"
@.str.17 = [25 x i8] c"%s is empty with %s[0]=0\00"
@.str.19 = [30 x i8] c"n is empty with n set to NULL\00"
@.str.20 = [2 x i8] c"n\00"
@.str.21 = [35 x i8] c"%s is nonempty with %s set to NULL\00"
@.str.22 = [35 x i8] c"%s is nonempty with %s[0] set to 0\00"
define void @test_assert_strings() {
%1 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%2 = icmp eq i64 %1, 0
%3 = zext i1 %2 to i32
%4 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %3, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 233, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 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.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%5 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%6 = icmp ne i64 %5, 0
%7 = zext i1 %6 to i32
%8 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %7, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 234, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, 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.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%9 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%10 = icmp sgt i64 %9, 0
%11 = zext i1 %10 to i32
%12 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %11, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 235, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, 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.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%13 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%14 = lshr i64 %13, 63
%15 = trunc i64 %14 to i32
%16 = xor i32 %15, 1
%17 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %16, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 236, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, 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.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%18 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%19 = lshr i64 %18, 63
%20 = trunc i64 %19 to i32
%21 = xor i32 %20, 1
%22 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %21, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 237, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, 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.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%23 = tail call i64 @strcmp(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%24 = lshr i64 %23, 63
%25 = trunc i64 %24 to i32
%26 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %25, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 238, i8* getelementptr inbounds ([34 x i8], [34 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 ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%27 = tail call i64 @strcmp(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%28 = icmp slt i64 %27, 1
%29 = zext i1 %28 to i32
%30 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %29, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 239, i8* getelementptr inbounds ([34 x i8], [34 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 ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%31 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%32 = icmp slt i64 %31, 1
%33 = zext i1 %32 to i32
%34 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %33, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 240, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%35 = tail call i64 (...) @ctest_toggle_inversion()
%36 = icmp eq i64 %35, 0
br i1 %36, label %73, label %37
37: ; preds = %0, %37
%38 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%39 = icmp eq i64 %38, 0
%40 = zext i1 %39 to i32
%41 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %40, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 243, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 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.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%42 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%43 = icmp ne i64 %42, 0
%44 = zext i1 %43 to i32
%45 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %44, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 244, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, 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.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%46 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%47 = icmp sgt i64 %46, 0
%48 = zext i1 %47 to i32
%49 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %48, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 245, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, 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.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%50 = tail call i64 @strcmp(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%51 = icmp sgt i64 %50, 0
%52 = zext i1 %51 to i32
%53 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %52, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 246, i8* getelementptr inbounds ([34 x i8], [34 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 ([3 x i8], [3 x i8]* @.str.10, 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.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%54 = tail call i64 @strcmp(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%55 = lshr i64 %54, 63
%56 = trunc i64 %55 to i32
%57 = xor i32 %56, 1
%58 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %57, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 247, i8* getelementptr inbounds ([34 x i8], [34 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 ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%59 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%60 = lshr i64 %59, 63
%61 = trunc i64 %60 to i32
%62 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %61, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 248, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%63 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%64 = lshr i64 %63, 63
%65 = trunc i64 %64 to i32
%66 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %65, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 249, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, 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.7, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%67 = tail call i64 @strcmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%68 = icmp slt i64 %67, 1
%69 = zext i1 %68 to i32
%70 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 %69, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 250, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, 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.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%71 = tail call i64 (...) @ctest_toggle_inversion()
%72 = icmp eq i64 %71, 0
br i1 %72, label %73, label %37
73: ; preds = %37, %0
%74 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 253, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
%75 = tail call i64 (...) @ctest_toggle_inversion()
%76 = icmp eq i64 %75, 0
br i1 %76, label %82, label %77
77: ; preds = %73, %77
%78 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 255, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%79 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 256, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.19, i64 0, i64 0))
%80 = tail call i64 (...) @ctest_toggle_inversion()
%81 = icmp eq i64 %80, 0
br i1 %81, label %82, label %77
82: ; preds = %77, %73
%83 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 1, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 259, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%84 = tail call i64 (...) @ctest_toggle_inversion()
%85 = icmp eq i64 %84, 0
br i1 %85, label %91, label %86
86: ; preds = %82, %86
%87 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 261, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
%88 = tail call i32 (i32, i8*, i32, i8*, ...) @ctest_assert_fmt(i32 0, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.3, i64 0, i64 0), i32 262, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
%89 = tail call i64 (...) @ctest_toggle_inversion()
%90 = icmp eq i64 %89, 0
br i1 %90, label %91, label %86
91: ; preds = %86, %82
ret void
}