#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*/ assert(int);
int main2() {
  int one = 1;
  int two = 2;
  int three = 3;
  int four = 4;
  int five = 5;
  int six = 6;
  int x, y, z;
  if (x + one == two) {
    assert(x == one);
  } else {
    assert(x != one);
  }
  if (five - x == three)
    assert(x == two);
  if (five - x == three && x + y == x * three)
    assert(x == two && y == four);
  if (x == three && y / x == two) {
    assert(y == six);
    assert(y >= 6 && y <= 8);
  }
  if (y / x == two && x == three)
    assert(x == three);
  if (two + (three - x) * four / five == six && two * y >= x + four)
    assert(x == -two && y >= one);
  if (x > one && x < five && x % two == one)
    assert(x != two);
  if (y / three == -two)
    assert(y >= -8 && y <= -6);
  if (y / -three == -two)
    assert(y >= 6 && y <= 8);
  if (y / x == two && x == three)
    assert(x == 3);
  if (two + (three - x) * four / five == six && two * y >= x + five)
    assert(x >= -3 && x <= -2 && y >= 1);
  if (x > one && x < five && x % two == one)
    assert(x != 2);
  long xl, yl, zl;
  if (xl + one == two) {
    assert(xl == one);
  } else {
    assert(xl != one);
  }
  if (five - xl == three)
    assert(xl == two);
  if (five - xl == three && xl + yl == xl * three)
    assert(xl == two && yl == four);
  if (xl == three && yl / xl == two)
    assert(yl == six);
  if (yl / xl == two && xl == three)
    assert(xl == three);
  if (two + (three - xl) * four / five == six && two * yl >= xl + four)
    assert(xl == -two && yl >= one);
  if (xl > one && xl < five && xl % two == one) {
  }
  short xs, ys, zs;
  if (xs + one == two) {
    assert(xs == one);
  } else {
  }
  if (five - xs == three)
    assert(xs == two);
  if (five - xs == three && xs + ys == xs * three)
    assert(xs == two && ys == four);
  if (xs == three && ys / xs == two) {
    assert(ys == six);
    assert(ys >= six && ys <= 8);
  }
  if (ys / xs == two && xs == three)
    assert(xs == three);
  if (two + (three - xs) * four / five == six && two * ys >= xs + five) {
    assert(xs == -two && ys >= one);
    assert(xs >= -three && xs <= -two && ys >= one);
  }
  if (xs > one && xs < five && xs % two == one) {
    assert(xs != two);
  }
  if (ys / three == -two)
    assert(ys >= -8 && ys <= -6);
  if (ys / -three == -two)
    assert(ys >= 6 && ys <= 8);
  if (ys / xs == two && xs == three)
    assert(xs == 3);
}


x86 assembly (clang, -O0):
<main2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x1,-0x8(%rbp)
movl   $0x2,-0xc(%rbp)
movl   $0x3,-0x10(%rbp)
movl   $0x4,-0x14(%rbp)
movl   $0x5,-0x18(%rbp)
movl   $0x6,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    1169 <main2+0x59>
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    117c <main2+0x6c>
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x18(%rbp),%eax
sub    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    119e <main2+0x8e>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x18(%rbp),%eax
sub    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    11ec <main2+0xdc>
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jne    11ec <main2+0xdc>
mov    -0x20(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x47(%rbp)
jne    11df <main2+0xcf>
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
sete   %al
mov    %al,-0x47(%rbp)
mov    -0x47(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    1241 <main2+0x131>
mov    -0x24(%rbp),%eax
cltd
idivl  -0x20(%rbp)
cmp    -0xc(%rbp),%eax
jne    1241 <main2+0x131>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x6,-0x24(%rbp)
mov    %al,-0x48(%rbp)
jl     1234 <main2+0x124>
cmpl   $0x8,-0x24(%rbp)
setle  %al
mov    %al,-0x48(%rbp)
mov    -0x48(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x24(%rbp),%eax
cltd
idivl  -0x20(%rbp)
cmp    -0xc(%rbp),%eax
jne    1270 <main2+0x160>
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    1270 <main2+0x160>
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0xc(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x20(%rbp),%eax
imul   -0x14(%rbp),%eax
cltd
idivl  -0x18(%rbp)
mov    %eax,%ecx
mov    -0x4c(%rbp),%eax
add    %ecx,%eax
cmp    -0x1c(%rbp),%eax
jne    12d7 <main2+0x1c7>
mov    -0xc(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jl     12d7 <main2+0x1c7>
mov    -0x20(%rbp),%ecx
xor    %edx,%edx
sub    -0xc(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x4d(%rbp)
jne    12ca <main2+0x1ba>
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
setge  %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    1312 <main2+0x202>
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1312 <main2+0x202>
mov    -0x20(%rbp),%eax
cltd
idivl  -0xc(%rbp)
cmp    -0x8(%rbp),%edx
jne    1312 <main2+0x202>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x24(%rbp),%eax
cltd
idivl  -0x10(%rbp)
xor    %ecx,%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jne    134c <main2+0x23c>
xor    %eax,%eax
cmpl   $0xfffffff8,-0x24(%rbp)
mov    %al,-0x4e(%rbp)
jl     133f <main2+0x22f>
cmpl   $0xfffffffa,-0x24(%rbp)
setle  %al
mov    %al,-0x4e(%rbp)
mov    -0x4e(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x24(%rbp),%eax
xor    %ecx,%ecx
sub    -0x10(%rbp),%ecx
cltd
idiv   %ecx
xor    %ecx,%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jne    138a <main2+0x27a>
xor    %eax,%eax
cmpl   $0x6,-0x24(%rbp)
mov    %al,-0x4f(%rbp)
jl     137d <main2+0x26d>
cmpl   $0x8,-0x24(%rbp)
setle  %al
mov    %al,-0x4f(%rbp)
mov    -0x4f(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x24(%rbp),%eax
cltd
idivl  -0x20(%rbp)
cmp    -0xc(%rbp),%eax
jne    13b7 <main2+0x2a7>
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    13b7 <main2+0x2a7>
cmpl   $0x3,-0x20(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0xc(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x20(%rbp),%eax
imul   -0x14(%rbp),%eax
cltd
idivl  -0x18(%rbp)
mov    %eax,%ecx
mov    -0x54(%rbp),%eax
add    %ecx,%eax
cmp    -0x1c(%rbp),%eax
jne    1425 <main2+0x315>
mov    -0xc(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jl     1425 <main2+0x315>
xor    %eax,%eax
cmpl   $0xfffffffd,-0x20(%rbp)
mov    %al,-0x55(%rbp)
jl     1418 <main2+0x308>
xor    %eax,%eax
cmpl   $0xfffffffe,-0x20(%rbp)
mov    %al,-0x55(%rbp)
jg     1418 <main2+0x308>
cmpl   $0x1,-0x24(%rbp)
setge  %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    145e <main2+0x34e>
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    145e <main2+0x34e>
mov    -0x20(%rbp),%eax
cltd
idivl  -0xc(%rbp)
cmp    -0x8(%rbp),%edx
jne    145e <main2+0x34e>
cmpl   $0x2,-0x20(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jne    1493 <main2+0x383>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    14ab <main2+0x39b>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movslq -0x18(%rbp),%rax
sub    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
jne    14d8 <main2+0x3c8>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movslq -0x18(%rbp),%rax
sub    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
jne    153e <main2+0x42e>
mov    -0x30(%rbp),%rax
add    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x10(%rbp),%rdx
imul   %rdx,%rcx
cmp    %rcx,%rax
jne    153e <main2+0x42e>
mov    -0x30(%rbp),%rcx
movslq -0xc(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x56(%rbp)
jne    1531 <main2+0x421>
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0x56(%rbp)
mov    -0x56(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
jne    157e <main2+0x46e>
mov    -0x38(%rbp),%rax
cqto
idivq  -0x30(%rbp)
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jne    157e <main2+0x46e>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x38(%rbp),%rax
cqto
idivq  -0x30(%rbp)
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jne    15be <main2+0x4ae>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
jne    15be <main2+0x4ae>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movslq -0xc(%rbp),%rax
mov    %rax,-0x60(%rbp)
movslq -0x10(%rbp),%rax
sub    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
movslq -0x18(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x60(%rbp),%rax
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jne    164b <main2+0x53b>
movslq -0xc(%rbp),%rax
imul   -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x14(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jl     164b <main2+0x53b>
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
sub    -0xc(%rbp),%eax
movslq %eax,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x61(%rbp)
jne    163e <main2+0x52e>
mov    -0x38(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
setge  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jle    168c <main2+0x57c>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmp    %rcx,%rax
jge    168c <main2+0x57c>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
cqto
idiv   %rcx
movslq -0x8(%rbp),%rax
cmp    %rax,%rdx
jne    168c <main2+0x57c>
jmp    168c <main2+0x57c>
movswl -0x42(%rbp),%eax
add    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    16b5 <main2+0x5a5>
movswl -0x42(%rbp),%eax
cmp    -0x8(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    16ba <main2+0x5aa>
jmp    16ba <main2+0x5aa>
mov    -0x18(%rbp),%eax
movswl -0x42(%rbp),%ecx
sub    %ecx,%eax
cmp    -0x10(%rbp),%eax
jne    16e0 <main2+0x5d0>
movswl -0x42(%rbp),%eax
cmp    -0xc(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x18(%rbp),%eax
movswl -0x42(%rbp),%ecx
sub    %ecx,%eax
cmp    -0x10(%rbp),%eax
jne    1738 <main2+0x628>
movswl -0x42(%rbp),%eax
movswl -0x44(%rbp),%ecx
add    %ecx,%eax
movswl -0x42(%rbp),%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jne    1738 <main2+0x628>
movswl -0x42(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x62(%rbp)
jne    172b <main2+0x61b>
movswl -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
sete   %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswl -0x42(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    1799 <main2+0x689>
movswl -0x44(%rbp),%eax
movswl -0x42(%rbp),%ecx
cltd
idiv   %ecx
cmp    -0xc(%rbp),%eax
jne    1799 <main2+0x689>
movswl -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswl -0x44(%rbp),%ecx
xor    %eax,%eax
cmp    -0x1c(%rbp),%ecx
mov    %al,-0x63(%rbp)
jl     178c <main2+0x67c>
movswl -0x44(%rbp),%eax
cmp    $0x8,%eax
setle  %al
mov    %al,-0x63(%rbp)
mov    -0x63(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswl -0x44(%rbp),%eax
movswl -0x42(%rbp),%ecx
cltd
idiv   %ecx
cmp    -0xc(%rbp),%eax
jne    17ce <main2+0x6be>
movswl -0x42(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    17ce <main2+0x6be>
movswl -0x42(%rbp),%eax
cmp    -0x10(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0xc(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%eax
movswl -0x42(%rbp),%ecx
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
cltd
idivl  -0x18(%rbp)
mov    %eax,%ecx
mov    -0x68(%rbp),%eax
add    %ecx,%eax
cmp    -0x1c(%rbp),%eax
jne    1884 <main2+0x774>
mov    -0xc(%rbp),%eax
movswl -0x44(%rbp),%ecx
imul   %ecx,%eax
movswl -0x42(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jl     1884 <main2+0x774>
movswl -0x42(%rbp),%ecx
xor    %edx,%edx
sub    -0xc(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x69(%rbp)
jne    1831 <main2+0x721>
movswl -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
setge  %al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswl -0x42(%rbp),%ecx
xor    %edx,%edx
sub    -0x10(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x6a(%rbp)
jl     1877 <main2+0x767>
movswl -0x42(%rbp),%ecx
xor    %edx,%edx
sub    -0xc(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x6a(%rbp)
jg     1877 <main2+0x767>
movswl -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
setge  %al
mov    %al,-0x6a(%rbp)
mov    -0x6a(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswl -0x42(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    18c3 <main2+0x7b3>
movswl -0x42(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18c3 <main2+0x7b3>
movswl -0x42(%rbp),%eax
cltd
idivl  -0xc(%rbp)
cmp    -0x8(%rbp),%edx
jne    18c3 <main2+0x7b3>
movswl -0x42(%rbp),%eax
cmp    -0xc(%rbp),%eax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswl -0x44(%rbp),%eax
cltd
idivl  -0x10(%rbp)
xor    %ecx,%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jne    1904 <main2+0x7f4>
movswl -0x44(%rbp),%ecx
xor    %eax,%eax
cmp    $0xfffffff8,%ecx
mov    %al,-0x6b(%rbp)
jl     18f7 <main2+0x7e7>
movswl -0x44(%rbp),%eax
cmp    $0xfffffffa,%eax
setle  %al
mov    %al,-0x6b(%rbp)
mov    -0x6b(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswl -0x44(%rbp),%eax
xor    %ecx,%ecx
sub    -0x10(%rbp),%ecx
cltd
idiv   %ecx
xor    %ecx,%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jne    1949 <main2+0x839>
movswl -0x44(%rbp),%ecx
xor    %eax,%eax
cmp    $0x6,%ecx
mov    %al,-0x6c(%rbp)
jl     193c <main2+0x82c>
movswl -0x44(%rbp),%eax
cmp    $0x8,%eax
setle  %al
mov    %al,-0x6c(%rbp)
mov    -0x6c(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movswl -0x44(%rbp),%eax
movswl -0x42(%rbp),%ecx
cltd
idiv   %ecx
cmp    -0xc(%rbp),%eax
jne    197e <main2+0x86e>
movswl -0x42(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    197e <main2+0x86e>
movswl -0x42(%rbp),%eax
cmp    $0x3,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main2>:
push   %rax
xor    %edi,%edi
call   1030 <assert@plt>
xor    %edi,%edi
pop    %rax
jmp    1030 <assert@plt>

LLVM IR (-O0):
define i32 @main2() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i16
%15 = alloca i16
%16 = alloca i16
store i32 1, i32* %2
store i32 2, i32* %3
store i32 3, i32* %4
store i32 4, i32* %5
store i32 5, i32* %6
store i32 6, i32* %7
%17 = load i32, i32* %8
%18 = load i32, i32* %2
%19 = add nsw i32 %17, %18
%20 = load i32, i32* %3
%21 = icmp eq i32 %19, %20
br i1 %21, label %22, label %28
22: ; preds = %0
%23 = load i32, i32* %8
%24 = load i32, i32* %2
%25 = icmp eq i32 %23, %24
%26 = zext i1 %25 to i32
%27 = call i32 @assert(i32 %26)
br label %34
28: ; preds = %0
%29 = load i32, i32* %8
%30 = load i32, i32* %2
%31 = icmp ne i32 %29, %30
%32 = zext i1 %31 to i32
%33 = call i32 @assert(i32 %32)
br label %34
34: ; preds = %28, %22
%35 = load i32, i32* %6
%36 = load i32, i32* %8
%37 = sub nsw i32 %35, %36
%38 = load i32, i32* %4
%39 = icmp eq i32 %37, %38
br i1 %39, label %40, label %46
40: ; preds = %34
%41 = load i32, i32* %8
%42 = load i32, i32* %3
%43 = icmp eq i32 %41, %42
%44 = zext i1 %43 to i32
%45 = call i32 @assert(i32 %44)
br label %46
46: ; preds = %40, %34
%47 = load i32, i32* %6
%48 = load i32, i32* %8
%49 = sub nsw i32 %47, %48
%50 = load i32, i32* %4
%51 = icmp eq i32 %49, %50
br i1 %51, label %52, label %72
52: ; preds = %46
%53 = load i32, i32* %8
%54 = load i32, i32* %9
%55 = add nsw i32 %53, %54
%56 = load i32, i32* %8
%57 = load i32, i32* %4
%58 = mul nsw i32 %56, %57
%59 = icmp eq i32 %55, %58
br i1 %59, label %60, label %72
60: ; preds = %52
%61 = load i32, i32* %8
%62 = load i32, i32* %3
%63 = icmp eq i32 %61, %62
br i1 %63, label %64, label %68
64: ; preds = %60
%65 = load i32, i32* %9
%66 = load i32, i32* %5
%67 = icmp eq i32 %65, %66
br label %68
68: ; preds = %64, %60
%69 = phi i1 [ false, %60 ], [ %67, %64 ]
%70 = zext i1 %69 to i32
%71 = call i32 @assert(i32 %70)
br label %72
72: ; preds = %68, %52, %46
%73 = load i32, i32* %8
%74 = load i32, i32* %4
%75 = icmp eq i32 %73, %74
br i1 %75, label %76, label %97
76: ; preds = %72
%77 = load i32, i32* %9
%78 = load i32, i32* %8
%79 = sdiv i32 %77, %78
%80 = load i32, i32* %3
%81 = icmp eq i32 %79, %80
br i1 %81, label %82, label %97
82: ; preds = %76
%83 = load i32, i32* %9
%84 = load i32, i32* %7
%85 = icmp eq i32 %83, %84
%86 = zext i1 %85 to i32
%87 = call i32 @assert(i32 %86)
%88 = load i32, i32* %9
%89 = icmp sge i32 %88, 6
br i1 %89, label %90, label %93
90: ; preds = %82
%91 = load i32, i32* %9
%92 = icmp sle i32 %91, 8
br label %93
93: ; preds = %90, %82
%94 = phi i1 [ false, %82 ], [ %92, %90 ]
%95 = zext i1 %94 to i32
%96 = call i32 @assert(i32 %95)
br label %97
97: ; preds = %93, %76, %72
%98 = load i32, i32* %9
%99 = load i32, i32* %8
%100 = sdiv i32 %98, %99
%101 = load i32, i32* %3
%102 = icmp eq i32 %100, %101
br i1 %102, label %103, label %113
103: ; preds = %97
%104 = load i32, i32* %8
%105 = load i32, i32* %4
%106 = icmp eq i32 %104, %105
br i1 %106, label %107, label %113
107: ; preds = %103
%108 = load i32, i32* %8
%109 = load i32, i32* %4
%110 = icmp eq i32 %108, %109
%111 = zext i1 %110 to i32
%112 = call i32 @assert(i32 %111)
br label %113
113: ; preds = %107, %103, %97
%114 = load i32, i32* %3
%115 = load i32, i32* %4
%116 = load i32, i32* %8
%117 = sub nsw i32 %115, %116
%118 = load i32, i32* %5
%119 = mul nsw i32 %117, %118
%120 = load i32, i32* %6
%121 = sdiv i32 %119, %120
%122 = add nsw i32 %114, %121
%123 = load i32, i32* %7
%124 = icmp eq i32 %122, %123
br i1 %124, label %125, label %146
125: ; preds = %113
%126 = load i32, i32* %3
%127 = load i32, i32* %9
%128 = mul nsw i32 %126, %127
%129 = load i32, i32* %8
%130 = load i32, i32* %5
%131 = add nsw i32 %129, %130
%132 = icmp sge i32 %128, %131
br i1 %132, label %133, label %146
133: ; preds = %125
%134 = load i32, i32* %8
%135 = load i32, i32* %3
%136 = sub nsw i32 0, %135
%137 = icmp eq i32 %134, %136
br i1 %137, label %138, label %142
138: ; preds = %133
%139 = load i32, i32* %9
%140 = load i32, i32* %2
%141 = icmp sge i32 %139, %140
br label %142
142: ; preds = %138, %133
%143 = phi i1 [ false, %133 ], [ %141, %138 ]
%144 = zext i1 %143 to i32
%145 = call i32 @assert(i32 %144)
br label %146
146: ; preds = %142, %125, %113
%147 = load i32, i32* %8
%148 = load i32, i32* %2
%149 = icmp sgt i32 %147, %148
br i1 %149, label %150, label %166
150: ; preds = %146
%151 = load i32, i32* %8
%152 = load i32, i32* %6
%153 = icmp slt i32 %151, %152
br i1 %153, label %154, label %166
154: ; preds = %150
%155 = load i32, i32* %8
%156 = load i32, i32* %3
%157 = srem i32 %155, %156
%158 = load i32, i32* %2
%159 = icmp eq i32 %157, %158
br i1 %159, label %160, label %166
160: ; preds = %154
%161 = load i32, i32* %8
%162 = load i32, i32* %3
%163 = icmp ne i32 %161, %162
%164 = zext i1 %163 to i32
%165 = call i32 @assert(i32 %164)
br label %166
166: ; preds = %160, %154, %150, %146
%167 = load i32, i32* %9
%168 = load i32, i32* %4
%169 = sdiv i32 %167, %168
%170 = load i32, i32* %3
%171 = sub nsw i32 0, %170
%172 = icmp eq i32 %169, %171
br i1 %172, label %173, label %183
173: ; preds = %166
%174 = load i32, i32* %9
%175 = icmp sge i32 %174, -8
br i1 %175, label %176, label %179
176: ; preds = %173
%177 = load i32, i32* %9
%178 = icmp sle i32 %177, -6
br label %179
179: ; preds = %176, %173
%180 = phi i1 [ false, %173 ], [ %178, %176 ]
%181 = zext i1 %180 to i32
%182 = call i32 @assert(i32 %181)
br label %183
183: ; preds = %179, %166
%184 = load i32, i32* %9
%185 = load i32, i32* %4
%186 = sub nsw i32 0, %185
%187 = sdiv i32 %184, %186
%188 = load i32, i32* %3
%189 = sub nsw i32 0, %188
%190 = icmp eq i32 %187, %189
br i1 %190, label %191, label %201
191: ; preds = %183
%192 = load i32, i32* %9
%193 = icmp sge i32 %192, 6
br i1 %193, label %194, label %197
194: ; preds = %191
%195 = load i32, i32* %9
%196 = icmp sle i32 %195, 8
br label %197
197: ; preds = %194, %191
%198 = phi i1 [ false, %191 ], [ %196, %194 ]
%199 = zext i1 %198 to i32
%200 = call i32 @assert(i32 %199)
br label %201
201: ; preds = %197, %183
%202 = load i32, i32* %9
%203 = load i32, i32* %8
%204 = sdiv i32 %202, %203
%205 = load i32, i32* %3
%206 = icmp eq i32 %204, %205
br i1 %206, label %207, label %216
207: ; preds = %201
%208 = load i32, i32* %8
%209 = load i32, i32* %4
%210 = icmp eq i32 %208, %209
br i1 %210, label %211, label %216
211: ; preds = %207
%212 = load i32, i32* %8
%213 = icmp eq i32 %212, 3
%214 = zext i1 %213 to i32
%215 = call i32 @assert(i32 %214)
br label %216
216: ; preds = %211, %207, %201
%217 = load i32, i32* %3
%218 = load i32, i32* %4
%219 = load i32, i32* %8
%220 = sub nsw i32 %218, %219
%221 = load i32, i32* %5
%222 = mul nsw i32 %220, %221
%223 = load i32, i32* %6
%224 = sdiv i32 %222, %223
%225 = add nsw i32 %217, %224
%226 = load i32, i32* %7
%227 = icmp eq i32 %225, %226
br i1 %227, label %228, label %249
228: ; preds = %216
%229 = load i32, i32* %3
%230 = load i32, i32* %9
%231 = mul nsw i32 %229, %230
%232 = load i32, i32* %8
%233 = load i32, i32* %6
%234 = add nsw i32 %232, %233
%235 = icmp sge i32 %231, %234
br i1 %235, label %236, label %249
236: ; preds = %228
%237 = load i32, i32* %8
%238 = icmp sge i32 %237, -3
br i1 %238, label %239, label %245
239: ; preds = %236
%240 = load i32, i32* %8
%241 = icmp sle i32 %240, -2
br i1 %241, label %242, label %245
242: ; preds = %239
%243 = load i32, i32* %9
%244 = icmp sge i32 %243, 1
br label %245
245: ; preds = %242, %239, %236
%246 = phi i1 [ false, %239 ], [ false, %236 ], [ %244, %242 ]
%247 = zext i1 %246 to i32
%248 = call i32 @assert(i32 %247)
br label %249
249: ; preds = %245, %228, %216
%250 = load i32, i32* %8
%251 = load i32, i32* %2
%252 = icmp sgt i32 %250, %251
br i1 %252, label %253, label %268
253: ; preds = %249
%254 = load i32, i32* %8
%255 = load i32, i32* %6
%256 = icmp slt i32 %254, %255
br i1 %256, label %257, label %268
257: ; preds = %253
%258 = load i32, i32* %8
%259 = load i32, i32* %3
%260 = srem i32 %258, %259
%261 = load i32, i32* %2
%262 = icmp eq i32 %260, %261
br i1 %262, label %263, label %268
263: ; preds = %257
%264 = load i32, i32* %8
%265 = icmp ne i32 %264, 2
%266 = zext i1 %265 to i32
%267 = call i32 @assert(i32 %266)
br label %268
268: ; preds = %263, %257, %253, %249
%269 = load i64, i64* %11
%270 = load i32, i32* %2
%271 = sext i32 %270 to i64
%272 = add nsw i64 %269, %271
%273 = load i32, i32* %3
%274 = sext i32 %273 to i64
%275 = icmp eq i64 %272, %274
br i1 %275, label %276, label %283
276: ; preds = %268
%277 = load i64, i64* %11
%278 = load i32, i32* %2
%279 = sext i32 %278 to i64
%280 = icmp eq i64 %277, %279
%281 = zext i1 %280 to i32
%282 = call i32 @assert(i32 %281)
br label %290
283: ; preds = %268
%284 = load i64, i64* %11
%285 = load i32, i32* %2
%286 = sext i32 %285 to i64
%287 = icmp ne i64 %284, %286
%288 = zext i1 %287 to i32
%289 = call i32 @assert(i32 %288)
br label %290
290: ; preds = %283, %276
%291 = load i32, i32* %6
%292 = sext i32 %291 to i64
%293 = load i64, i64* %11
%294 = sub nsw i64 %292, %293
%295 = load i32, i32* %4
%296 = sext i32 %295 to i64
%297 = icmp eq i64 %294, %296
br i1 %297, label %298, label %305
298: ; preds = %290
%299 = load i64, i64* %11
%300 = load i32, i32* %3
%301 = sext i32 %300 to i64
%302 = icmp eq i64 %299, %301
%303 = zext i1 %302 to i32
%304 = call i32 @assert(i32 %303)
br label %305
305: ; preds = %298, %290
%306 = load i32, i32* %6
%307 = sext i32 %306 to i64
%308 = load i64, i64* %11
%309 = sub nsw i64 %307, %308
%310 = load i32, i32* %4
%311 = sext i32 %310 to i64
%312 = icmp eq i64 %309, %311
br i1 %312, label %313, label %336
313: ; preds = %305
%314 = load i64, i64* %11
%315 = load i64, i64* %12
%316 = add nsw i64 %314, %315
%317 = load i64, i64* %11
%318 = load i32, i32* %4
%319 = sext i32 %318 to i64
%320 = mul nsw i64 %317, %319
%321 = icmp eq i64 %316, %320
br i1 %321, label %322, label %336
322: ; preds = %313
%323 = load i64, i64* %11
%324 = load i32, i32* %3
%325 = sext i32 %324 to i64
%326 = icmp eq i64 %323, %325
br i1 %326, label %327, label %332
327: ; preds = %322
%328 = load i64, i64* %12
%329 = load i32, i32* %5
%330 = sext i32 %329 to i64
%331 = icmp eq i64 %328, %330
br label %332
332: ; preds = %327, %322
%333 = phi i1 [ false, %322 ], [ %331, %327 ]
%334 = zext i1 %333 to i32
%335 = call i32 @assert(i32 %334)
br label %336
336: ; preds = %332, %313, %305
%337 = load i64, i64* %11
%338 = load i32, i32* %4
%339 = sext i32 %338 to i64
%340 = icmp eq i64 %337, %339
br i1 %340, label %341, label %355
341: ; preds = %336
%342 = load i64, i64* %12
%343 = load i64, i64* %11
%344 = sdiv i64 %342, %343
%345 = load i32, i32* %3
%346 = sext i32 %345 to i64
%347 = icmp eq i64 %344, %346
br i1 %347, label %348, label %355
348: ; preds = %341
%349 = load i64, i64* %12
%350 = load i32, i32* %7
%351 = sext i32 %350 to i64
%352 = icmp eq i64 %349, %351
%353 = zext i1 %352 to i32
%354 = call i32 @assert(i32 %353)
br label %355
355: ; preds = %348, %341, %336
%356 = load i64, i64* %12
%357 = load i64, i64* %11
%358 = sdiv i64 %356, %357
%359 = load i32, i32* %3
%360 = sext i32 %359 to i64
%361 = icmp eq i64 %358, %360
br i1 %361, label %362, label %374
362: ; preds = %355
%363 = load i64, i64* %11
%364 = load i32, i32* %4
%365 = sext i32 %364 to i64
%366 = icmp eq i64 %363, %365
br i1 %366, label %367, label %374
367: ; preds = %362
%368 = load i64, i64* %11
%369 = load i32, i32* %4
%370 = sext i32 %369 to i64
%371 = icmp eq i64 %368, %370
%372 = zext i1 %371 to i32
%373 = call i32 @assert(i32 %372)
br label %374
374: ; preds = %367, %362, %355
%375 = load i32, i32* %3
%376 = sext i32 %375 to i64
%377 = load i32, i32* %4
%378 = sext i32 %377 to i64
%379 = load i64, i64* %11
%380 = sub nsw i64 %378, %379
%381 = load i32, i32* %5
%382 = sext i32 %381 to i64
%383 = mul nsw i64 %380, %382
%384 = load i32, i32* %6
%385 = sext i32 %384 to i64
%386 = sdiv i64 %383, %385
%387 = add nsw i64 %376, %386
%388 = load i32, i32* %7
%389 = sext i32 %388 to i64
%390 = icmp eq i64 %387, %389
br i1 %390, label %391, label %416
391: ; preds = %374
%392 = load i32, i32* %3
%393 = sext i32 %392 to i64
%394 = load i64, i64* %12
%395 = mul nsw i64 %393, %394
%396 = load i64, i64* %11
%397 = load i32, i32* %5
%398 = sext i32 %397 to i64
%399 = add nsw i64 %396, %398
%400 = icmp sge i64 %395, %399
br i1 %400, label %401, label %416
401: ; preds = %391
%402 = load i64, i64* %11
%403 = load i32, i32* %3
%404 = sub nsw i32 0, %403
%405 = sext i32 %404 to i64
%406 = icmp eq i64 %402, %405
br i1 %406, label %407, label %412
407: ; preds = %401
%408 = load i64, i64* %12
%409 = load i32, i32* %2
%410 = sext i32 %409 to i64
%411 = icmp sge i64 %408, %410
br label %412
412: ; preds = %407, %401
%413 = phi i1 [ false, %401 ], [ %411, %407 ]
%414 = zext i1 %413 to i32
%415 = call i32 @assert(i32 %414)
br label %416
416: ; preds = %412, %391, %374
%417 = load i64, i64* %11
%418 = load i32, i32* %2
%419 = sext i32 %418 to i64
%420 = icmp sgt i64 %417, %419
br i1 %420, label %421, label %435
421: ; preds = %416
%422 = load i64, i64* %11
%423 = load i32, i32* %6
%424 = sext i32 %423 to i64
%425 = icmp slt i64 %422, %424
br i1 %425, label %426, label %435
426: ; preds = %421
%427 = load i64, i64* %11
%428 = load i32, i32* %3
%429 = sext i32 %428 to i64
%430 = srem i64 %427, %429
%431 = load i32, i32* %2
%432 = sext i32 %431 to i64
%433 = icmp eq i64 %430, %432
br i1 %433, label %434, label %435
434: ; preds = %426
br label %435
435: ; preds = %434, %426, %421, %416
%436 = load i16, i16* %14
%437 = sext i16 %436 to i32
%438 = load i32, i32* %2
%439 = add nsw i32 %437, %438
%440 = load i32, i32* %3
%441 = icmp eq i32 %439, %440
br i1 %441, label %442, label %449
442: ; preds = %435
%443 = load i16, i16* %14
%444 = sext i16 %443 to i32
%445 = load i32, i32* %2
%446 = icmp eq i32 %444, %445
%447 = zext i1 %446 to i32
%448 = call i32 @assert(i32 %447)
br label %450
449: ; preds = %435
br label %450
450: ; preds = %449, %442
%451 = load i32, i32* %6
%452 = load i16, i16* %14
%453 = sext i16 %452 to i32
%454 = sub nsw i32 %451, %453
%455 = load i32, i32* %4
%456 = icmp eq i32 %454, %455
br i1 %456, label %457, label %464
457: ; preds = %450
%458 = load i16, i16* %14
%459 = sext i16 %458 to i32
%460 = load i32, i32* %3
%461 = icmp eq i32 %459, %460
%462 = zext i1 %461 to i32
%463 = call i32 @assert(i32 %462)
br label %464
464: ; preds = %457, %450
%465 = load i32, i32* %6
%466 = load i16, i16* %14
%467 = sext i16 %466 to i32
%468 = sub nsw i32 %465, %467
%469 = load i32, i32* %4
%470 = icmp eq i32 %468, %469
br i1 %470, label %471, label %496
471: ; preds = %464
%472 = load i16, i16* %14
%473 = sext i16 %472 to i32
%474 = load i16, i16* %15
%475 = sext i16 %474 to i32
%476 = add nsw i32 %473, %475
%477 = load i16, i16* %14
%478 = sext i16 %477 to i32
%479 = load i32, i32* %4
%480 = mul nsw i32 %478, %479
%481 = icmp eq i32 %476, %480
br i1 %481, label %482, label %496
482: ; preds = %471
%483 = load i16, i16* %14
%484 = sext i16 %483 to i32
%485 = load i32, i32* %3
%486 = icmp eq i32 %484, %485
br i1 %486, label %487, label %492
487: ; preds = %482
%488 = load i16, i16* %15
%489 = sext i16 %488 to i32
%490 = load i32, i32* %5
%491 = icmp eq i32 %489, %490
br label %492
492: ; preds = %487, %482
%493 = phi i1 [ false, %482 ], [ %491, %487 ]
%494 = zext i1 %493 to i32
%495 = call i32 @assert(i32 %494)
br label %496
496: ; preds = %492, %471, %464
%497 = load i16, i16* %14
%498 = sext i16 %497 to i32
%499 = load i32, i32* %4
%500 = icmp eq i32 %498, %499
br i1 %500, label %501, label %528
501: ; preds = %496
%502 = load i16, i16* %15
%503 = sext i16 %502 to i32
%504 = load i16, i16* %14
%505 = sext i16 %504 to i32
%506 = sdiv i32 %503, %505
%507 = load i32, i32* %3
%508 = icmp eq i32 %506, %507
br i1 %508, label %509, label %528
509: ; preds = %501
%510 = load i16, i16* %15
%511 = sext i16 %510 to i32
%512 = load i32, i32* %7
%513 = icmp eq i32 %511, %512
%514 = zext i1 %513 to i32
%515 = call i32 @assert(i32 %514)
%516 = load i16, i16* %15
%517 = sext i16 %516 to i32
%518 = load i32, i32* %7
%519 = icmp sge i32 %517, %518
br i1 %519, label %520, label %524
520: ; preds = %509
%521 = load i16, i16* %15
%522 = sext i16 %521 to i32
%523 = icmp sle i32 %522, 8
br label %524
524: ; preds = %520, %509
%525 = phi i1 [ false, %509 ], [ %523, %520 ]
%526 = zext i1 %525 to i32
%527 = call i32 @assert(i32 %526)
br label %528
528: ; preds = %524, %501, %496
%529 = load i16, i16* %15
%530 = sext i16 %529 to i32
%531 = load i16, i16* %14
%532 = sext i16 %531 to i32
%533 = sdiv i32 %530, %532
%534 = load i32, i32* %3
%535 = icmp eq i32 %533, %534
br i1 %535, label %536, label %548
536: ; preds = %528
%537 = load i16, i16* %14
%538 = sext i16 %537 to i32
%539 = load i32, i32* %4
%540 = icmp eq i32 %538, %539
br i1 %540, label %541, label %548
541: ; preds = %536
%542 = load i16, i16* %14
%543 = sext i16 %542 to i32
%544 = load i32, i32* %4
%545 = icmp eq i32 %543, %544
%546 = zext i1 %545 to i32
%547 = call i32 @assert(i32 %546)
br label %548
548: ; preds = %541, %536, %528
%549 = load i32, i32* %3
%550 = load i32, i32* %4
%551 = load i16, i16* %14
%552 = sext i16 %551 to i32
%553 = sub nsw i32 %550, %552
%554 = load i32, i32* %5
%555 = mul nsw i32 %553, %554
%556 = load i32, i32* %6
%557 = sdiv i32 %555, %556
%558 = add nsw i32 %549, %557
%559 = load i32, i32* %7
%560 = icmp eq i32 %558, %559
br i1 %560, label %561, label %606
561: ; preds = %548
%562 = load i32, i32* %3
%563 = load i16, i16* %15
%564 = sext i16 %563 to i32
%565 = mul nsw i32 %562, %564
%566 = load i16, i16* %14
%567 = sext i16 %566 to i32
%568 = load i32, i32* %6
%569 = add nsw i32 %567, %568
%570 = icmp sge i32 %565, %569
br i1 %570, label %571, label %606
571: ; preds = %561
%572 = load i16, i16* %14
%573 = sext i16 %572 to i32
%574 = load i32, i32* %3
%575 = sub nsw i32 0, %574
%576 = icmp eq i32 %573, %575
br i1 %576, label %577, label %582
577: ; preds = %571
%578 = load i16, i16* %15
%579 = sext i16 %578 to i32
%580 = load i32, i32* %2
%581 = icmp sge i32 %579, %580
br label %582
582: ; preds = %577, %571
%583 = phi i1 [ false, %571 ], [ %581, %577 ]
%584 = zext i1 %583 to i32
%585 = call i32 @assert(i32 %584)
%586 = load i16, i16* %14
%587 = sext i16 %586 to i32
%588 = load i32, i32* %4
%589 = sub nsw i32 0, %588
%590 = icmp sge i32 %587, %589
br i1 %590, label %591, label %602
591: ; preds = %582
%592 = load i16, i16* %14
%593 = sext i16 %592 to i32
%594 = load i32, i32* %3
%595 = sub nsw i32 0, %594
%596 = icmp sle i32 %593, %595
br i1 %596, label %597, label %602
597: ; preds = %591
%598 = load i16, i16* %15
%599 = sext i16 %598 to i32
%600 = load i32, i32* %2
%601 = icmp sge i32 %599, %600
br label %602
602: ; preds = %597, %591, %582
%603 = phi i1 [ false, %591 ], [ false, %582 ], [ %601, %597 ]
%604 = zext i1 %603 to i32
%605 = call i32 @assert(i32 %604)
br label %606
606: ; preds = %602, %561, %548
%607 = load i16, i16* %14
%608 = sext i16 %607 to i32
%609 = load i32, i32* %2
%610 = icmp sgt i32 %608, %609
br i1 %610, label %611, label %630
611: ; preds = %606
%612 = load i16, i16* %14
%613 = sext i16 %612 to i32
%614 = load i32, i32* %6
%615 = icmp slt i32 %613, %614
br i1 %615, label %616, label %630
616: ; preds = %611
%617 = load i16, i16* %14
%618 = sext i16 %617 to i32
%619 = load i32, i32* %3
%620 = srem i32 %618, %619
%621 = load i32, i32* %2
%622 = icmp eq i32 %620, %621
br i1 %622, label %623, label %630
623: ; preds = %616
%624 = load i16, i16* %14
%625 = sext i16 %624 to i32
%626 = load i32, i32* %3
%627 = icmp ne i32 %625, %626
%628 = zext i1 %627 to i32
%629 = call i32 @assert(i32 %628)
br label %630
630: ; preds = %623, %616, %611, %606
%631 = load i16, i16* %15
%632 = sext i16 %631 to i32
%633 = load i32, i32* %4
%634 = sdiv i32 %632, %633
%635 = load i32, i32* %3
%636 = sub nsw i32 0, %635
%637 = icmp eq i32 %634, %636
br i1 %637, label %638, label %650
638: ; preds = %630
%639 = load i16, i16* %15
%640 = sext i16 %639 to i32
%641 = icmp sge i32 %640, -8
br i1 %641, label %642, label %646
642: ; preds = %638
%643 = load i16, i16* %15
%644 = sext i16 %643 to i32
%645 = icmp sle i32 %644, -6
br label %646
646: ; preds = %642, %638
%647 = phi i1 [ false, %638 ], [ %645, %642 ]
%648 = zext i1 %647 to i32
%649 = call i32 @assert(i32 %648)
br label %650
650: ; preds = %646, %630
%651 = load i16, i16* %15
%652 = sext i16 %651 to i32
%653 = load i32, i32* %4
%654 = sub nsw i32 0, %653
%655 = sdiv i32 %652, %654
%656 = load i32, i32* %3
%657 = sub nsw i32 0, %656
%658 = icmp eq i32 %655, %657
br i1 %658, label %659, label %671
659: ; preds = %650
%660 = load i16, i16* %15
%661 = sext i16 %660 to i32
%662 = icmp sge i32 %661, 6
br i1 %662, label %663, label %667
663: ; preds = %659
%664 = load i16, i16* %15
%665 = sext i16 %664 to i32
%666 = icmp sle i32 %665, 8
br label %667
667: ; preds = %663, %659
%668 = phi i1 [ false, %659 ], [ %666, %663 ]
%669 = zext i1 %668 to i32
%670 = call i32 @assert(i32 %669)
br label %671
671: ; preds = %667, %650
%672 = load i16, i16* %15
%673 = sext i16 %672 to i32
%674 = load i16, i16* %14
%675 = sext i16 %674 to i32
%676 = sdiv i32 %673, %675
%677 = load i32, i32* %3
%678 = icmp eq i32 %676, %677
br i1 %678, label %679, label %690
679: ; preds = %671
%680 = load i16, i16* %14
%681 = sext i16 %680 to i32
%682 = load i32, i32* %4
%683 = icmp eq i32 %681, %682
br i1 %683, label %684, label %690
684: ; preds = %679
%685 = load i16, i16* %14
%686 = sext i16 %685 to i32
%687 = icmp eq i32 %686, 3
%688 = zext i1 %687 to i32
%689 = call i32 @assert(i32 %688)
br label %690
690: ; preds = %684, %679, %671
%691 = load i32, i32* %1
ret i32 %691
}

LLVM IR (-O2):
define i32 @main2() {
%1 = tail call i32 @assert(i32 0)
%2 = tail call i32 @assert(i32 0)
ret i32 undef
}