#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 CHAR_BIT;
int /*<<< orphan*/ _test_MIN_equalint_equaluint(int, int);
int _test_various_MIN_equalint_equaluint() {
  _test_MIN_equalint_equaluint(0, 0);
  _test_MIN_equalint_equaluint(1, 1);
  _test_MIN_equalint_equaluint(
      ((((unsigned int)((-((unsigned int)(((unsigned int)(((unsigned int)1)
                                                          << ((sizeof(
                                                                   unsigned int) *
                                                               CHAR_BIT) -
                                                              2))) +
                                          ((unsigned int)(((unsigned int)(((unsigned int)1)
                                                                          << ((sizeof(
                                                                                   unsigned int) *
                                                                               CHAR_BIT) -
                                                                              2))) -
                                                          1))))) -
                        1)) < ((unsigned int)0))
           ? ((unsigned int)((-((unsigned int)(((unsigned int)(((unsigned int)1)
                                                               << ((sizeof(
                                                                        unsigned int) *
                                                                    CHAR_BIT) -
                                                                   2))) +
                                               ((unsigned int)(((unsigned int)(((unsigned int)1)
                                                                               << ((sizeof(
                                                                                        unsigned int) *
                                                                                    CHAR_BIT) -
                                                                                   2))) -
                                                               1))))) -
                             1))
           : ((unsigned int)0)),
      ((((unsigned int)((-((unsigned int)(((unsigned int)(((unsigned int)1)
                                                          << ((sizeof(
                                                                   unsigned int) *
                                                               CHAR_BIT) -
                                                              2))) +
                                          ((unsigned int)(((unsigned int)(((unsigned int)1)
                                                                          << ((sizeof(
                                                                                   unsigned int) *
                                                                               CHAR_BIT) -
                                                                              2))) -
                                                          1))))) -
                        1)) < ((unsigned int)0))
           ? ((unsigned int)((-((unsigned int)(((unsigned int)(((unsigned int)1)
                                                               << ((sizeof(
                                                                        unsigned int) *
                                                                    CHAR_BIT) -
                                                                   2))) +
                                               ((unsigned int)(((unsigned int)(((unsigned int)1)
                                                                               << ((sizeof(
                                                                                        unsigned int) *
                                                                                    CHAR_BIT) -
                                                                                   2))) -
                                                               1))))) -
                             1))
           : ((unsigned int)0)));
  _test_MIN_equalint_equaluint(
      ((((int)(((int)(((int)1) << ((sizeof(int) * CHAR_BIT) - 2))) +
               ((int)(((int)(((int)1) << ((sizeof(int) * CHAR_BIT) - 2))) -
                      1)))) > ((int)(~((int)0))))
           ? ((int)(((int)(((int)1) << ((sizeof(int) * CHAR_BIT) - 2))) +
                    ((int)(((int)(((int)1) << ((sizeof(int) * CHAR_BIT) - 2))) -
                           1))))
           : ((int)(~((int)0)))),
      ((((int)(((int)(((int)1) << ((sizeof(int) * CHAR_BIT) - 2))) +
               ((int)(((int)(((int)1) << ((sizeof(int) * CHAR_BIT) - 2))) -
                      1)))) > ((int)(~((int)0))))
           ? ((int)(((int)(((int)1) << ((sizeof(int) * CHAR_BIT) - 2))) +
                    ((int)(((int)(((int)1) << ((sizeof(int) * CHAR_BIT) - 2))) -
                           1))))
           : ((int)(~((int)0)))));
  return 0;
}


x86 assembly (clang, -O0):
<_test_various_MIN_equalint_equaluint>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
xor    %esi,%esi
mov    %esi,%edi
call   1030 <_test_MIN_equalint_equaluint@plt>
mov    $0x1,%esi
mov    %esi,%edi
call   1030 <_test_MIN_equalint_equaluint@plt>
mov    0x2eac(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x4(%rbp)
mov    0x2e8e(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jae    11ce <_test_various_MIN_equalint_equaluint+0xbe>
mov    0x2e5b(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0xc(%rbp)
mov    0x2e3d(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11d8 <_test_various_MIN_equalint_equaluint+0xc8>
xor    %eax,%eax
mov    %eax,-0x8(%rbp)
jmp    11d8 <_test_various_MIN_equalint_equaluint+0xc8>
mov    -0x8(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    0x2dfb(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x10(%rbp)
mov    0x2ddd(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jae    127f <_test_various_MIN_equalint_equaluint+0x16f>
mov    0x2daa(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x1c(%rbp)
mov    0x2d8c(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1289 <_test_various_MIN_equalint_equaluint+0x179>
xor    %eax,%eax
mov    %eax,-0x18(%rbp)
jmp    1289 <_test_various_MIN_equalint_equaluint+0x179>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
call   1030 <_test_MIN_equalint_equaluint@plt>
mov    0x2d45(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2d2a(%rip),%rcx
movslq (%rcx),%rcx
shl    $0x2,%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    $0x1,%ecx
add    %ecx,%eax
cmp    $0xffffffff,%eax
jle    131b <_test_various_MIN_equalint_equaluint+0x20b>
mov    0x2d01(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2ce6(%rip),%rcx
movslq (%rcx),%rcx
shl    $0x2,%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
jmp    1328 <_test_various_MIN_equalint_equaluint+0x218>
mov    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1328 <_test_various_MIN_equalint_equaluint+0x218>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    0x2cab(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2c90(%rip),%rcx
movslq (%rcx),%rcx
shl    $0x2,%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    $0x1,%ecx
add    %ecx,%eax
cmp    $0xffffffff,%eax
jle    13b5 <_test_various_MIN_equalint_equaluint+0x2a5>
mov    0x2c67(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2c4c(%rip),%rcx
movslq (%rcx),%rcx
shl    $0x2,%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
jmp    13c2 <_test_various_MIN_equalint_equaluint+0x2b2>
mov    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    13c2 <_test_various_MIN_equalint_equaluint+0x2b2>
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
call   1030 <_test_MIN_equalint_equaluint@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_test_various_MIN_equalint_equaluint>:
push   %rax
xor    %edi,%edi
xor    %esi,%esi
call   1030 <_test_MIN_equalint_equaluint@plt>
mov    $0x1,%edi
mov    $0x1,%esi
call   1030 <_test_MIN_equalint_equaluint@plt>
xor    %edi,%edi
xor    %esi,%esi
call   1030 <_test_MIN_equalint_equaluint@plt>
mov    0x2ea7(%rip),%rax
mov    (%rax),%cl
shl    $0x2,%cl
add    $0xfe,%cl
mov    $0x2,%eax
shl    %cl,%eax
add    $0xffffffff,%eax
mov    $0xffffffff,%edi
cmovns %eax,%edi
mov    %edi,%esi
call   1030 <_test_MIN_equalint_equaluint@plt>
xor    %eax,%eax
pop    %rcx
ret

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

LLVM IR (-O2):
@CHAR_BIT = global i32 0
define i32 @_test_various_MIN_equalint_equaluint() {
%1 = tail call i32 @_test_MIN_equalint_equaluint(i32 0, i32 0)
%2 = tail call i32 @_test_MIN_equalint_equaluint(i32 1, i32 1)
%3 = tail call i32 @_test_MIN_equalint_equaluint(i32 0, i32 0)
%4 = load i32, i32* @CHAR_BIT
%5 = shl i32 %4, 2
%6 = add i32 %5, -2
%7 = shl i32 2, %6
%8 = add i32 %7, -1
%9 = icmp sgt i32 %8, -1
%10 = select i1 %9, i32 %8, i32 -1
%11 = tail call i32 @_test_MIN_equalint_equaluint(i32 %10, i32 %10)
ret i32 0
}