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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ isprint(unsigned char);
scalar_t__ strcmp(char const *, char const *);
int subtest_level();
int /*<<< orphan*/ test_diff_header(char const *, char const *);
int /*<<< orphan*/ test_fail_message_prefix(char const *, char const *, int,
                                            char const *, char const *,
                                            char const *, char const *);
int /*<<< orphan*/ test_flush_stderr();
int /*<<< orphan*/ test_printf_stderr(char *, ...);
int /*<<< orphan*/ test_string_null_empty(char const *, char);
void test_fail_string_common(const char *prefix, const char *file, int line,
                             const char *type, const char *left,
                             const char *right, const char *op, const char *m1,
                             size_t l1, const char *m2, size_t l2) {
  const size_t width = ((80) - subtest_level() - 12) / 16 * 16;
  char b1[(80) + 1], b2[(80) + 1];
  char bdiff[(80) + 1];
  size_t n1, n2, i;
  unsigned int cnt = 0, diff;
  test_fail_message_prefix(prefix, file, line, type, left, right, op);
  if (m1 == NULL)
    l1 = 0;
  if (m2 == NULL)
    l2 = 0;
  if (l1 == 0 && l2 == 0) {
    if ((m1 == NULL) == (m2 == NULL)) {
      test_string_null_empty(m1, ' ');
    } else {
      test_diff_header(left, right);
      test_string_null_empty(m1, '-');
      test_string_null_empty(m2, '+');
    }
    goto fin;
  }
  if (l1 != l2 || strcmp(m1, m2) != 0)
    test_diff_header(left, right);
  while (l1 > 0 || l2 > 0) {
    n1 = n2 = 0;
    if (l1 > 0) {
      b1[n1 = l1 > width ? width : l1] = 0;
      for (i = 0; i < n1; i++)
        b1[i] = isprint((unsigned char)m1[i]) ? m1[i] : '.';
    }
    if (l2 > 0) {
      b2[n2 = l2 > width ? width : l2] = 0;
      for (i = 0; i < n2; i++)
        b2[i] = isprint((unsigned char)m2[i]) ? m2[i] : '.';
    }
    diff = 0;
    i = 0;
    if (n1 > 0 && n2 > 0) {
      const size_t j = n1 < n2 ? n1 : n2;
      for (; i < j; i++)
        if (m1[i] == m2[i]) {
          bdiff[i] = ' ';
        } else {
          bdiff[i] = '^';
          diff = 1;
        }
      bdiff[i] = '\0';
    }
    if (n1 == n2 && !diff) {
      test_printf_stderr("% 4u:  '%s'\n", cnt, n2 > n1 ? b2 : b1);
    } else {
      if (cnt == 0 && (m1 == NULL || *m1 == '\0'))
        test_string_null_empty(m1, '-');
      else if (n1 > 0)
        test_printf_stderr("% 4u:- '%s'\n", cnt, b1);
      if (cnt == 0 && (m2 == NULL || *m2 == '\0'))
        test_string_null_empty(m2, '+');
      else if (n2 > 0)
        test_printf_stderr("% 4u:+ '%s'\n", cnt, b2);
      if (diff && i > 0)
        test_printf_stderr("% 4s    %s\n", "", bdiff);
    }
    m1 += n1;
    m2 += n2;
    l1 -= n1;
    l2 -= n2;
    cnt += width;
  }
fin:
  test_flush_stderr();
}


x86 assembly (clang, -O0):
<test_fail_string_common>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    $0x0,%al
call   1090 <subtest_level@plt>
mov    %eax,%ecx
mov    $0x50,%eax
sub    %ecx,%eax
sub    $0xc,%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
shl    $0x4,%eax
cltq
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x16c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
mov    0x10(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <test_fail_message_prefix@plt>
cmpq   $0x0,0x18(%rbp)
jne    121b <test_fail_string_common+0x9b>
movq   $0x0,0x20(%rbp)
cmpq   $0x0,0x28(%rbp)
jne    122e <test_fail_string_common+0xae>
movq   $0x0,0x30(%rbp)
cmpq   $0x0,0x20(%rbp)
jne    12a8 <test_fail_string_common+0x128>
cmpq   $0x0,0x30(%rbp)
jne    12a8 <test_fail_string_common+0x128>
cmpq   $0x0,0x18(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%eax
cmpq   $0x0,0x28(%rbp)
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
cmp    %ecx,%eax
jne    127a <test_fail_string_common+0xfa>
mov    0x18(%rbp),%rdi
mov    $0x20,%esi
call   1040 <test_string_null_empty@plt>
jmp    12a3 <test_fail_string_common+0x123>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1060 <test_diff_header@plt>
mov    0x18(%rbp),%rdi
mov    $0x2d,%esi
call   1040 <test_string_null_empty@plt>
mov    0x28(%rbp),%rdi
mov    $0x2b,%esi
call   1040 <test_string_null_empty@plt>
jmp    17e4 <test_fail_string_common+0x664>
mov    0x20(%rbp),%rax
cmp    0x30(%rbp),%rax
jne    12cd <test_fail_string_common+0x14d>
mov    0x18(%rbp),%rdi
mov    0x28(%rbp),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
je     12da <test_fail_string_common+0x15a>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1060 <test_diff_header@plt>
jmp    12df <test_fail_string_common+0x15f>
mov    $0x1,%al
cmpq   $0x0,0x20(%rbp)
mov    %al,-0x179(%rbp)
ja     1300 <test_fail_string_common+0x180>
cmpq   $0x0,0x30(%rbp)
seta   %al
mov    %al,-0x179(%rbp)
mov    -0x179(%rbp),%al
test   $0x1,%al
jne    1313 <test_fail_string_common+0x193>
jmp    17df <test_fail_string_common+0x65f>
movq   $0x0,-0x160(%rbp)
movq   $0x0,-0x158(%rbp)
cmpq   $0x0,0x20(%rbp)
jbe    140c <test_fail_string_common+0x28c>
mov    0x20(%rbp),%rax
cmp    -0x38(%rbp),%rax
jbe    1352 <test_fail_string_common+0x1d2>
mov    -0x38(%rbp),%rax
mov    %rax,-0x188(%rbp)
jmp    135d <test_fail_string_common+0x1dd>
mov    0x20(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x188(%rbp),%rax
mov    %rax,-0x158(%rbp)
movb   $0x0,-0x90(%rbp,%rax,1)
movq   $0x0,-0x168(%rbp)
mov    -0x168(%rbp),%rax
cmp    -0x158(%rbp),%rax
jae    1407 <test_fail_string_common+0x287>
mov    0x18(%rbp),%rax
mov    -0x168(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   10a0 <isprint@plt>
cmp    $0x0,%rax
je     13ca <test_fail_string_common+0x24a>
mov    0x18(%rbp),%rax
mov    -0x168(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x18c(%rbp)
jmp    13da <test_fail_string_common+0x25a>
mov    $0x2e,%eax
mov    %eax,-0x18c(%rbp)
jmp    13da <test_fail_string_common+0x25a>
mov    -0x18c(%rbp),%eax
mov    %al,%cl
mov    -0x168(%rbp),%rax
mov    %cl,-0x90(%rbp,%rax,1)
mov    -0x168(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
jmp    137e <test_fail_string_common+0x1fe>
jmp    140c <test_fail_string_common+0x28c>
cmpq   $0x0,0x30(%rbp)
jbe    14ef <test_fail_string_common+0x36f>
mov    0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jbe    1435 <test_fail_string_common+0x2b5>
mov    -0x38(%rbp),%rax
mov    %rax,-0x198(%rbp)
jmp    1440 <test_fail_string_common+0x2c0>
mov    0x30(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0x198(%rbp),%rax
mov    %rax,-0x160(%rbp)
movb   $0x0,-0xf0(%rbp,%rax,1)
movq   $0x0,-0x168(%rbp)
mov    -0x168(%rbp),%rax
cmp    -0x160(%rbp),%rax
jae    14ea <test_fail_string_common+0x36a>
mov    0x28(%rbp),%rax
mov    -0x168(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   10a0 <isprint@plt>
cmp    $0x0,%rax
je     14ad <test_fail_string_common+0x32d>
mov    0x28(%rbp),%rax
mov    -0x168(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x19c(%rbp)
jmp    14bd <test_fail_string_common+0x33d>
mov    $0x2e,%eax
mov    %eax,-0x19c(%rbp)
jmp    14bd <test_fail_string_common+0x33d>
mov    -0x19c(%rbp),%eax
mov    %al,%cl
mov    -0x168(%rbp),%rax
mov    %cl,-0xf0(%rbp,%rax,1)
mov    -0x168(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
jmp    1461 <test_fail_string_common+0x2e1>
jmp    14ef <test_fail_string_common+0x36f>
movl   $0x0,-0x170(%rbp)
movq   $0x0,-0x168(%rbp)
cmpq   $0x0,-0x158(%rbp)
jbe    15f5 <test_fail_string_common+0x475>
cmpq   $0x0,-0x160(%rbp)
jbe    15f5 <test_fail_string_common+0x475>
mov    -0x158(%rbp),%rax
cmp    -0x160(%rbp),%rax
jae    1547 <test_fail_string_common+0x3c7>
mov    -0x158(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
jmp    1555 <test_fail_string_common+0x3d5>
mov    -0x160(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x1a8(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x168(%rbp),%rax
cmp    -0x178(%rbp),%rax
jae    15e6 <test_fail_string_common+0x466>
mov    0x18(%rbp),%rax
mov    -0x168(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    0x28(%rbp),%rcx
mov    -0x168(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    15b1 <test_fail_string_common+0x431>
mov    -0x168(%rbp),%rax
movb   $0x20,-0x150(%rbp,%rax,1)
20
jmp    15ca <test_fail_string_common+0x44a>
mov    -0x168(%rbp),%rax
movb   $0x5e,-0x150(%rbp,%rax,1)
5e
movl   $0x1,-0x170(%rbp)
jmp    15cf <test_fail_string_common+0x44f>
mov    -0x168(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
jmp    1563 <test_fail_string_common+0x3e3>
mov    -0x168(%rbp),%rax
movb   $0x0,-0x150(%rbp,%rax,1)
mov    -0x158(%rbp),%rax
cmp    -0x160(%rbp),%rax
jne    1677 <test_fail_string_common+0x4f7>
cmpl   $0x0,-0x170(%rbp)
jne    1677 <test_fail_string_common+0x4f7>
mov    -0x16c(%rbp),%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x160(%rbp),%rax
cmp    -0x158(%rbp),%rax
jbe    1649 <test_fail_string_common+0x4c9>
lea    -0xf0(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
jmp    1657 <test_fail_string_common+0x4d7>
lea    -0x90(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x1ac(%rbp),%esi
mov    -0x1b8(%rbp),%rdx
lea    0x995(%rip),%rdi
mov    $0x0,%al
call   1070 <test_printf_stderr@plt>
jmp    1785 <test_fail_string_common+0x605>
cmpl   $0x0,-0x16c(%rbp)
jne    16b2 <test_fail_string_common+0x532>
cmpq   $0x0,0x18(%rbp)
je     169f <test_fail_string_common+0x51f>
mov    0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    16b2 <test_fail_string_common+0x532>
mov    0x18(%rbp),%rdi
mov    $0x2d,%esi
call   1040 <test_string_null_empty@plt>
jmp    16e0 <test_fail_string_common+0x560>
cmpq   $0x0,-0x158(%rbp)
jbe    16db <test_fail_string_common+0x55b>
mov    -0x16c(%rbp),%esi
lea    -0x90(%rbp),%rdx
lea    0x939(%rip),%rdi
mov    $0x0,%al
call   1070 <test_printf_stderr@plt>
jmp    16e0 <test_fail_string_common+0x560>
cmpl   $0x0,-0x16c(%rbp)
jne    171b <test_fail_string_common+0x59b>
cmpq   $0x0,0x28(%rbp)
je     1708 <test_fail_string_common+0x588>
mov    0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    171b <test_fail_string_common+0x59b>
mov    0x28(%rbp),%rdi
mov    $0x2b,%esi
call   1040 <test_string_null_empty@plt>
jmp    1749 <test_fail_string_common+0x5c9>
cmpq   $0x0,-0x160(%rbp)
jbe    1744 <test_fail_string_common+0x5c4>
mov    -0x16c(%rbp),%esi
lea    -0xf0(%rbp),%rdx
lea    0x8dd(%rip),%rdi
mov    $0x0,%al
call   1070 <test_printf_stderr@plt>
jmp    1749 <test_fail_string_common+0x5c9>
cmpl   $0x0,-0x170(%rbp)
je     1780 <test_fail_string_common+0x600>
cmpq   $0x0,-0x168(%rbp)
jbe    1780 <test_fail_string_common+0x600>
lea    -0x150(%rbp),%rdx
lea    0x8b5(%rip),%rdi
lea    0x893(%rip),%rsi
mov    $0x0,%al
call   1070 <test_printf_stderr@plt>
jmp    1785 <test_fail_string_common+0x605>
mov    -0x158(%rbp),%rax
add    0x18(%rbp),%rax
mov    %rax,0x18(%rbp)
mov    -0x160(%rbp),%rax
add    0x28(%rbp),%rax
mov    %rax,0x28(%rbp)
mov    -0x158(%rbp),%rcx
mov    0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,0x20(%rbp)
mov    -0x160(%rbp),%rcx
mov    0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,0x30(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x16c(%rbp),%eax
add    %rcx,%rax
mov    %eax,-0x16c(%rbp)
jmp    12df <test_fail_string_common+0x15f>
jmp    17e4 <test_fail_string_common+0x664>
mov    $0x0,%al
call   1050 <test_flush_stderr@plt>
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_fail_string_common>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,%r13
mov    %r8,0x10(%rsp)
mov    %rcx,0x20(%rsp)
mov    %edx,%ebp
mov    %rsi,%r15
mov    %rdi,%rbx
mov    0x1a8(%rsp),%r14
mov    0x198(%rsp),%r12
xor    %eax,%eax
call   1090 <subtest_level@plt>
mov    $0x44,%ecx
sub    %eax,%ecx
mov    $0x53,%edx
sub    %eax,%edx
test   %ecx,%ecx
cmovns %ecx,%edx
mov    %edx,0x1c(%rsp)
mov    0x190(%rsp),%rax
mov    %rax,(%rsp)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r13,%r15
mov    %ebp,%edx
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%rcx
mov    %rbp,%r8
mov    %r13,%r9
call   1030 <test_fail_message_prefix@plt>
mov    %r12,%r13
test   %r12,%r12
je     1210 <test_fail_string_common+0x90>
mov    0x1a0(%rsp),%r13
mov    %r14,%rbx
test   %r14,%r14
je     1220 <test_fail_string_common+0xa0>
mov    0x1b0(%rsp),%rbx
mov    %rbx,%rax
or     %r13,%rax
je     1561 <test_fail_string_common+0x3e1>
andl   $0xfffffff0,0x1c(%rsp)
cmp    %rbx,%r13
jne    1246 <test_fail_string_common+0xc6>
mov    %r12,%rdi
mov    %r14,%rsi
call   1080 <strcmp@plt>
test   %rax,%rax
je     1251 <test_fail_string_common+0xd1>
mov    %rbp,%rdi
mov    %r15,%rsi
call   1060 <test_diff_header@plt>
movslq 0x1c(%rsp),%rax
mov    %rax,0x30(%rsp)
test   %rbx,%rbx
setne  %bpl
test   %r13,%r13
setne  %al
movl   $0x0,0x10(%rsp)
jmp    12d5 <test_fail_string_common+0x155>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0xd79(%rip),%rdi
mov    0x10(%rsp),%esi
lea    0xa0(%rsp),%rdx
xor    %eax,%eax
call   1070 <test_printf_stderr@plt>
mov    0x38(%rsp),%r13
mov    0x20(%rsp),%rbx
add    %r15,%r12
add    %rbp,%r14
sub    %r15,%r13
sub    %rbp,%rbx
mov    0x10(%rsp),%eax
add    0x1c(%rsp),%eax
mov    %eax,0x10(%rsp)
test   %r13,%r13
setne  %al
test   %rbx,%rbx
setne  %bpl
mov    %r13,%rcx
or     %rbx,%rcx
je     15a0 <test_fail_string_common+0x420>
test   $0x1,%al
mov    %rbx,0x20(%rsp)
je     1330 <test_fail_string_common+0x1b0>
mov    0x30(%rsp),%rax
cmp    %rax,%r13
mov    %r13,%r15
cmova  %rax,%r15
movb   $0x0,0xa0(%rsp,%r15,1)
test   %r15,%r15
je     1330 <test_fail_string_common+0x1b0>
xor    %ebx,%ebx
jmp    1315 <test_fail_string_common+0x195>
nop
movzbl (%r12,%rbx,1),%eax
mov    %al,0xa0(%rsp,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r15
je     1340 <test_fail_string_common+0x1c0>
movzbl (%r12,%rbx,1),%edi
call   10a0 <isprint@plt>
test   %rax,%rax
jne    1300 <test_fail_string_common+0x180>
mov    $0x2e,%al
jmp    1305 <test_fail_string_common+0x185>
nopl   0x0(%rax,%rax,1)
xor    %r15d,%r15d
jmp    1345 <test_fail_string_common+0x1c5>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%rbx
test   $0x1,%bpl
mov    %r13,0x38(%rsp)
je     13a0 <test_fail_string_common+0x220>
mov    0x30(%rsp),%rax
cmp    %rax,%rbx
mov    %rbx,%rbp
cmova  %rax,%rbp
movb   $0x0,0x100(%rsp,%rbp,1)
test   %rbp,%rbp
je     13a0 <test_fail_string_common+0x220>
xor    %ebx,%ebx
jmp    1385 <test_fail_string_common+0x205>
movzbl (%r14,%rbx,1),%eax
mov    %al,0x100(%rsp,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%rbp
je     1400 <test_fail_string_common+0x280>
movzbl (%r14,%rbx,1),%edi
call   10a0 <isprint@plt>
test   %rax,%rax
jne    1370 <test_fail_string_common+0x1f0>
mov    $0x2e,%al
jmp    1375 <test_fail_string_common+0x1f5>
nopl   0x0(%rax,%rax,1)
test   %r15,%r15
setne  %al
xor    %ecx,%ecx
xor    %ebp,%ebp
xor    %ebx,%ebx
xor    %r13d,%r13d
cmp    %rbp,%r15
jne    13bd <test_fail_string_common+0x23d>
test   %r13d,%r13d
je     1280 <test_fail_string_common+0x100>
cmpl   $0x0,0x10(%rsp)
je     142a <test_fail_string_common+0x2aa>
test   %al,%al
je     13ec <test_fail_string_common+0x26c>
lea    0xc3e(%rip),%rdi
mov    0x10(%rsp),%esi
lea    0xa0(%rsp),%rdx
xor    %eax,%eax
mov    %rcx,0x28(%rsp)
call   1070 <test_printf_stderr@plt>
mov    0x28(%rsp),%rcx
cmpl   $0x0,0x10(%rsp)
jne    1458 <test_fail_string_common+0x2d8>
test   %r14,%r14
jne    1452 <test_fail_string_common+0x2d2>
jmp    1478 <test_fail_string_common+0x2f8>
nopw   0x0(%rax,%rax,1)
test   %r15,%r15
setne  %al
je     14bf <test_fail_string_common+0x33f>
cmp    %rbp,%r15
mov    %rbp,%r8
cmovb  %r15,%r8
cmp    $0x1,%r8
jne    14c8 <test_fail_string_common+0x348>
xor    %r13d,%r13d
xor    %ecx,%ecx
jmp    151f <test_fail_string_common+0x39f>
test   %r12,%r12
je     1436 <test_fail_string_common+0x2b6>
cmpb   $0x0,(%r12)
jne    13c4 <test_fail_string_common+0x244>
mov    %r12,%rdi
mov    $0x2d,%esi
mov    %rcx,0x28(%rsp)
call   1040 <test_string_null_empty@plt>
mov    0x28(%rsp),%rcx
test   %r14,%r14
je     1478 <test_fail_string_common+0x2f8>
cmpb   $0x0,(%r14)
je     1478 <test_fail_string_common+0x2f8>
test   %cl,%cl
je     1485 <test_fail_string_common+0x305>
lea    0xbb7(%rip),%rdi
mov    0x10(%rsp),%esi
lea    0x100(%rsp),%rdx
xor    %eax,%eax
call   1070 <test_printf_stderr@plt>
jmp    1485 <test_fail_string_common+0x305>
mov    %r14,%rdi
mov    $0x2b,%esi
call   1040 <test_string_null_empty@plt>
test   %r13d,%r13d
sete   %al
xor    $0x1,%bl
or     %al,%bl
mov    0x38(%rsp),%r13
mov    0x20(%rsp),%rbx
jne    12a4 <test_fail_string_common+0x124>
lea    0xb80(%rip),%rdi
lea    0xb5e(%rip),%rsi
lea    0x40(%rsp),%rdx
xor    %eax,%eax
call   1070 <test_printf_stderr@plt>
jmp    12a4 <test_fail_string_common+0x124>
xor    %ebx,%ebx
mov    $0x1,%cl
jmp    13ac <test_fail_string_common+0x22c>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %r13d,%r13d
xor    %ecx,%ecx
mov    $0x20,%edi
mov    $0x1,%eax
xchg   %ax,%ax
movzbl (%r12,%rcx,1),%ebx
cmp    (%r14,%rcx,1),%bl
mov    $0x5e,%esi
cmove  %edi,%esi
mov    %sil,0x40(%rsp,%rcx,1)
cmovne %eax,%r13d
movzbl 0x1(%r12,%rcx,1),%ebx
cmp    0x1(%r14,%rcx,1),%bl
mov    $0x5e,%esi
cmove  %edi,%esi
cmovne %eax,%r13d
mov    %sil,0x41(%rsp,%rcx,1)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    14e0 <test_fail_string_common+0x360>
mov    $0x1,%eax
mov    $0x20,%esi
test   $0x1,%r8b
je     1547 <test_fail_string_common+0x3c7>
mov    (%r12,%rcx,1),%dl
cmp    (%r14,%rcx,1),%dl
mov    $0x5e,%edx
cmove  %esi,%edx
cmovne %eax,%r13d
mov    %dl,0x40(%rsp,%rcx,1)
movb   $0x0,0x40(%rsp,%r8,1)
mov    $0x1,%cl
mov    $0x1,%al
mov    $0x1,%bl
cmp    %rbp,%r15
je     13b4 <test_fail_string_common+0x234>
jmp    13bd <test_fail_string_common+0x23d>
test   %r14,%r14
sete   %al
test   %r12,%r12
sete   %cl
xor    %al,%cl
je     1593 <test_fail_string_common+0x413>
mov    %rbp,%rdi
mov    %r15,%rsi
call   1060 <test_diff_header@plt>
mov    %r12,%rdi
mov    $0x2d,%esi
call   1040 <test_string_null_empty@plt>
mov    %r14,%rdi
mov    $0x2b,%esi
jmp    159b <test_fail_string_common+0x41b>
mov    %r12,%rdi
mov    $0x20,%esi
call   1040 <test_string_null_empty@plt>
xor    %eax,%eax
call   1050 <test_flush_stderr@plt>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [13 x i8] c"% 4u: '%s'\0A\00"
@.str.1 = [13 x i8] c"% 4u:- '%s'\0A\00"
@.str.2 = [13 x i8] c"% 4u:+ '%s'\0A\00"
@.str.3 = [12 x i8] c"% 4s %s\0A\00"
@.str.4 = [1 x i8] zeroinitializer
define void @test_fail_string_common(i8* %0, i8* %1, i32 %2, i8* %3, i8* %4, i8* %5, i8* %6, i8* %7, i64 %8, i8* %9, i64 %10) {
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i32
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i64
%21 = alloca i8*
%22 = alloca i64
%23 = alloca i64
%24 = alloca [81 x i8]
%25 = alloca [81 x i8]
%26 = alloca [81 x i8]
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i32
%31 = alloca i32
%32 = alloca i64
store i8* %0, i8** %12
store i8* %1, i8** %13
store i32 %2, i32* %14
store i8* %3, i8** %15
store i8* %4, i8** %16
store i8* %5, i8** %17
store i8* %6, i8** %18
store i8* %7, i8** %19
store i64 %8, i64* %20
store i8* %9, i8** %21
store i64 %10, i64* %22
%33 = call i32 (...) @subtest_level()
%34 = sub nsw i32 80, %33
%35 = sub nsw i32 %34, 12
%36 = sdiv i32 %35, 16
%37 = mul nsw i32 %36, 16
%38 = sext i32 %37 to i64
store i64 %38, i64* %23
store i32 0, i32* %30
%39 = load i8*, i8** %12
%40 = load i8*, i8** %13
%41 = load i32, i32* %14
%42 = load i8*, i8** %15
%43 = load i8*, i8** %16
%44 = load i8*, i8** %17
%45 = load i8*, i8** %18
%46 = call i32 @test_fail_message_prefix(i8* %39, i8* %40, i32 %41, i8* %42, i8* %43, i8* %44, i8* %45)
%47 = load i8*, i8** %19
%48 = icmp eq i8* %47, null
br i1 %48, label %49, label %50
49: ; preds = %11
store i64 0, i64* %20
br label %50
50: ; preds = %49, %11
%51 = load i8*, i8** %21
%52 = icmp eq i8* %51, null
br i1 %52, label %53, label %54
53: ; preds = %50
store i64 0, i64* %22
br label %54
54: ; preds = %53, %50
%55 = load i64, i64* %20
%56 = icmp eq i64 %55, 0
br i1 %56, label %57, label %80
57: ; preds = %54
%58 = load i64, i64* %22
%59 = icmp eq i64 %58, 0
br i1 %59, label %60, label %80
60: ; preds = %57
%61 = load i8*, i8** %19
%62 = icmp eq i8* %61, null
%63 = zext i1 %62 to i32
%64 = load i8*, i8** %21
%65 = icmp eq i8* %64, null
%66 = zext i1 %65 to i32
%67 = icmp eq i32 %63, %66
br i1 %67, label %68, label %71
68: ; preds = %60
%69 = load i8*, i8** %19
%70 = call i32 @test_string_null_empty(i8* %69, i8 signext 32)
br label %79
71: ; preds = %60
%72 = load i8*, i8** %16
%73 = load i8*, i8** %17
%74 = call i32 @test_diff_header(i8* %72, i8* %73)
%75 = load i8*, i8** %19
%76 = call i32 @test_string_null_empty(i8* %75, i8 signext 45)
%77 = load i8*, i8** %21
%78 = call i32 @test_string_null_empty(i8* %77, i8 signext 43)
br label %79
79: ; preds = %71, %68
br label %321
80: ; preds = %57, %54
%81 = load i64, i64* %20
%82 = load i64, i64* %22
%83 = icmp ne i64 %81, %82
br i1 %83, label %89, label %84
84: ; preds = %80
%85 = load i8*, i8** %19
%86 = load i8*, i8** %21
%87 = call i64 @strcmp(i8* %85, i8* %86)
%88 = icmp ne i64 %87, 0
br i1 %88, label %89, label %93
89: ; preds = %84, %80
%90 = load i8*, i8** %16
%91 = load i8*, i8** %17
%92 = call i32 @test_diff_header(i8* %90, i8* %91)
br label %93
93: ; preds = %89, %84
br label %94
94: ; preds = %302, %93
%95 = load i64, i64* %20
%96 = icmp ugt i64 %95, 0
br i1 %96, label %100, label %97
97: ; preds = %94
%98 = load i64, i64* %22
%99 = icmp ugt i64 %98, 0
br label %100
100: ; preds = %97, %94
%101 = phi i1 [ true, %94 ], [ %99, %97 ]
br i1 %101, label %102, label %320
102: ; preds = %100
store i64 0, i64* %28
store i64 0, i64* %27
%103 = load i64, i64* %20
%104 = icmp ugt i64 %103, 0
br i1 %104, label %105, label %143
105: ; preds = %102
%106 = load i64, i64* %20
%107 = load i64, i64* %23
%108 = icmp ugt i64 %106, %107
br i1 %108, label %109, label %111
109: ; preds = %105
%110 = load i64, i64* %23
br label %113
111: ; preds = %105
%112 = load i64, i64* %20
br label %113
113: ; preds = %111, %109
%114 = phi i64 [ %110, %109 ], [ %112, %111 ]
store i64 %114, i64* %27
%115 = getelementptr inbounds [81 x i8], [81 x i8]* %24, i64 0, i64 %114
store i8 0, i8* %115
store i64 0, i64* %29
br label %116
116: ; preds = %139, %113
%117 = load i64, i64* %29
%118 = load i64, i64* %27
%119 = icmp ult i64 %117, %118
br i1 %119, label %120, label %142
120: ; preds = %116
%121 = load i8*, i8** %19
%122 = load i64, i64* %29
%123 = getelementptr inbounds i8, i8* %121, i64 %122
%124 = load i8, i8* %123
%125 = call i64 @isprint(i8 zeroext %124)
%126 = icmp ne i64 %125, 0
br i1 %126, label %127, label %133
127: ; preds = %120
%128 = load i8*, i8** %19
%129 = load i64, i64* %29
%130 = getelementptr inbounds i8, i8* %128, i64 %129
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
br label %134
133: ; preds = %120
br label %134
134: ; preds = %133, %127
%135 = phi i32 [ %132, %127 ], [ 46, %133 ]
%136 = trunc i32 %135 to i8
%137 = load i64, i64* %29
%138 = getelementptr inbounds [81 x i8], [81 x i8]* %24, i64 0, i64 %137
store i8 %136, i8* %138
br label %139
139: ; preds = %134
%140 = load i64, i64* %29
%141 = add i64 %140, 1
store i64 %141, i64* %29
br label %116
142: ; preds = %116
br label %143
143: ; preds = %142, %102
%144 = load i64, i64* %22
%145 = icmp ugt i64 %144, 0
br i1 %145, label %146, label %184
146: ; preds = %143
%147 = load i64, i64* %22
%148 = load i64, i64* %23
%149 = icmp ugt i64 %147, %148
br i1 %149, label %150, label %152
150: ; preds = %146
%151 = load i64, i64* %23
br label %154
152: ; preds = %146
%153 = load i64, i64* %22
br label %154
154: ; preds = %152, %150
%155 = phi i64 [ %151, %150 ], [ %153, %152 ]
store i64 %155, i64* %28
%156 = getelementptr inbounds [81 x i8], [81 x i8]* %25, i64 0, i64 %155
store i8 0, i8* %156
store i64 0, i64* %29
br label %157
157: ; preds = %180, %154
%158 = load i64, i64* %29
%159 = load i64, i64* %28
%160 = icmp ult i64 %158, %159
br i1 %160, label %161, label %183
161: ; preds = %157
%162 = load i8*, i8** %21
%163 = load i64, i64* %29
%164 = getelementptr inbounds i8, i8* %162, i64 %163
%165 = load i8, i8* %164
%166 = call i64 @isprint(i8 zeroext %165)
%167 = icmp ne i64 %166, 0
br i1 %167, label %168, label %174
168: ; preds = %161
%169 = load i8*, i8** %21
%170 = load i64, i64* %29
%171 = getelementptr inbounds i8, i8* %169, i64 %170
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
br label %175
174: ; preds = %161
br label %175
175: ; preds = %174, %168
%176 = phi i32 [ %173, %168 ], [ 46, %174 ]
%177 = trunc i32 %176 to i8
%178 = load i64, i64* %29
%179 = getelementptr inbounds [81 x i8], [81 x i8]* %25, i64 0, i64 %178
store i8 %177, i8* %179
br label %180
180: ; preds = %175
%181 = load i64, i64* %29
%182 = add i64 %181, 1
store i64 %182, i64* %29
br label %157
183: ; preds = %157
br label %184
184: ; preds = %183, %143
store i32 0, i32* %31
store i64 0, i64* %29
%185 = load i64, i64* %27
%186 = icmp ugt i64 %185, 0
br i1 %186, label %187, label %229
187: ; preds = %184
%188 = load i64, i64* %28
%189 = icmp ugt i64 %188, 0
br i1 %189, label %190, label %229
190: ; preds = %187
%191 = load i64, i64* %27
%192 = load i64, i64* %28
%193 = icmp ult i64 %191, %192
br i1 %193, label %194, label %196
194: ; preds = %190
%195 = load i64, i64* %27
br label %198
196: ; preds = %190
%197 = load i64, i64* %28
br label %198
198: ; preds = %196, %194
%199 = phi i64 [ %195, %194 ], [ %197, %196 ]
store i64 %199, i64* %32
br label %200
200: ; preds = %223, %198
%201 = load i64, i64* %29
%202 = load i64, i64* %32
%203 = icmp ult i64 %201, %202
br i1 %203, label %204, label %226
204: ; preds = %200
%205 = load i8*, i8** %19
%206 = load i64, i64* %29
%207 = getelementptr inbounds i8, i8* %205, i64 %206
%208 = load i8, i8* %207
%209 = sext i8 %208 to i32
%210 = load i8*, i8** %21
%211 = load i64, i64* %29
%212 = getelementptr inbounds i8, i8* %210, i64 %211
%213 = load i8, i8* %212
%214 = sext i8 %213 to i32
%215 = icmp eq i32 %209, %214
br i1 %215, label %216, label %219
216: ; preds = %204
%217 = load i64, i64* %29
%218 = getelementptr inbounds [81 x i8], [81 x i8]* %26, i64 0, i64 %217
store i8 32, i8* %218
br label %222
219: ; preds = %204
%220 = load i64, i64* %29
%221 = getelementptr inbounds [81 x i8], [81 x i8]* %26, i64 0, i64 %220
store i8 94, i8* %221
store i32 1, i32* %31
br label %222
222: ; preds = %219, %216
br label %223
223: ; preds = %222
%224 = load i64, i64* %29
%225 = add i64 %224, 1
store i64 %225, i64* %29
br label %200
226: ; preds = %200
%227 = load i64, i64* %29
%228 = getelementptr inbounds [81 x i8], [81 x i8]* %26, i64 0, i64 %227
store i8 0, i8* %228
br label %229
229: ; preds = %226, %187, %184
%230 = load i64, i64* %27
%231 = load i64, i64* %28
%232 = icmp eq i64 %230, %231
br i1 %232, label %233, label %248
233: ; preds = %229
%234 = load i32, i32* %31
%235 = icmp ne i32 %234, 0
br i1 %235, label %248, label %236
236: ; preds = %233
%237 = load i32, i32* %30
%238 = load i64, i64* %28
%239 = load i64, i64* %27
%240 = icmp ugt i64 %238, %239
br i1 %240, label %241, label %243
241: ; preds = %236
%242 = getelementptr inbounds [81 x i8], [81 x i8]* %25, i64 0, i64 0
br label %245
243: ; preds = %236
%244 = getelementptr inbounds [81 x i8], [81 x i8]* %24, i64 0, i64 0
br label %245
245: ; preds = %243, %241
%246 = phi i8* [ %242, %241 ], [ %244, %243 ]
%247 = call i32 (i8*, ...) @test_printf_stderr(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 %237, i8* %246)
br label %302
248: ; preds = %233, %229
%249 = load i32, i32* %30
%250 = icmp eq i32 %249, 0
br i1 %250, label %251, label %262
251: ; preds = %248
%252 = load i8*, i8** %19
%253 = icmp eq i8* %252, null
br i1 %253, label %259, label %254
254: ; preds = %251
%255 = load i8*, i8** %19
%256 = load i8, i8* %255
%257 = sext i8 %256 to i32
%258 = icmp eq i32 %257, 0
br i1 %258, label %259, label %262
259: ; preds = %254, %251
%260 = load i8*, i8** %19
%261 = call i32 @test_string_null_empty(i8* %260, i8 signext 45)
br label %270
262: ; preds = %254, %248
%263 = load i64, i64* %27
%264 = icmp ugt i64 %263, 0
br i1 %264, label %265, label %269
265: ; preds = %262
%266 = load i32, i32* %30
%267 = getelementptr inbounds [81 x i8], [81 x i8]* %24, i64 0, i64 0
%268 = call i32 (i8*, ...) @test_printf_stderr(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 %266, i8* %267)
br label %269
269: ; preds = %265, %262
br label %270
270: ; preds = %269, %259
%271 = load i32, i32* %30
%272 = icmp eq i32 %271, 0
br i1 %272, label %273, label %284
273: ; preds = %270
%274 = load i8*, i8** %21
%275 = icmp eq i8* %274, null
br i1 %275, label %281, label %276
276: ; preds = %273
%277 = load i8*, i8** %21
%278 = load i8, i8* %277
%279 = sext i8 %278 to i32
%280 = icmp eq i32 %279, 0
br i1 %280, label %281, label %284
281: ; preds = %276, %273
%282 = load i8*, i8** %21
%283 = call i32 @test_string_null_empty(i8* %282, i8 signext 43)
br label %292
284: ; preds = %276, %270
%285 = load i64, i64* %28
%286 = icmp ugt i64 %285, 0
br i1 %286, label %287, label %291
287: ; preds = %284
%288 = load i32, i32* %30
%289 = getelementptr inbounds [81 x i8], [81 x i8]* %25, i64 0, i64 0
%290 = call i32 (i8*, ...) @test_printf_stderr(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %288, i8* %289)
br label %291
291: ; preds = %287, %284
br label %292
292: ; preds = %291, %281
%293 = load i32, i32* %31
%294 = icmp ne i32 %293, 0
br i1 %294, label %295, label %301
295: ; preds = %292
%296 = load i64, i64* %29
%297 = icmp ugt i64 %296, 0
br i1 %297, label %298, label %301
298: ; preds = %295
%299 = getelementptr inbounds [81 x i8], [81 x i8]* %26, i64 0, i64 0
%300 = call i32 (i8*, ...) @test_printf_stderr(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i64 0, i64 0), i8* %299)
br label %301
301: ; preds = %298, %295, %292
br label %302
302: ; preds = %301, %245
%303 = load i64, i64* %27
%304 = load i8*, i8** %19
%305 = getelementptr inbounds i8, i8* %304, i64 %303
store i8* %305, i8** %19
%306 = load i64, i64* %28
%307 = load i8*, i8** %21
%308 = getelementptr inbounds i8, i8* %307, i64 %306
store i8* %308, i8** %21
%309 = load i64, i64* %27
%310 = load i64, i64* %20
%311 = sub i64 %310, %309
store i64 %311, i64* %20
%312 = load i64, i64* %28
%313 = load i64, i64* %22
%314 = sub i64 %313, %312
store i64 %314, i64* %22
%315 = load i64, i64* %23
%316 = load i32, i32* %30
%317 = zext i32 %316 to i64
%318 = add i64 %317, %315
%319 = trunc i64 %318 to i32
store i32 %319, i32* %30
br label %94
320: ; preds = %100
br label %321
321: ; preds = %320, %79
%322 = call i32 (...) @test_flush_stderr()
ret void
}

LLVM IR (-O2):
@.str = [13 x i8] c"% 4u: '%s'\0A\00"
@.str.1 = [13 x i8] c"% 4u:- '%s'\0A\00"
@.str.2 = [13 x i8] c"% 4u:+ '%s'\0A\00"
@.str.3 = [12 x i8] c"% 4s %s\0A\00"
@.str.4 = [1 x i8] zeroinitializer
define void @test_fail_string_common(i8* %0, i8* %1, i32 %2, i8* %3, i8* %4, i8* %5, i8* %6, i8* %7, i64 %8, i8* %9, i64 %10) {
%12 = alloca [81 x i8]
%13 = alloca [81 x i8]
%14 = alloca [81 x i8]
%15 = tail call i32 (...) @subtest_level()
%16 = sub i32 68, %15
%17 = sdiv i32 %16, 16
%18 = shl nsw i32 %17, 4
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 0
%21 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 0
%22 = getelementptr inbounds [81 x i8], [81 x i8]* %14, i64 0, i64 0
%23 = tail call i32 @test_fail_message_prefix(i8* %0, i8* %1, i32 %2, i8* %3, i8* %4, i8* %5, i8* %6)
%24 = icmp eq i8* %7, null
%25 = select i1 %24, i64 0, i64 %8
%26 = icmp eq i8* %9, null
%27 = select i1 %26, i64 0, i64 %10
%28 = or i64 %27, %25
%29 = icmp eq i64 %28, 0
br i1 %29, label %30, label %38
30: ; preds = %11
%31 = xor i1 %24, %26
br i1 %31, label %34, label %32
32: ; preds = %30
%33 = tail call i32 @test_string_null_empty(i8* %7, i8 signext 32)
br label %195
34: ; preds = %30
%35 = tail call i32 @test_diff_header(i8* %4, i8* %5)
%36 = tail call i32 @test_string_null_empty(i8* %7, i8 signext 45)
%37 = tail call i32 @test_string_null_empty(i8* %9, i8 signext 43)
br label %195
38: ; preds = %11
%39 = icmp eq i64 %25, %27
br i1 %39, label %40, label %43
40: ; preds = %38
%41 = tail call i64 @strcmp(i8* %7, i8* %9)
%42 = icmp eq i64 %41, 0
br i1 %42, label %45, label %43
43: ; preds = %40, %38
%44 = tail call i32 @test_diff_header(i8* %4, i8* %5)
br label %45
45: ; preds = %40, %43
%46 = icmp ne i64 %27, 0
%47 = icmp ne i64 %25, 0
br label %48
48: ; preds = %45, %186
%49 = phi i1 [ %193, %186 ], [ %46, %45 ]
%50 = phi i1 [ %192, %186 ], [ %47, %45 ]
%51 = phi i8* [ %187, %186 ], [ %7, %45 ]
%52 = phi i32 [ %191, %186 ], [ 0, %45 ]
%53 = phi i64 [ %189, %186 ], [ %25, %45 ]
%54 = phi i64 [ %190, %186 ], [ %27, %45 ]
%55 = phi i8* [ %188, %186 ], [ %9, %45 ]
br i1 %50, label %56, label %74
56: ; preds = %48
%57 = icmp ugt i64 %53, %19
%58 = select i1 %57, i64 %19, i64 %53
%59 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 %58
store i8 0, i8* %59
%60 = icmp eq i64 %58, 0
br i1 %60, label %74, label %61
61: ; preds = %56, %69
%62 = phi i64 [ %72, %69 ], [ 0, %56 ]
%63 = getelementptr inbounds i8, i8* %51, i64 %62
%64 = load i8, i8* %63
%65 = call i64 @isprint(i8 zeroext %64)
%66 = icmp eq i64 %65, 0
br i1 %66, label %69, label %67
67: ; preds = %61
%68 = load i8, i8* %63
br label %69
69: ; preds = %61, %67
%70 = phi i8 [ %68, %67 ], [ 46, %61 ]
%71 = getelementptr inbounds [81 x i8], [81 x i8]* %12, i64 0, i64 %62
store i8 %70, i8* %71
%72 = add nuw i64 %62, 1
%73 = icmp eq i64 %72, %58
br i1 %73, label %74, label %61
74: ; preds = %69, %56, %48
%75 = phi i64 [ 0, %48 ], [ 0, %56 ], [ %58, %69 ]
br i1 %49, label %78, label %76
76: ; preds = %74
%77 = icmp ne i64 %75, 0
br label %148
78: ; preds = %74
%79 = icmp ugt i64 %54, %19
%80 = select i1 %79, i64 %19, i64 %54
%81 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 %80
store i8 0, i8* %81
%82 = icmp eq i64 %80, 0
br i1 %82, label %83, label %85
83: ; preds = %78
%84 = icmp ne i64 %75, 0
br label %148
85: ; preds = %78, %93
%86 = phi i64 [ %96, %93 ], [ 0, %78 ]
%87 = getelementptr inbounds i8, i8* %55, i64 %86
%88 = load i8, i8* %87
%89 = call i64 @isprint(i8 zeroext %88)
%90 = icmp eq i64 %89, 0
br i1 %90, label %93, label %91
91: ; preds = %85
%92 = load i8, i8* %87
br label %93
93: ; preds = %85, %91
%94 = phi i8 [ %92, %91 ], [ 46, %85 ]
%95 = getelementptr inbounds [81 x i8], [81 x i8]* %13, i64 0, i64 %86
store i8 %94, i8* %95
%96 = add nuw i64 %86, 1
%97 = icmp eq i64 %96, %80
br i1 %97, label %98, label %85
98: ; preds = %93
%99 = icmp ne i64 %75, 0
br i1 %99, label %100, label %148
100: ; preds = %98
%101 = icmp ult i64 %75, %80
%102 = select i1 %101, i64 %75, i64 %80
%103 = and i64 %102, 1
%104 = icmp eq i64 %102, 1
br i1 %104, label %131, label %105
105: ; preds = %100
%106 = and i64 %102, -2
br label %107
107: ; preds = %107, %105
%108 = phi i32 [ 0, %105 ], [ %126, %107 ]
%109 = phi i64 [ 0, %105 ], [ %128, %107 ]
%110 = phi i64 [ 0, %105 ], [ %129, %107 ]
%111 = getelementptr inbounds i8, i8* %51, i64 %109
%112 = load i8, i8* %111
%113 = getelementptr inbounds i8, i8* %55, i64 %109
%114 = load i8, i8* %113
%115 = icmp eq i8 %112, %114
%116 = select i1 %115, i8 32, i8 94
%117 = getelementptr inbounds [81 x i8], [81 x i8]* %14, i64 0, i64 %109
store i8 %116, i8* %117
%118 = or i64 %109, 1
%119 = getelementptr inbounds i8, i8* %51, i64 %118
%120 = load i8, i8* %119
%121 = getelementptr inbounds i8, i8* %55, i64 %118
%122 = load i8, i8* %121
%123 = icmp eq i8 %120, %122
%124 = select i1 %123, i8 32, i8 94
%125 = select i1 %123, i1 %115, i1 false
%126 = select i1 %125, i32 %108, i32 1
%127 = getelementptr inbounds [81 x i8], [81 x i8]* %14, i64 0, i64 %118
store i8 %124, i8* %127
%128 = add nuw i64 %109, 2
%129 = add i64 %110, 2
%130 = icmp eq i64 %129, %106
br i1 %130, label %131, label %107
131: ; preds = %107, %100
%132 = phi i32 [ undef, %100 ], [ %126, %107 ]
%133 = phi i32 [ 0, %100 ], [ %126, %107 ]
%134 = phi i64 [ 0, %100 ], [ %128, %107 ]
%135 = icmp eq i64 %103, 0
br i1 %135, label %145, label %136
136: ; preds = %131
%137 = getelementptr inbounds i8, i8* %51, i64 %134
%138 = load i8, i8* %137
%139 = getelementptr inbounds i8, i8* %55, i64 %134
%140 = load i8, i8* %139
%141 = icmp eq i8 %138, %140
%142 = select i1 %141, i8 32, i8 94
%143 = select i1 %141, i32 %133, i32 1
%144 = getelementptr inbounds [81 x i8], [81 x i8]* %14, i64 0, i64 %134
store i8 %142, i8* %144
br label %145
145: ; preds = %131, %136
%146 = phi i32 [ %132, %131 ], [ %143, %136 ]
%147 = getelementptr inbounds [81 x i8], [81 x i8]* %14, i64 0, i64 %102
store i8 0, i8* %147
br label %148
148: ; preds = %83, %76, %145, %98
%149 = phi i1 [ true, %145 ], [ true, %98 ], [ false, %76 ], [ false, %83 ]
%150 = phi i1 [ true, %145 ], [ %99, %98 ], [ %77, %76 ], [ %84, %83 ]
%151 = phi i64 [ %80, %145 ], [ %80, %98 ], [ 0, %76 ], [ 0, %83 ]
%152 = phi i1 [ true, %145 ], [ false, %98 ], [ false, %76 ], [ false, %83 ]
%153 = phi i32 [ %146, %145 ], [ 0, %98 ], [ 0, %76 ], [ 0, %83 ]
%154 = icmp ne i64 %75, %151
%155 = icmp ne i32 %153, 0
%156 = select i1 %154, i1 true, i1 %155
br i1 %156, label %159, label %157
157: ; preds = %148
%158 = call i32 (i8*, ...) @test_printf_stderr(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 %52, i8* %20)
br label %186
159: ; preds = %148
%160 = icmp eq i32 %52, 0
br i1 %160, label %161, label %168
161: ; preds = %159
%162 = icmp eq i8* %51, null
br i1 %162, label %166, label %163
163: ; preds = %161
%164 = load i8, i8* %51
%165 = icmp eq i8 %164, 0
br i1 %165, label %166, label %168
166: ; preds = %161, %163
%167 = call i32 @test_string_null_empty(i8* %51, i8 signext 45)
br label %172
168: ; preds = %163, %159
br i1 %150, label %169, label %171
169: ; preds = %168
%170 = call i32 (i8*, ...) @test_printf_stderr(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 %52, i8* %20)
br label %171
171: ; preds = %168, %169
br i1 %160, label %172, label %179
172: ; preds = %166, %171
%173 = icmp eq i8* %55, null
br i1 %173, label %177, label %174
174: ; preds = %172
%175 = load i8, i8* %55
%176 = icmp eq i8 %175, 0
br i1 %176, label %177, label %179
177: ; preds = %174, %172
%178 = call i32 @test_string_null_empty(i8* %55, i8 signext 43)
br label %182
179: ; preds = %174, %171
br i1 %149, label %180, label %182
180: ; preds = %179
%181 = call i32 (i8*, ...) @test_printf_stderr(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32 %52, i8* %21)
br label %182
182: ; preds = %179, %180, %177
%183 = and i1 %155, %152
br i1 %183, label %184, label %186
184: ; preds = %182
%185 = call i32 (i8*, ...) @test_printf_stderr(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i64 0, i64 0), i8* %22)
br label %186
186: ; preds = %182, %184, %157
%187 = getelementptr inbounds i8, i8* %51, i64 %75
%188 = getelementptr inbounds i8, i8* %55, i64 %151
%189 = sub i64 %53, %75
%190 = sub i64 %54, %151
%191 = add i32 %52, %18
%192 = icmp ne i64 %189, 0
%193 = icmp ne i64 %190, 0
%194 = select i1 %192, i1 true, i1 %193
br i1 %194, label %48, label %195
195: ; preds = %186, %32, %34
%196 = call i32 (...) @test_flush_stderr()
ret void
}