#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 ranges_overlap(int start1, int end1, int start2, int end2) {
  assert(start1 >= 0);
  assert(end1 >= 0);
  assert(start1 <= end1 || end1 == 0);
  assert(start2 >= 0);
  assert(end2 >= 0);
  assert(start2 <= end2 || end2 == 0);
  if (start1 == 0 && end1 == 0) {
    return 1;
  } else if (start2 == 0 && end2 == 0) {
    return 1;
  } else if (start1 == 0) {
    assert(end1 != 0);
    return (end1 > start2);
  } else if (start2 == 0) {
    assert(end2 != 0);
    return (end2 > start1);
  } else if (end1 == 0) {
    return (start1 < end2 || end2 == 0);
  } else if (end2 == 0) {
    assert(end1 != 0);
    return (start2 < end1);
  } else {
    assert(start1 != 0 && end1 != 0 && start2 != 0 && end2 != 0);
    return (start1 < end2 && start2 < end1);
  }
}


x86 assembly (clang, -O0):
<ranges_overlap>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
cmpl   $0x0,-0x8(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0xc(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%ecx
mov    $0x1,%al
cmp    -0xc(%rbp),%ecx
mov    %al,-0x15(%rbp)
jle    1161 <ranges_overlap+0x51>
cmpl   $0x0,-0xc(%rbp)
sete   %al
mov    %al,-0x15(%rbp)
mov    -0x15(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x10(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x14(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x10(%rbp),%ecx
mov    $0x1,%al
cmp    -0x14(%rbp),%ecx
mov    %al,-0x16(%rbp)
jle    11ab <ranges_overlap+0x9b>
cmpl   $0x0,-0x14(%rbp)
sete   %al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpl   $0x0,-0x8(%rbp)
jne    11d8 <ranges_overlap+0xc8>
cmpl   $0x0,-0xc(%rbp)
jne    11d8 <ranges_overlap+0xc8>
movl   $0x1,-0x4(%rbp)
jmp    132c <ranges_overlap+0x21c>
cmpl   $0x0,-0x10(%rbp)
jne    11f8 <ranges_overlap+0xe8>
cmpl   $0x0,-0x14(%rbp)
jne    11f8 <ranges_overlap+0xe8>
movl   $0x1,-0x4(%rbp)
jmp    132c <ranges_overlap+0x21c>
cmpl   $0x0,-0x8(%rbp)
jne    1229 <ranges_overlap+0x119>
cmpl   $0x0,-0xc(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    132c <ranges_overlap+0x21c>
cmpl   $0x0,-0x10(%rbp)
jne    125a <ranges_overlap+0x14a>
cmpl   $0x0,-0x14(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    132c <ranges_overlap+0x21c>
cmpl   $0x0,-0xc(%rbp)
jne    128f <ranges_overlap+0x17f>
mov    -0x8(%rbp),%ecx
mov    $0x1,%al
cmp    -0x14(%rbp),%ecx
mov    %al,-0x17(%rbp)
jl     127f <ranges_overlap+0x16f>
cmpl   $0x0,-0x14(%rbp)
sete   %al
mov    %al,-0x17(%rbp)
mov    -0x17(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    132c <ranges_overlap+0x21c>
cmpl   $0x0,-0x14(%rbp)
jne    12c0 <ranges_overlap+0x1b0>
cmpl   $0x0,-0xc(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
jmp    132c <ranges_overlap+0x21c>
xor    %eax,%eax
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x18(%rbp)
je     12f7 <ranges_overlap+0x1e7>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x18(%rbp)
je     12f7 <ranges_overlap+0x1e7>
xor    %eax,%eax
cmpl   $0x0,-0x10(%rbp)
mov    %al,-0x18(%rbp)
je     12f7 <ranges_overlap+0x1e7>
cmpl   $0x0,-0x14(%rbp)
setne  %al
mov    %al,-0x18(%rbp)
mov    -0x18(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x19(%rbp)
jge    1321 <ranges_overlap+0x211>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
setl   %al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ranges_overlap>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %ecx,%ebx
mov    %edx,%r14d
mov    %esi,%ebp
mov    %edi,%r15d
not    %edi
shr    $0x1f,%edi
call   1030 <assert@plt>
mov    %ebp,%edi
not    %edi
shr    $0x1f,%edi
call   1030 <assert@plt>
cmp    %ebp,%r15d
setle  %al
test   %ebp,%ebp
sete   %cl
or     %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %r14d,%edi
not    %edi
shr    $0x1f,%edi
call   1030 <assert@plt>
mov    %ebx,%edi
not    %edi
shr    $0x1f,%edi
call   1030 <assert@plt>
cmp    %ebx,%r14d
setle  %al
test   %ebx,%ebx
sete   %cl
or     %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    $0x1,%al
mov    %ebp,%ecx
or     %r15d,%ecx
je     11f5 <ranges_overlap+0xe5>
mov    %ebx,%ecx
or     %r14d,%ecx
je     11f5 <ranges_overlap+0xe5>
test   %r15d,%r15d
je     11b6 <ranges_overlap+0xa6>
test   %r14d,%r14d
je     11cb <ranges_overlap+0xbb>
test   %ebp,%ebp
je     11e0 <ranges_overlap+0xd0>
mov    $0x1,%edi
call   1030 <assert@plt>
test   %ebx,%ebx
je     11ef <ranges_overlap+0xdf>
cmp    %ebx,%r15d
setl   %cl
cmp    %ebp,%r14d
setl   %al
and    %cl,%al
jmp    11f5 <ranges_overlap+0xe5>
xor    %edi,%edi
test   %ebp,%ebp
setne  %dil
call   1030 <assert@plt>
cmp    %r14d,%ebp
setg   %al
jmp    11f5 <ranges_overlap+0xe5>
xor    %edi,%edi
test   %ebx,%ebx
setne  %dil
call   1030 <assert@plt>
cmp    %r15d,%ebx
setg   %al
jmp    11f5 <ranges_overlap+0xe5>
test   %ebx,%ebx
sete   %cl
cmp    %ebx,%r15d
setl   %al
or     %cl,%al
jmp    11f5 <ranges_overlap+0xe5>
cmp    %ebp,%r14d
setl   %al
movzbl %al,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @ranges_overlap(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
%10 = load i32, i32* %6
%11 = icmp sge i32 %10, 0
%12 = zext i1 %11 to i32
%13 = call i32 @assert(i32 %12)
%14 = load i32, i32* %7
%15 = icmp sge i32 %14, 0
%16 = zext i1 %15 to i32
%17 = call i32 @assert(i32 %16)
%18 = load i32, i32* %6
%19 = load i32, i32* %7
%20 = icmp sle i32 %18, %19
br i1 %20, label %24, label %21
21: ; preds = %4
%22 = load i32, i32* %7
%23 = icmp eq i32 %22, 0
br label %24
24: ; preds = %21, %4
%25 = phi i1 [ true, %4 ], [ %23, %21 ]
%26 = zext i1 %25 to i32
%27 = call i32 @assert(i32 %26)
%28 = load i32, i32* %8
%29 = icmp sge i32 %28, 0
%30 = zext i1 %29 to i32
%31 = call i32 @assert(i32 %30)
%32 = load i32, i32* %9
%33 = icmp sge i32 %32, 0
%34 = zext i1 %33 to i32
%35 = call i32 @assert(i32 %34)
%36 = load i32, i32* %8
%37 = load i32, i32* %9
%38 = icmp sle i32 %36, %37
br i1 %38, label %42, label %39
39: ; preds = %24
%40 = load i32, i32* %9
%41 = icmp eq i32 %40, 0
br label %42
42: ; preds = %39, %24
%43 = phi i1 [ true, %24 ], [ %41, %39 ]
%44 = zext i1 %43 to i32
%45 = call i32 @assert(i32 %44)
%46 = load i32, i32* %6
%47 = icmp eq i32 %46, 0
br i1 %47, label %48, label %52
48: ; preds = %42
%49 = load i32, i32* %7
%50 = icmp eq i32 %49, 0
br i1 %50, label %51, label %52
51: ; preds = %48
store i32 1, i32* %5
br label %134
52: ; preds = %48, %42
%53 = load i32, i32* %8
%54 = icmp eq i32 %53, 0
br i1 %54, label %55, label %59
55: ; preds = %52
%56 = load i32, i32* %9
%57 = icmp eq i32 %56, 0
br i1 %57, label %58, label %59
58: ; preds = %55
store i32 1, i32* %5
br label %134
59: ; preds = %55, %52
%60 = load i32, i32* %6
%61 = icmp eq i32 %60, 0
br i1 %61, label %62, label %71
62: ; preds = %59
%63 = load i32, i32* %7
%64 = icmp ne i32 %63, 0
%65 = zext i1 %64 to i32
%66 = call i32 @assert(i32 %65)
%67 = load i32, i32* %7
%68 = load i32, i32* %8
%69 = icmp sgt i32 %67, %68
%70 = zext i1 %69 to i32
store i32 %70, i32* %5
br label %134
71: ; preds = %59
%72 = load i32, i32* %8
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %83
74: ; preds = %71
%75 = load i32, i32* %9
%76 = icmp ne i32 %75, 0
%77 = zext i1 %76 to i32
%78 = call i32 @assert(i32 %77)
%79 = load i32, i32* %9
%80 = load i32, i32* %6
%81 = icmp sgt i32 %79, %80
%82 = zext i1 %81 to i32
store i32 %82, i32* %5
br label %134
83: ; preds = %71
%84 = load i32, i32* %7
%85 = icmp eq i32 %84, 0
br i1 %85, label %86, label %96
86: ; preds = %83
%87 = load i32, i32* %6
%88 = load i32, i32* %9
%89 = icmp slt i32 %87, %88
br i1 %89, label %93, label %90
90: ; preds = %86
%91 = load i32, i32* %9
%92 = icmp eq i32 %91, 0
br label %93
93: ; preds = %90, %86
%94 = phi i1 [ true, %86 ], [ %92, %90 ]
%95 = zext i1 %94 to i32
store i32 %95, i32* %5
br label %134
96: ; preds = %83
%97 = load i32, i32* %9
%98 = icmp eq i32 %97, 0
br i1 %98, label %99, label %108
99: ; preds = %96
%100 = load i32, i32* %7
%101 = icmp ne i32 %100, 0
%102 = zext i1 %101 to i32
%103 = call i32 @assert(i32 %102)
%104 = load i32, i32* %8
%105 = load i32, i32* %7
%106 = icmp slt i32 %104, %105
%107 = zext i1 %106 to i32
store i32 %107, i32* %5
br label %134
108: ; preds = %96
%109 = load i32, i32* %6
%110 = icmp ne i32 %109, 0
br i1 %110, label %111, label %120
111: ; preds = %108
%112 = load i32, i32* %7
%113 = icmp ne i32 %112, 0
br i1 %113, label %114, label %120
114: ; preds = %111
%115 = load i32, i32* %8
%116 = icmp ne i32 %115, 0
br i1 %116, label %117, label %120
117: ; preds = %114
%118 = load i32, i32* %9
%119 = icmp ne i32 %118, 0
br label %120
120: ; preds = %117, %114, %111, %108
%121 = phi i1 [ false, %114 ], [ false, %111 ], [ false, %108 ], [ %119, %117 ]
%122 = zext i1 %121 to i32
%123 = call i32 @assert(i32 %122)
%124 = load i32, i32* %6
%125 = load i32, i32* %9
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %131
127: ; preds = %120
%128 = load i32, i32* %8
%129 = load i32, i32* %7
%130 = icmp slt i32 %128, %129
br label %131
131: ; preds = %127, %120
%132 = phi i1 [ false, %120 ], [ %130, %127 ]
%133 = zext i1 %132 to i32
store i32 %133, i32* %5
br label %134
134: ; preds = %131, %99, %93, %74, %62, %58, %51
%135 = load i32, i32* %5
ret i32 %135
}

LLVM IR (-O2):
define i32 @ranges_overlap(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = xor i32 %0, -1
%6 = lshr i32 %5, 31
%7 = tail call i32 @assert(i32 %6)
%8 = xor i32 %1, -1
%9 = lshr i32 %8, 31
%10 = tail call i32 @assert(i32 %9)
%11 = icmp sle i32 %0, %1
%12 = icmp eq i32 %1, 0
%13 = or i1 %11, %12
%14 = zext i1 %13 to i32
%15 = tail call i32 @assert(i32 %14)
%16 = xor i32 %2, -1
%17 = lshr i32 %16, 31
%18 = tail call i32 @assert(i32 %17)
%19 = xor i32 %3, -1
%20 = lshr i32 %19, 31
%21 = tail call i32 @assert(i32 %20)
%22 = icmp sle i32 %2, %3
%23 = icmp eq i32 %3, 0
%24 = or i1 %22, %23
%25 = zext i1 %24 to i32
%26 = tail call i32 @assert(i32 %25)
%27 = icmp eq i32 %0, 0
%28 = or i32 %1, %0
%29 = icmp eq i32 %28, 0
br i1 %29, label %58, label %30
30: ; preds = %4
%31 = icmp eq i32 %2, 0
%32 = or i32 %3, %2
%33 = icmp eq i32 %32, 0
br i1 %33, label %58, label %34
34: ; preds = %30
br i1 %27, label %35, label %40
35: ; preds = %34
%36 = icmp ne i32 %1, 0
%37 = zext i1 %36 to i32
%38 = tail call i32 @assert(i32 %37)
%39 = icmp sgt i32 %1, %2
br label %58
40: ; preds = %34
br i1 %31, label %41, label %46
41: ; preds = %40
%42 = icmp ne i32 %3, 0
%43 = zext i1 %42 to i32
%44 = tail call i32 @assert(i32 %43)
%45 = icmp sgt i32 %3, %0
br label %58
46: ; preds = %40
br i1 %12, label %47, label %50
47: ; preds = %46
%48 = icmp slt i32 %0, %3
%49 = or i1 %48, %23
br label %58
50: ; preds = %46
%51 = tail call i32 @assert(i32 1)
br i1 %23, label %52, label %54
52: ; preds = %50
%53 = icmp slt i32 %2, %1
br label %58
54: ; preds = %50
%55 = icmp slt i32 %0, %3
%56 = icmp slt i32 %2, %1
%57 = and i1 %56, %55
br label %58
58: ; preds = %30, %4, %54, %52, %47, %41, %35
%59 = phi i1 [ %39, %35 ], [ %45, %41 ], [ %49, %47 ], [ %53, %52 ], [ %57, %54 ], [ true, %4 ], [ true, %30 ]
%60 = zext i1 %59 to i32
ret i32 %60
}