#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 main() {
  int x;
  int y;
  int z;
  int a;
  if (x >= 0) {
    a = 0;
    a = a + 2;
    assert(a == 2);
    assert(!(x < 0));
    if (y >= 0) {
      a = a + 4;
      assert(a == 6);
      assert(!(x < 0) && !(y < 0));
      if (z >= 0) {
        a = a + 6;
        assert(a == 12);
        assert(!(x < 0) && !(y < 0) && !(z < 0));
      } else {
        a = a + 8;
        assert(a == 14);
        assert(!(x < 0) && !(y < 0) && !(z >= 0));
      }
    } else {
      a = a + 10;
      assert(a == 12);
      assert(!(x < 0) && !(y >= 0));
      if (z >= 0) {
        a = a + 12;
        assert(a == 24);
        assert(!(x < 0) && !(y >= 0) && !(z < 0));
      } else {
        a = a + 14;
        assert(a == 26);
        assert(!(x < 0) && !(y >= 0) && !(z >= 0));
      }
    }
    assert(a % 2 == 0 && x >= 0 && (y >= 0 || y < 0) && (z >= 0 || z < 0));
  } else {
    a = 1;
    a = a + 2;
    assert(a == 3);
    assert(!(x >= 0));
    if (y >= 0) {
      a = a + 4;
      assert(a == 7);
      assert(!(x >= 0) && !(y < 0));
      if (z >= 0) {
        a = a + 6;
        assert(a == 13);
        assert(!(x >= 0) && !(y < 0) && !(z < 0));
      } else {
        a = a + 8;
        assert(a == 15);
        assert(!(x >= 0) && !(y < 0) && !(z >= 0));
      }
    } else {
      a = a + 10;
      assert(a == 13);
      assert(!(x >= 0) && !(y >= 0));
      if (z >= 0) {
        a = a + 12;
        assert(a == 25);
        assert(!(x >= 0) && !(y >= 0) && !(z < 0));
      } else {
        a = a + 14;
        assert(a == 27);
        assert(!(x >= 0) && !(y >= 0) && !(z >= 0));
      }
    }
    assert(a % 2 == 1 && x < 0 && (y >= 0 || y < 0) && (z >= 0 || z < 0));
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
cmpl   $0x0,-0x8(%rbp)
jl     13c9 <main+0x2b9>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x2,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x8(%rbp)
setl   %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0xc(%rbp)
jl     125f <main+0x14f>
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x6,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x15(%rbp)
jl     119c <main+0x8c>
cmpl   $0x0,-0xc(%rbp)
setl   %al
xor    $0xff,%al
mov    %al,-0x15(%rbp)
mov    -0x15(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x10(%rbp)
jl     1209 <main+0xf9>
mov    -0x14(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0xc,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x16(%rbp)
jl     11f7 <main+0xe7>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x16(%rbp)
jl     11f7 <main+0xe7>
cmpl   $0x0,-0x10(%rbp)
setl   %al
xor    $0xff,%al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    125a <main+0x14a>
mov    -0x14(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0xe,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x17(%rbp)
jl     124d <main+0x13d>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x17(%rbp)
jl     124d <main+0x13d>
cmpl   $0x0,-0x10(%rbp)
setge  %al
xor    $0xff,%al
mov    %al,-0x17(%rbp)
mov    -0x17(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    1357 <main+0x247>
mov    -0x14(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0xc,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x18(%rbp)
jl     1294 <main+0x184>
cmpl   $0x0,-0xc(%rbp)
setge  %al
xor    $0xff,%al
mov    %al,-0x18(%rbp)
mov    -0x18(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x10(%rbp)
jl     1301 <main+0x1f1>
mov    -0x14(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x18,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x19(%rbp)
jl     12ef <main+0x1df>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x19(%rbp)
jge    12ef <main+0x1df>
cmpl   $0x0,-0x10(%rbp)
setl   %al
xor    $0xff,%al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    1352 <main+0x242>
mov    -0x14(%rbp),%eax
add    $0xe,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x1a,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x1a(%rbp)
jl     1345 <main+0x235>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x1a(%rbp)
jge    1345 <main+0x235>
cmpl   $0x0,-0x10(%rbp)
setge  %al
xor    $0xff,%al
mov    %al,-0x1a(%rbp)
mov    -0x1a(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    1357 <main+0x247>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
xor    %eax,%eax
cmp    $0x0,%edx
mov    %al,-0x1b(%rbp)
jne    13b7 <main+0x2a7>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x1b(%rbp)
jl     13b7 <main+0x2a7>
cmpl   $0x0,-0xc(%rbp)
jge    1398 <main+0x288>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x1b(%rbp)
jge    13b7 <main+0x2a7>
mov    $0x1,%al
cmpl   $0x0,-0x10(%rbp)
mov    %al,-0x1c(%rbp)
jge    13b1 <main+0x2a1>
cmpl   $0x0,-0x10(%rbp)
setl   %al
mov    %al,-0x1c(%rbp)
mov    -0x1c(%rbp),%al
mov    %al,-0x1b(%rbp)
mov    -0x1b(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    1664 <main+0x554>
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x8(%rbp)
setge  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0xc(%rbp)
jl     14ff <main+0x3ef>
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x7,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x1d(%rbp)
jge    143c <main+0x32c>
cmpl   $0x0,-0xc(%rbp)
setl   %al
xor    $0xff,%al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x10(%rbp)
jl     14a9 <main+0x399>
mov    -0x14(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0xd,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x1e(%rbp)
jge    1497 <main+0x387>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x1e(%rbp)
jl     1497 <main+0x387>
cmpl   $0x0,-0x10(%rbp)
setl   %al
xor    $0xff,%al
mov    %al,-0x1e(%rbp)
mov    -0x1e(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    14fa <main+0x3ea>
mov    -0x14(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0xf,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x1f(%rbp)
jge    14ed <main+0x3dd>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x1f(%rbp)
jl     14ed <main+0x3dd>
cmpl   $0x0,-0x10(%rbp)
setge  %al
xor    $0xff,%al
mov    %al,-0x1f(%rbp)
mov    -0x1f(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    15f7 <main+0x4e7>
mov    -0x14(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0xd,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x20(%rbp)
jge    1534 <main+0x424>
cmpl   $0x0,-0xc(%rbp)
setge  %al
xor    $0xff,%al
mov    %al,-0x20(%rbp)
mov    -0x20(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x10(%rbp)
jl     15a1 <main+0x491>
mov    -0x14(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x19,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x21(%rbp)
jge    158f <main+0x47f>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x21(%rbp)
jge    158f <main+0x47f>
cmpl   $0x0,-0x10(%rbp)
setl   %al
xor    $0xff,%al
mov    %al,-0x21(%rbp)
mov    -0x21(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    15f2 <main+0x4e2>
mov    -0x14(%rbp),%eax
add    $0xe,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x1b,-0x14(%rbp)
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x22(%rbp)
jge    15e5 <main+0x4d5>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x22(%rbp)
jge    15e5 <main+0x4d5>
cmpl   $0x0,-0x10(%rbp)
setge  %al
xor    $0xff,%al
mov    %al,-0x22(%rbp)
mov    -0x22(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
jmp    15f7 <main+0x4e7>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
xor    %eax,%eax
cmp    $0x1,%edx
mov    %al,-0x23(%rbp)
jne    1657 <main+0x547>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x23(%rbp)
jge    1657 <main+0x547>
cmpl   $0x0,-0xc(%rbp)
jge    1638 <main+0x528>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x23(%rbp)
jge    1657 <main+0x547>
mov    $0x1,%al
cmpl   $0x0,-0x10(%rbp)
mov    %al,-0x24(%rbp)
jge    1651 <main+0x541>
cmpl   $0x0,-0x10(%rbp)
setl   %al
mov    %al,-0x24(%rbp)
mov    -0x24(%rbp),%al
mov    %al,-0x23(%rbp)
mov    -0x23(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
define i32 @main() {
%1 = tail call i32 @assert(i32 1)
%2 = tail call i32 @assert(i32 1)
%3 = tail call i32 @assert(i32 1)
%4 = tail call i32 @assert(i32 1)
%5 = tail call i32 @assert(i32 1)
%6 = tail call i32 @assert(i32 1)
%7 = tail call i32 @assert(i32 1)
ret i32 0
}