#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_equallong_equalulong(long, long);
int _test_various_MIN_equallong_equalulong() {
  _test_MIN_equallong_equalulong(0, 0);
  _test_MIN_equallong_equalulong(1, 1);
  _test_MIN_equallong_equalulong(
      ((((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_equallong_equalulong(
      ((((unsigned long)((-((unsigned long)(((unsigned long)(((unsigned long)1)
                                                             << ((sizeof(
                                                                      unsigned long) *
                                                                  CHAR_BIT) -
                                                                 2))) +
                                            ((unsigned long)(((unsigned long)(((unsigned long)1)
                                                                              << ((sizeof(
                                                                                       unsigned long) *
                                                                                   CHAR_BIT) -
                                                                                  2))) -
                                                             1))))) -
                         1)) < ((unsigned long)0))
           ? ((unsigned long)((-((unsigned long)(((unsigned long)(((unsigned long)1)
                                                                  << ((sizeof(
                                                                           unsigned long) *
                                                                       CHAR_BIT) -
                                                                      2))) +
                                                 ((unsigned long)(((unsigned long)(((unsigned long)1)
                                                                                   << ((sizeof(
                                                                                            unsigned long) *
                                                                                        CHAR_BIT) -
                                                                                       2))) -
                                                                  1))))) -
                              1))
           : ((unsigned long)0)),
      ((((unsigned long)((-((unsigned long)(((unsigned long)(((unsigned long)1)
                                                             << ((sizeof(
                                                                      unsigned long) *
                                                                  CHAR_BIT) -
                                                                 2))) +
                                            ((unsigned long)(((unsigned long)(((unsigned long)1)
                                                                              << ((sizeof(
                                                                                       unsigned long) *
                                                                                   CHAR_BIT) -
                                                                                  2))) -
                                                             1))))) -
                         1)) < ((unsigned long)0))
           ? ((unsigned long)((-((unsigned long)(((unsigned long)(((unsigned long)1)
                                                                  << ((sizeof(
                                                                           unsigned long) *
                                                                       CHAR_BIT) -
                                                                      2))) +
                                                 ((unsigned long)(((unsigned long)(((unsigned long)1)
                                                                                   << ((sizeof(
                                                                                            unsigned long) *
                                                                                        CHAR_BIT) -
                                                                                       2))) -
                                                                  1))))) -
                              1))
           : ((unsigned long)0)));
  _test_MIN_equallong_equalulong(
      ((((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)))));
  _test_MIN_equallong_equalulong(
      ((((long)(((long)(((long)1) << ((sizeof(long) * CHAR_BIT) - 2))) +
                ((long)(((long)(((long)1) << ((sizeof(long) * CHAR_BIT) - 2))) -
                        1)))) > ((long)(~((long)0))))
           ? ((long)(((long)(((long)1) << ((sizeof(long) * CHAR_BIT) - 2))) +
                     ((long)(((long)(((long)1)
                                     << ((sizeof(long) * CHAR_BIT) - 2))) -
                             1))))
           : ((long)(~((long)0)))),
      ((((long)(((long)(((long)1) << ((sizeof(long) * CHAR_BIT) - 2))) +
                ((long)(((long)(((long)1) << ((sizeof(long) * CHAR_BIT) - 2))) -
                        1)))) > ((long)(~((long)0))))
           ? ((long)(((long)(((long)1) << ((sizeof(long) * CHAR_BIT) - 2))) +
                     ((long)(((long)(((long)1)
                                     << ((sizeof(long) * CHAR_BIT) - 2))) -
                             1))))
           : ((long)(~((long)0)))));
  return 0;
}


x86 assembly (clang, -O0):
<_test_various_MIN_equallong_equalulong>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
xor    %eax,%eax
mov    %eax,%esi
mov    %rsi,%rdi
call   1030 <_test_MIN_equallong_equalulong@plt>
mov    $0x1,%esi
mov    %rsi,%rdi
call   1030 <_test_MIN_equallong_equalulong@plt>
mov    0x2ea5(%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    0x2e87(%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    11d5 <_test_various_MIN_equallong_equalulong+0xc5>
mov    0x2e54(%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    0x2e36(%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    11df <_test_various_MIN_equallong_equalulong+0xcf>
xor    %eax,%eax
mov    %eax,-0x8(%rbp)
jmp    11df <_test_various_MIN_equallong_equalulong+0xcf>
mov    -0x8(%rbp),%eax
mov    %eax,%eax
mov    %rax,-0x18(%rbp)
mov    0x2df1(%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    0x2dd3(%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    1289 <_test_various_MIN_equallong_equalulong+0x179>
mov    0x2da0(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x20(%rbp)
mov    0x2d82(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1293 <_test_various_MIN_equallong_equalulong+0x183>
xor    %eax,%eax
mov    %eax,-0x1c(%rbp)
jmp    1293 <_test_various_MIN_equallong_equalulong+0x183>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%eax
mov    %eax,%eax
mov    %eax,%esi
call   1030 <_test_MIN_equallong_equalulong@plt>
mov    0x2d36(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x28(%rbp)
mov    0x2d18(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    134e <_test_various_MIN_equallong_equalulong+0x23e>
mov    0x2ce0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x38(%rbp)
mov    0x2cc2(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1359 <_test_various_MIN_equallong_equalulong+0x249>
xor    %eax,%eax
mov    %rax,-0x30(%rbp)
jmp    1359 <_test_various_MIN_equallong_equalulong+0x249>
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    0x2c78(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x40(%rbp)
mov    0x2c5a(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    140c <_test_various_MIN_equallong_equalulong+0x2fc>
mov    0x2c22(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x58(%rbp)
mov    0x2c04(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1417 <_test_various_MIN_equallong_equalulong+0x307>
xor    %eax,%eax
mov    %rax,-0x50(%rbp)
jmp    1417 <_test_various_MIN_equallong_equalulong+0x307>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   1030 <_test_MIN_equallong_equalulong@plt>
mov    0x2bb5(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2b9a(%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    14ab <_test_various_MIN_equallong_equalulong+0x39b>
mov    0x2b71(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2b56(%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,-0x5c(%rbp)
jmp    14b8 <_test_various_MIN_equallong_equalulong+0x3a8>
mov    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    14b8 <_test_various_MIN_equallong_equalulong+0x3a8>
mov    -0x5c(%rbp),%eax
cltq
mov    %rax,-0x68(%rbp)
mov    0x2b18(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2afd(%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    1548 <_test_various_MIN_equallong_equalulong+0x438>
mov    0x2ad4(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2ab9(%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,-0x6c(%rbp)
jmp    1555 <_test_various_MIN_equallong_equalulong+0x445>
mov    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
jmp    1555 <_test_various_MIN_equallong_equalulong+0x445>
mov    -0x68(%rbp),%rdi
mov    -0x6c(%rbp),%eax
movslq %eax,%rsi
call   1030 <_test_MIN_equallong_equalulong@plt>
mov    0x2a75(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2a5b(%rip),%rcx
movslq (%rcx),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
sub    $0x1,%rcx
add    %rcx,%rax
cmp    $0xffffffffffffffff,%rax
jle    15f3 <_test_various_MIN_equallong_equalulong+0x4e3>
mov    0x2a2d(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2a13(%rip),%rcx
movslq (%rcx),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
sub    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    1603 <_test_various_MIN_equallong_equalulong+0x4f3>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x78(%rbp)
jmp    1603 <_test_various_MIN_equallong_equalulong+0x4f3>
mov    -0x78(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    0x29ce(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x29b4(%rip),%rcx
movslq (%rcx),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
sub    $0x1,%rcx
add    %rcx,%rax
cmp    $0xffffffffffffffff,%rax
jle    169d <_test_various_MIN_equallong_equalulong+0x58d>
mov    0x2986(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x296c(%rip),%rcx
movslq (%rcx),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
sub    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
jmp    16b0 <_test_various_MIN_equallong_equalulong+0x5a0>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x88(%rbp)
jmp    16b0 <_test_various_MIN_equallong_equalulong+0x5a0>
mov    -0x80(%rbp),%rdi
mov    -0x88(%rbp),%rsi
call   1030 <_test_MIN_equallong_equalulong@plt>
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_test_various_MIN_equallong_equalulong>:
push   %rbx
xor    %edi,%edi
xor    %esi,%esi
call   1030 <_test_MIN_equallong_equalulong@plt>
mov    $0x1,%edi
mov    $0x1,%esi
call   1030 <_test_MIN_equallong_equalulong@plt>
xor    %edi,%edi
xor    %esi,%esi
call   1030 <_test_MIN_equallong_equalulong@plt>
xor    %edi,%edi
xor    %esi,%esi
call   1030 <_test_MIN_equallong_equalulong@plt>
mov    0x2e9e(%rip),%rbx
mov    (%rbx),%cl
shl    $0x2,%cl
add    $0xfe,%cl
mov    $0x2,%eax
shl    %cl,%eax
add    $0xffffffff,%eax
mov    $0xffffffff,%ecx
cmovns %eax,%ecx
movslq %ecx,%rdi
mov    %rdi,%rsi
call   1030 <_test_MIN_equallong_equalulong@plt>
mov    (%rbx),%cl
shl    $0x3,%cl
add    $0xfe,%cl
mov    $0x2,%eax
shl    %cl,%rax
add    $0xffffffffffffffff,%rax
mov    $0xffffffffffffffff,%rdi
cmovns %rax,%rdi
mov    %rdi,%rsi
call   1030 <_test_MIN_equallong_equalulong@plt>
xor    %eax,%eax
pop    %rbx
ret

LLVM IR (-O0):
@CHAR_BIT = global i32 0
define i32 @_test_various_MIN_equallong_equalulong() {
%1 = call i32 @_test_MIN_equallong_equalulong(i64 0, i64 0)
%2 = call i32 @_test_MIN_equallong_equalulong(i64 1, i64 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 = zext i32 %39 to i64
%41 = load i32, i32* @CHAR_BIT
%42 = sext i32 %41 to i64
%43 = mul i64 4, %42
%44 = sub i64 %43, 2
%45 = trunc i64 %44 to i32
%46 = shl i32 1, %45
%47 = load i32, i32* @CHAR_BIT
%48 = sext i32 %47 to i64
%49 = mul i64 4, %48
%50 = sub i64 %49, 2
%51 = trunc i64 %50 to i32
%52 = shl i32 1, %51
%53 = sub i32 %52, 1
%54 = add i32 %46, %53
%55 = sub i32 0, %54
%56 = sub i32 %55, 1
%57 = icmp ult i32 %56, 0
br i1 %57, label %58, label %75
58: ; preds = %38
%59 = load i32, i32* @CHAR_BIT
%60 = sext i32 %59 to i64
%61 = mul i64 4, %60
%62 = sub i64 %61, 2
%63 = trunc i64 %62 to i32
%64 = shl i32 1, %63
%65 = load i32, i32* @CHAR_BIT
%66 = sext i32 %65 to i64
%67 = mul i64 4, %66
%68 = sub i64 %67, 2
%69 = trunc i64 %68 to i32
%70 = shl i32 1, %69
%71 = sub i32 %70, 1
%72 = add i32 %64, %71
%73 = sub i32 0, %72
%74 = sub i32 %73, 1
br label %76
75: ; preds = %38
br label %76
76: ; preds = %75, %58
%77 = phi i32 [ %74, %58 ], [ 0, %75 ]
%78 = zext i32 %77 to i64
%79 = call i32 @_test_MIN_equallong_equalulong(i64 %40, i64 %78)
%80 = load i32, i32* @CHAR_BIT
%81 = sext i32 %80 to i64
%82 = mul i64 8, %81
%83 = sub i64 %82, 2
%84 = shl i64 1, %83
%85 = load i32, i32* @CHAR_BIT
%86 = sext i32 %85 to i64
%87 = mul i64 8, %86
%88 = sub i64 %87, 2
%89 = shl i64 1, %88
%90 = sub i64 %89, 1
%91 = add i64 %84, %90
%92 = sub i64 0, %91
%93 = sub i64 %92, 1
%94 = icmp ult i64 %93, 0
br i1 %94, label %95, label %110
95: ; preds = %76
%96 = load i32, i32* @CHAR_BIT
%97 = sext i32 %96 to i64
%98 = mul i64 8, %97
%99 = sub i64 %98, 2
%100 = shl i64 1, %99
%101 = load i32, i32* @CHAR_BIT
%102 = sext i32 %101 to i64
%103 = mul i64 8, %102
%104 = sub i64 %103, 2
%105 = shl i64 1, %104
%106 = sub i64 %105, 1
%107 = add i64 %100, %106
%108 = sub i64 0, %107
%109 = sub i64 %108, 1
br label %111
110: ; preds = %76
br label %111
111: ; preds = %110, %95
%112 = phi i64 [ %109, %95 ], [ 0, %110 ]
%113 = load i32, i32* @CHAR_BIT
%114 = sext i32 %113 to i64
%115 = mul i64 8, %114
%116 = sub i64 %115, 2
%117 = shl i64 1, %116
%118 = load i32, i32* @CHAR_BIT
%119 = sext i32 %118 to i64
%120 = mul i64 8, %119
%121 = sub i64 %120, 2
%122 = shl i64 1, %121
%123 = sub i64 %122, 1
%124 = add i64 %117, %123
%125 = sub i64 0, %124
%126 = sub i64 %125, 1
%127 = icmp ult i64 %126, 0
br i1 %127, label %128, label %143
128: ; preds = %111
%129 = load i32, i32* @CHAR_BIT
%130 = sext i32 %129 to i64
%131 = mul i64 8, %130
%132 = sub i64 %131, 2
%133 = shl i64 1, %132
%134 = load i32, i32* @CHAR_BIT
%135 = sext i32 %134 to i64
%136 = mul i64 8, %135
%137 = sub i64 %136, 2
%138 = shl i64 1, %137
%139 = sub i64 %138, 1
%140 = add i64 %133, %139
%141 = sub i64 0, %140
%142 = sub i64 %141, 1
br label %144
143: ; preds = %111
br label %144
144: ; preds = %143, %128
%145 = phi i64 [ %142, %128 ], [ 0, %143 ]
%146 = call i32 @_test_MIN_equallong_equalulong(i64 %112, i64 %145)
%147 = load i32, i32* @CHAR_BIT
%148 = sext i32 %147 to i64
%149 = mul i64 4, %148
%150 = sub i64 %149, 2
%151 = trunc i64 %150 to i32
%152 = shl i32 1, %151
%153 = load i32, i32* @CHAR_BIT
%154 = sext i32 %153 to i64
%155 = mul i64 4, %154
%156 = sub i64 %155, 2
%157 = trunc i64 %156 to i32
%158 = shl i32 1, %157
%159 = sub nsw i32 %158, 1
%160 = add nsw i32 %152, %159
%161 = icmp sgt i32 %160, -1
br i1 %161, label %162, label %177
162: ; preds = %144
%163 = load i32, i32* @CHAR_BIT
%164 = sext i32 %163 to i64
%165 = mul i64 4, %164
%166 = sub i64 %165, 2
%167 = trunc i64 %166 to i32
%168 = shl i32 1, %167
%169 = load i32, i32* @CHAR_BIT
%170 = sext i32 %169 to i64
%171 = mul i64 4, %170
%172 = sub i64 %171, 2
%173 = trunc i64 %172 to i32
%174 = shl i32 1, %173
%175 = sub nsw i32 %174, 1
%176 = add nsw i32 %168, %175
br label %178
177: ; preds = %144
br label %178
178: ; preds = %177, %162
%179 = phi i32 [ %176, %162 ], [ -1, %177 ]
%180 = sext i32 %179 to i64
%181 = load i32, i32* @CHAR_BIT
%182 = sext i32 %181 to i64
%183 = mul i64 4, %182
%184 = sub i64 %183, 2
%185 = trunc i64 %184 to i32
%186 = shl i32 1, %185
%187 = load i32, i32* @CHAR_BIT
%188 = sext i32 %187 to i64
%189 = mul i64 4, %188
%190 = sub i64 %189, 2
%191 = trunc i64 %190 to i32
%192 = shl i32 1, %191
%193 = sub nsw i32 %192, 1
%194 = add nsw i32 %186, %193
%195 = icmp sgt i32 %194, -1
br i1 %195, label %196, label %211
196: ; preds = %178
%197 = load i32, i32* @CHAR_BIT
%198 = sext i32 %197 to i64
%199 = mul i64 4, %198
%200 = sub i64 %199, 2
%201 = trunc i64 %200 to i32
%202 = shl i32 1, %201
%203 = load i32, i32* @CHAR_BIT
%204 = sext i32 %203 to i64
%205 = mul i64 4, %204
%206 = sub i64 %205, 2
%207 = trunc i64 %206 to i32
%208 = shl i32 1, %207
%209 = sub nsw i32 %208, 1
%210 = add nsw i32 %202, %209
br label %212
211: ; preds = %178
br label %212
212: ; preds = %211, %196
%213 = phi i32 [ %210, %196 ], [ -1, %211 ]
%214 = sext i32 %213 to i64
%215 = call i32 @_test_MIN_equallong_equalulong(i64 %180, i64 %214)
%216 = load i32, i32* @CHAR_BIT
%217 = sext i32 %216 to i64
%218 = mul i64 8, %217
%219 = sub i64 %218, 2
%220 = shl i64 1, %219
%221 = load i32, i32* @CHAR_BIT
%222 = sext i32 %221 to i64
%223 = mul i64 8, %222
%224 = sub i64 %223, 2
%225 = shl i64 1, %224
%226 = sub nsw i64 %225, 1
%227 = add nsw i64 %220, %226
%228 = icmp sgt i64 %227, -1
br i1 %228, label %229, label %242
229: ; preds = %212
%230 = load i32, i32* @CHAR_BIT
%231 = sext i32 %230 to i64
%232 = mul i64 8, %231
%233 = sub i64 %232, 2
%234 = shl i64 1, %233
%235 = load i32, i32* @CHAR_BIT
%236 = sext i32 %235 to i64
%237 = mul i64 8, %236
%238 = sub i64 %237, 2
%239 = shl i64 1, %238
%240 = sub nsw i64 %239, 1
%241 = add nsw i64 %234, %240
br label %243
242: ; preds = %212
br label %243
243: ; preds = %242, %229
%244 = phi i64 [ %241, %229 ], [ -1, %242 ]
%245 = load i32, i32* @CHAR_BIT
%246 = sext i32 %245 to i64
%247 = mul i64 8, %246
%248 = sub i64 %247, 2
%249 = shl i64 1, %248
%250 = load i32, i32* @CHAR_BIT
%251 = sext i32 %250 to i64
%252 = mul i64 8, %251
%253 = sub i64 %252, 2
%254 = shl i64 1, %253
%255 = sub nsw i64 %254, 1
%256 = add nsw i64 %249, %255
%257 = icmp sgt i64 %256, -1
br i1 %257, label %258, label %271
258: ; preds = %243
%259 = load i32, i32* @CHAR_BIT
%260 = sext i32 %259 to i64
%261 = mul i64 8, %260
%262 = sub i64 %261, 2
%263 = shl i64 1, %262
%264 = load i32, i32* @CHAR_BIT
%265 = sext i32 %264 to i64
%266 = mul i64 8, %265
%267 = sub i64 %266, 2
%268 = shl i64 1, %267
%269 = sub nsw i64 %268, 1
%270 = add nsw i64 %263, %269
br label %272
271: ; preds = %243
br label %272
272: ; preds = %271, %258
%273 = phi i64 [ %270, %258 ], [ -1, %271 ]
%274 = call i32 @_test_MIN_equallong_equalulong(i64 %244, i64 %273)
ret i32 0
}

LLVM IR (-O2):
@CHAR_BIT = global i32 0
define i32 @_test_various_MIN_equallong_equalulong() {
%1 = tail call i32 @_test_MIN_equallong_equalulong(i64 0, i64 0)
%2 = tail call i32 @_test_MIN_equallong_equalulong(i64 1, i64 1)
%3 = tail call i32 @_test_MIN_equallong_equalulong(i64 0, i64 0)
%4 = tail call i32 @_test_MIN_equallong_equalulong(i64 0, i64 0)
%5 = load i32, i32* @CHAR_BIT
%6 = shl i32 %5, 2
%7 = add i32 %6, -2
%8 = shl i32 2, %7
%9 = add i32 %8, -1
%10 = icmp sgt i32 %9, -1
%11 = select i1 %10, i32 %9, i32 -1
%12 = sext i32 %11 to i64
%13 = tail call i32 @_test_MIN_equallong_equalulong(i64 %12, i64 %12)
%14 = load i32, i32* @CHAR_BIT
%15 = sext i32 %14 to i64
%16 = shl nsw i64 %15, 3
%17 = add nsw i64 %16, -2
%18 = shl i64 2, %17
%19 = add i64 %18, -1
%20 = icmp sgt i64 %19, -1
%21 = select i1 %20, i64 %19, i64 -1
%22 = tail call i32 @_test_MIN_equallong_equalulong(i64 %21, i64 %21)
ret i32 0
}