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


x86 assembly (clang, -O0):
<_test_various_MIN_smallerlong_biggerulong>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
mov    $0xffffffffffffffff,%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0xffffffffffffffff,%rdi
mov    $0x1,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3e9d(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3e82(%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
jbe    11c3 <_test_various_MIN_smallerlong_biggerulong+0xb3>
mov    0x3e59(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3e3e(%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,-0x4(%rbp)
jmp    11d0 <_test_various_MIN_smallerlong_biggerulong+0xc0>
mov    $0xffffffff,%eax
mov    %eax,-0x4(%rbp)
jmp    11d0 <_test_various_MIN_smallerlong_biggerulong+0xc0>
mov    -0x4(%rbp),%eax
mov    %eax,%eax
mov    %eax,%esi
mov    $0xffffffffffffffff,%rdi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3df6(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3ddc(%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
jbe    1272 <_test_various_MIN_smallerlong_biggerulong+0x162>
mov    0x3dae(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3d94(%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,-0x10(%rbp)
jmp    1282 <_test_various_MIN_smallerlong_biggerulong+0x172>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
jmp    1282 <_test_various_MIN_smallerlong_biggerulong+0x172>
mov    -0x10(%rbp),%rsi
mov    $0xffffffffffffffff,%rdi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
xor    %eax,%eax
mov    %eax,%edi
mov    $0x1,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
xor    %eax,%eax
mov    %eax,%edi
mov    $0x2,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3d2b(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3d10(%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
jbe    1335 <_test_various_MIN_smallerlong_biggerulong+0x225>
mov    0x3ce7(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3ccc(%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,-0x14(%rbp)
jmp    1342 <_test_various_MIN_smallerlong_biggerulong+0x232>
mov    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1342 <_test_various_MIN_smallerlong_biggerulong+0x232>
mov    -0x14(%rbp),%eax
mov    %eax,%eax
mov    %eax,%esi
xor    %eax,%eax
mov    %eax,%edi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3c87(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3c6d(%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
jbe    13e1 <_test_various_MIN_smallerlong_biggerulong+0x2d1>
mov    0x3c3f(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3c25(%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,-0x20(%rbp)
jmp    13f1 <_test_various_MIN_smallerlong_biggerulong+0x2e1>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
jmp    13f1 <_test_various_MIN_smallerlong_biggerulong+0x2e1>
mov    -0x20(%rbp),%rsi
xor    %eax,%eax
mov    %eax,%edi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x1,%edi
mov    $0x2,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x1,%edi
mov    $0x3,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3bbd(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3ba2(%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
jbe    14a3 <_test_various_MIN_smallerlong_biggerulong+0x393>
mov    0x3b79(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3b5e(%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,-0x24(%rbp)
jmp    14b0 <_test_various_MIN_smallerlong_biggerulong+0x3a0>
mov    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    14b0 <_test_various_MIN_smallerlong_biggerulong+0x3a0>
mov    -0x24(%rbp),%eax
mov    %eax,%eax
mov    %eax,%esi
mov    $0x1,%edi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3b18(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3afe(%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
jbe    1550 <_test_various_MIN_smallerlong_biggerulong+0x440>
mov    0x3ad0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3ab6(%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,-0x30(%rbp)
jmp    1560 <_test_various_MIN_smallerlong_biggerulong+0x450>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    1560 <_test_various_MIN_smallerlong_biggerulong+0x450>
mov    -0x30(%rbp),%rsi
mov    $0x1,%edi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3a6b(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x34(%rbp)
mov    0x3a4d(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    160f <_test_various_MIN_smallerlong_biggerulong+0x4ff>
mov    0x3a1a(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x3c(%rbp)
mov    0x39fc(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1619 <_test_various_MIN_smallerlong_biggerulong+0x509>
xor    %eax,%eax
mov    %eax,-0x38(%rbp)
jmp    1619 <_test_various_MIN_smallerlong_biggerulong+0x509>
mov    -0x38(%rbp),%eax
movslq %eax,%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x39b1(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x40(%rbp)
mov    0x3993(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    16c9 <_test_various_MIN_smallerlong_biggerulong+0x5b9>
mov    0x3960(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x48(%rbp)
mov    0x3942(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x48(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    16d3 <_test_various_MIN_smallerlong_biggerulong+0x5c3>
xor    %eax,%eax
mov    %eax,-0x44(%rbp)
jmp    16d3 <_test_various_MIN_smallerlong_biggerulong+0x5c3>
mov    -0x44(%rbp),%eax
movslq %eax,%rdi
mov    $0x2,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x38f6(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x4c(%rbp)
mov    0x38d8(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    1784 <_test_various_MIN_smallerlong_biggerulong+0x674>
mov    0x38a5(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x54(%rbp)
mov    0x3887(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x54(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    178e <_test_various_MIN_smallerlong_biggerulong+0x67e>
xor    %eax,%eax
mov    %eax,-0x50(%rbp)
jmp    178e <_test_various_MIN_smallerlong_biggerulong+0x67e>
mov    -0x50(%rbp),%eax
cltq
mov    %rax,-0x60(%rbp)
mov    0x3842(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3827(%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
jbe    181e <_test_various_MIN_smallerlong_biggerulong+0x70e>
mov    0x37fe(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x37e3(%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,-0x64(%rbp)
jmp    182b <_test_various_MIN_smallerlong_biggerulong+0x71b>
mov    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
jmp    182b <_test_various_MIN_smallerlong_biggerulong+0x71b>
mov    -0x60(%rbp),%rdi
mov    -0x64(%rbp),%eax
mov    %eax,%eax
mov    %eax,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x379e(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x68(%rbp)
mov    0x3780(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x68(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    18dc <_test_various_MIN_smallerlong_biggerulong+0x7cc>
mov    0x374d(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x70(%rbp)
mov    0x372f(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x70(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    18e6 <_test_various_MIN_smallerlong_biggerulong+0x7d6>
xor    %eax,%eax
mov    %eax,-0x6c(%rbp)
jmp    18e6 <_test_various_MIN_smallerlong_biggerulong+0x7d6>
mov    -0x6c(%rbp),%eax
cltq
mov    %rax,-0x78(%rbp)
mov    0x36ea(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x36d0(%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
jbe    197e <_test_various_MIN_smallerlong_biggerulong+0x86e>
mov    0x36a2(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3688(%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,-0x80(%rbp)
jmp    198e <_test_various_MIN_smallerlong_biggerulong+0x87e>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
jmp    198e <_test_various_MIN_smallerlong_biggerulong+0x87e>
mov    -0x78(%rbp),%rdi
mov    -0x80(%rbp),%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x363e(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x84(%rbp)
mov    0x361d(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x84(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    1a4b <_test_various_MIN_smallerlong_biggerulong+0x93b>
mov    0x35e7(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x8c(%rbp)
mov    0x35c6(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x8c(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1a58 <_test_various_MIN_smallerlong_biggerulong+0x948>
xor    %eax,%eax
mov    %eax,-0x88(%rbp)
jmp    1a58 <_test_various_MIN_smallerlong_biggerulong+0x948>
mov    -0x88(%rbp),%eax
cltq
mov    %rax,-0x98(%rbp)
mov    0x3572(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x90(%rbp)
mov    0x3551(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x90(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jae    1b17 <_test_various_MIN_smallerlong_biggerulong+0xa07>
mov    0x351b(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0xa0(%rbp)
mov    0x34fa(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0xa0(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1b24 <_test_various_MIN_smallerlong_biggerulong+0xa14>
xor    %eax,%eax
mov    %eax,-0x9c(%rbp)
jmp    1b24 <_test_various_MIN_smallerlong_biggerulong+0xa14>
mov    -0x98(%rbp),%rdi
mov    -0x9c(%rbp),%eax
mov    %eax,%eax
mov    %eax,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x349f(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0xa4(%rbp)
mov    0x347e(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0xa4(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jge    1bea <_test_various_MIN_smallerlong_biggerulong+0xada>
mov    0x3448(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0xac(%rbp)
mov    0x3427(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0xac(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1bf7 <_test_various_MIN_smallerlong_biggerulong+0xae7>
xor    %eax,%eax
mov    %eax,-0xa8(%rbp)
jmp    1bf7 <_test_various_MIN_smallerlong_biggerulong+0xae7>
mov    -0xa8(%rbp),%eax
cltq
mov    %rax,-0xc0(%rbp)
mov    0x33d3(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xb8(%rbp)
mov    0x33b2(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xb8(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    1cc0 <_test_various_MIN_smallerlong_biggerulong+0xbb0>
mov    0x3377(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xd0(%rbp)
mov    0x3356(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xd0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0xc8(%rbp)
jmp    1cce <_test_various_MIN_smallerlong_biggerulong+0xbbe>
xor    %eax,%eax
mov    %rax,-0xc8(%rbp)
jmp    1cce <_test_various_MIN_smallerlong_biggerulong+0xbbe>
mov    -0xc0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x32f8(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xd8(%rbp)
mov    0x32d7(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jge    1d9b <_test_various_MIN_smallerlong_biggerulong+0xc8b>
mov    0x329c(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xe8(%rbp)
mov    0x327b(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xe8(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0xe0(%rbp)
jmp    1da9 <_test_various_MIN_smallerlong_biggerulong+0xc99>
xor    %eax,%eax
mov    %rax,-0xe0(%rbp)
jmp    1da9 <_test_various_MIN_smallerlong_biggerulong+0xc99>
mov    -0xe0(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3220(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xf0(%rbp)
mov    0x31ff(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xf0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jge    1e73 <_test_various_MIN_smallerlong_biggerulong+0xd63>
mov    0x31c4(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x100(%rbp)
mov    0x31a3(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x100(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0xf8(%rbp)
jmp    1e81 <_test_various_MIN_smallerlong_biggerulong+0xd71>
xor    %eax,%eax
mov    %rax,-0xf8(%rbp)
jmp    1e81 <_test_various_MIN_smallerlong_biggerulong+0xd71>
mov    -0xf8(%rbp),%rdi
mov    $0x2,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x3147(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x108(%rbp)
mov    0x3126(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x108(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jge    1f4c <_test_various_MIN_smallerlong_biggerulong+0xe3c>
mov    0x30eb(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x118(%rbp)
mov    0x30ca(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x118(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x110(%rbp)
jmp    1f5a <_test_various_MIN_smallerlong_biggerulong+0xe4a>
xor    %eax,%eax
mov    %rax,-0x110(%rbp)
jmp    1f5a <_test_various_MIN_smallerlong_biggerulong+0xe4a>
mov    -0x110(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    0x3071(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3056(%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
jbe    1ff2 <_test_various_MIN_smallerlong_biggerulong+0xee2>
mov    0x302d(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x3012(%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,-0x124(%rbp)
jmp    2002 <_test_various_MIN_smallerlong_biggerulong+0xef2>
mov    $0xffffffff,%eax
mov    %eax,-0x124(%rbp)
jmp    2002 <_test_various_MIN_smallerlong_biggerulong+0xef2>
mov    -0x120(%rbp),%rdi
mov    -0x124(%rbp),%eax
mov    %eax,%eax
mov    %eax,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x2fc1(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x130(%rbp)
mov    0x2fa0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x130(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jge    20d2 <_test_various_MIN_smallerlong_biggerulong+0xfc2>
mov    0x2f65(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x140(%rbp)
mov    0x2f44(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x140(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x138(%rbp)
jmp    20e0 <_test_various_MIN_smallerlong_biggerulong+0xfd0>
xor    %eax,%eax
mov    %rax,-0x138(%rbp)
jmp    20e0 <_test_various_MIN_smallerlong_biggerulong+0xfd0>
mov    -0x138(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    0x2eeb(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2ed1(%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
jbe    2180 <_test_various_MIN_smallerlong_biggerulong+0x1070>
mov    0x2ea3(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2e89(%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,-0x150(%rbp)
jmp    2193 <_test_various_MIN_smallerlong_biggerulong+0x1083>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x150(%rbp)
jmp    2193 <_test_various_MIN_smallerlong_biggerulong+0x1083>
mov    -0x148(%rbp),%rdi
mov    -0x150(%rbp),%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x2e33(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x158(%rbp)
mov    0x2e12(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x158(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jge    2260 <_test_various_MIN_smallerlong_biggerulong+0x1150>
mov    0x2dd7(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x168(%rbp)
mov    0x2db6(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x168(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    226e <_test_various_MIN_smallerlong_biggerulong+0x115e>
xor    %eax,%eax
mov    %rax,-0x160(%rbp)
jmp    226e <_test_various_MIN_smallerlong_biggerulong+0x115e>
mov    -0x160(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    0x2d5d(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x16c(%rbp)
mov    0x2d3c(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x16c(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jae    232c <_test_various_MIN_smallerlong_biggerulong+0x121c>
mov    0x2d06(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x180(%rbp)
mov    0x2ce5(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x180(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x17c(%rbp)
jmp    2339 <_test_various_MIN_smallerlong_biggerulong+0x1229>
xor    %eax,%eax
mov    %eax,-0x17c(%rbp)
jmp    2339 <_test_various_MIN_smallerlong_biggerulong+0x1229>
mov    -0x178(%rbp),%rdi
mov    -0x17c(%rbp),%eax
mov    %eax,%eax
mov    %eax,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x2c8a(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x188(%rbp)
mov    0x2c69(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x188(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jge    2409 <_test_various_MIN_smallerlong_biggerulong+0x12f9>
mov    0x2c2e(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x198(%rbp)
mov    0x2c0d(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x198(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x190(%rbp)
jmp    2417 <_test_various_MIN_smallerlong_biggerulong+0x1307>
xor    %eax,%eax
mov    %rax,-0x190(%rbp)
jmp    2417 <_test_various_MIN_smallerlong_biggerulong+0x1307>
mov    -0x190(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    0x2bb4(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x1a0(%rbp)
mov    0x2b93(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x1a0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    24df <_test_various_MIN_smallerlong_biggerulong+0x13cf>
mov    0x2b58(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x1b8(%rbp)
mov    0x2b37(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x1b8(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x1b0(%rbp)
jmp    24ed <_test_various_MIN_smallerlong_biggerulong+0x13dd>
xor    %eax,%eax
mov    %rax,-0x1b0(%rbp)
jmp    24ed <_test_various_MIN_smallerlong_biggerulong+0x13dd>
mov    -0x1a8(%rbp),%rdi
mov    -0x1b0(%rbp),%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
xor    %eax,%eax
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_test_various_MIN_smallerlong_biggerulong>:
push   %rbp
push   %rbx
push   %rax
mov    $0xffffffffffffffff,%rdi
xor    %esi,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x1,%esi
mov    $0xffffffffffffffff,%rdi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0xffffffff,%esi
mov    $0xffffffffffffffff,%rdi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0xffffffffffffffff,%rdi
mov    $0xffffffffffffffff,%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x1,%esi
xor    %edi,%edi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x2,%esi
xor    %edi,%edi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0xffffffff,%esi
xor    %edi,%edi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
xor    %edi,%edi
mov    $0xffffffffffffffff,%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x1,%edi
mov    $0x2,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x1,%edi
mov    $0x3,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x1,%edi
mov    $0xffffffff,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    $0x1,%edi
mov    $0xffffffffffffffff,%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    0x2e13(%rip),%rbx
mov    (%rbx),%cl
shl    $0x2,%cl
add    $0xfe,%cl
mov    $0xfffffffe,%eax
shl    %cl,%eax
mov    $0xfffffffe,%ebp
mov    %eax,%ecx
sar    $0x1f,%ecx
and    %eax,%ecx
movslq %ecx,%rdi
xor    %esi,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x2,%cl
add    $0xfe,%cl
mov    $0xfffffffe,%eax
shl    %cl,%eax
mov    %eax,%ecx
sar    $0x1f,%ecx
and    %eax,%ecx
movslq %ecx,%rdi
mov    $0x2,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x2,%cl
add    $0xfe,%cl
mov    $0xfffffffe,%eax
shl    %cl,%eax
mov    %eax,%ecx
sar    $0x1f,%ecx
and    %eax,%ecx
movslq %ecx,%rdi
mov    $0xffffffff,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x2,%cl
add    $0xfe,%cl
mov    $0xfffffffe,%eax
shl    %cl,%eax
mov    %eax,%ecx
sar    $0x1f,%ecx
and    %eax,%ecx
movslq %ecx,%rdi
mov    $0xffffffffffffffff,%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x2,%cl
add    $0xfe,%cl
mov    $0xfffffffe,%eax
shl    %cl,%eax
mov    %eax,%ecx
sar    $0x1f,%ecx
and    %eax,%ecx
movslq %ecx,%rdi
xor    %esi,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x2,%cl
add    $0xfe,%cl
shl    %cl,%ebp
mov    %ebp,%eax
sar    $0x1f,%eax
and    %ebp,%eax
movslq %eax,%rdi
xor    %esi,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x3,%cl
add    $0xfe,%cl
mov    $0xfffffffffffffffe,%rax
shl    %cl,%rax
mov    $0xfffffffffffffffe,%rbp
mov    %rax,%rdi
sar    $0x3f,%rdi
and    %rax,%rdi
xor    %esi,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x3,%cl
add    $0xfe,%cl
mov    $0xfffffffffffffffe,%rax
shl    %cl,%rax
mov    %rax,%rdi
sar    $0x3f,%rdi
and    %rax,%rdi
mov    $0x2,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x3,%cl
add    $0xfe,%cl
mov    $0xfffffffffffffffe,%rax
shl    %cl,%rax
mov    %rax,%rdi
sar    $0x3f,%rdi
and    %rax,%rdi
mov    $0xffffffff,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x3,%cl
add    $0xfe,%cl
mov    $0xfffffffffffffffe,%rax
shl    %cl,%rax
mov    %rax,%rdi
sar    $0x3f,%rdi
and    %rax,%rdi
mov    $0xffffffffffffffff,%rsi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x3,%cl
add    $0xfe,%cl
mov    $0xfffffffffffffffe,%rax
shl    %cl,%rax
mov    %rax,%rdi
sar    $0x3f,%rdi
and    %rax,%rdi
xor    %esi,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
mov    (%rbx),%cl
shl    $0x3,%cl
add    $0xfe,%cl
shl    %cl,%rbp
mov    %rbp,%rdi
sar    $0x3f,%rdi
and    %rbp,%rdi
xor    %esi,%esi
call   1030 <_test_MIN_smallerlong_biggerulong@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@CHAR_BIT = global i32 0
define i32 @_test_various_MIN_smallerlong_biggerulong() {
%1 = call i32 @_test_MIN_smallerlong_biggerulong(i64 -1, i64 0)
%2 = call i32 @_test_MIN_smallerlong_biggerulong(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 = icmp ugt i32 %16, -1
br i1 %17, label %18, label %33
18: ; preds = %0
%19 = load i32, i32* @CHAR_BIT
%20 = sext i32 %19 to i64
%21 = mul i64 4, %20
%22 = sub i64 %21, 2
%23 = trunc i64 %22 to i32
%24 = shl i32 1, %23
%25 = load i32, i32* @CHAR_BIT
%26 = sext i32 %25 to i64
%27 = mul i64 4, %26
%28 = sub i64 %27, 2
%29 = trunc i64 %28 to i32
%30 = shl i32 1, %29
%31 = sub i32 %30, 1
%32 = add i32 %24, %31
br label %34
33: ; preds = %0
br label %34
34: ; preds = %33, %18
%35 = phi i32 [ %32, %18 ], [ -1, %33 ]
%36 = zext i32 %35 to i64
%37 = call i32 @_test_MIN_smallerlong_biggerulong(i64 -1, i64 %36)
%38 = load i32, i32* @CHAR_BIT
%39 = sext i32 %38 to i64
%40 = mul i64 8, %39
%41 = sub i64 %40, 2
%42 = shl i64 1, %41
%43 = load i32, i32* @CHAR_BIT
%44 = sext i32 %43 to i64
%45 = mul i64 8, %44
%46 = sub i64 %45, 2
%47 = shl i64 1, %46
%48 = sub i64 %47, 1
%49 = add i64 %42, %48
%50 = icmp ugt i64 %49, -1
br i1 %50, label %51, label %64
51: ; preds = %34
%52 = load i32, i32* @CHAR_BIT
%53 = sext i32 %52 to i64
%54 = mul i64 8, %53
%55 = sub i64 %54, 2
%56 = shl i64 1, %55
%57 = load i32, i32* @CHAR_BIT
%58 = sext i32 %57 to i64
%59 = mul i64 8, %58
%60 = sub i64 %59, 2
%61 = shl i64 1, %60
%62 = sub i64 %61, 1
%63 = add i64 %56, %62
br label %65
64: ; preds = %34
br label %65
65: ; preds = %64, %51
%66 = phi i64 [ %63, %51 ], [ -1, %64 ]
%67 = call i32 @_test_MIN_smallerlong_biggerulong(i64 -1, i64 %66)
%68 = call i32 @_test_MIN_smallerlong_biggerulong(i64 0, i64 1)
%69 = call i32 @_test_MIN_smallerlong_biggerulong(i64 0, i64 2)
%70 = load i32, i32* @CHAR_BIT
%71 = sext i32 %70 to i64
%72 = mul i64 4, %71
%73 = sub i64 %72, 2
%74 = trunc i64 %73 to i32
%75 = shl i32 1, %74
%76 = load i32, i32* @CHAR_BIT
%77 = sext i32 %76 to i64
%78 = mul i64 4, %77
%79 = sub i64 %78, 2
%80 = trunc i64 %79 to i32
%81 = shl i32 1, %80
%82 = sub i32 %81, 1
%83 = add i32 %75, %82
%84 = icmp ugt i32 %83, -1
br i1 %84, label %85, label %100
85: ; preds = %65
%86 = load i32, i32* @CHAR_BIT
%87 = sext i32 %86 to i64
%88 = mul i64 4, %87
%89 = sub i64 %88, 2
%90 = trunc i64 %89 to i32
%91 = shl i32 1, %90
%92 = load i32, i32* @CHAR_BIT
%93 = sext i32 %92 to i64
%94 = mul i64 4, %93
%95 = sub i64 %94, 2
%96 = trunc i64 %95 to i32
%97 = shl i32 1, %96
%98 = sub i32 %97, 1
%99 = add i32 %91, %98
br label %101
100: ; preds = %65
br label %101
101: ; preds = %100, %85
%102 = phi i32 [ %99, %85 ], [ -1, %100 ]
%103 = zext i32 %102 to i64
%104 = call i32 @_test_MIN_smallerlong_biggerulong(i64 0, i64 %103)
%105 = load i32, i32* @CHAR_BIT
%106 = sext i32 %105 to i64
%107 = mul i64 8, %106
%108 = sub i64 %107, 2
%109 = shl i64 1, %108
%110 = load i32, i32* @CHAR_BIT
%111 = sext i32 %110 to i64
%112 = mul i64 8, %111
%113 = sub i64 %112, 2
%114 = shl i64 1, %113
%115 = sub i64 %114, 1
%116 = add i64 %109, %115
%117 = icmp ugt i64 %116, -1
br i1 %117, label %118, label %131
118: ; preds = %101
%119 = load i32, i32* @CHAR_BIT
%120 = sext i32 %119 to i64
%121 = mul i64 8, %120
%122 = sub i64 %121, 2
%123 = shl i64 1, %122
%124 = load i32, i32* @CHAR_BIT
%125 = sext i32 %124 to i64
%126 = mul i64 8, %125
%127 = sub i64 %126, 2
%128 = shl i64 1, %127
%129 = sub i64 %128, 1
%130 = add i64 %123, %129
br label %132
131: ; preds = %101
br label %132
132: ; preds = %131, %118
%133 = phi i64 [ %130, %118 ], [ -1, %131 ]
%134 = call i32 @_test_MIN_smallerlong_biggerulong(i64 0, i64 %133)
%135 = call i32 @_test_MIN_smallerlong_biggerulong(i64 1, i64 2)
%136 = call i32 @_test_MIN_smallerlong_biggerulong(i64 1, i64 3)
%137 = load i32, i32* @CHAR_BIT
%138 = sext i32 %137 to i64
%139 = mul i64 4, %138
%140 = sub i64 %139, 2
%141 = trunc i64 %140 to i32
%142 = shl i32 1, %141
%143 = load i32, i32* @CHAR_BIT
%144 = sext i32 %143 to i64
%145 = mul i64 4, %144
%146 = sub i64 %145, 2
%147 = trunc i64 %146 to i32
%148 = shl i32 1, %147
%149 = sub i32 %148, 1
%150 = add i32 %142, %149
%151 = icmp ugt i32 %150, -1
br i1 %151, label %152, label %167
152: ; preds = %132
%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 = load i32, i32* @CHAR_BIT
%160 = sext i32 %159 to i64
%161 = mul i64 4, %160
%162 = sub i64 %161, 2
%163 = trunc i64 %162 to i32
%164 = shl i32 1, %163
%165 = sub i32 %164, 1
%166 = add i32 %158, %165
br label %168
167: ; preds = %132
br label %168
168: ; preds = %167, %152
%169 = phi i32 [ %166, %152 ], [ -1, %167 ]
%170 = zext i32 %169 to i64
%171 = call i32 @_test_MIN_smallerlong_biggerulong(i64 1, i64 %170)
%172 = load i32, i32* @CHAR_BIT
%173 = sext i32 %172 to i64
%174 = mul i64 8, %173
%175 = sub i64 %174, 2
%176 = shl i64 1, %175
%177 = load i32, i32* @CHAR_BIT
%178 = sext i32 %177 to i64
%179 = mul i64 8, %178
%180 = sub i64 %179, 2
%181 = shl i64 1, %180
%182 = sub i64 %181, 1
%183 = add i64 %176, %182
%184 = icmp ugt i64 %183, -1
br i1 %184, label %185, label %198
185: ; preds = %168
%186 = load i32, i32* @CHAR_BIT
%187 = sext i32 %186 to i64
%188 = mul i64 8, %187
%189 = sub i64 %188, 2
%190 = shl i64 1, %189
%191 = load i32, i32* @CHAR_BIT
%192 = sext i32 %191 to i64
%193 = mul i64 8, %192
%194 = sub i64 %193, 2
%195 = shl i64 1, %194
%196 = sub i64 %195, 1
%197 = add i64 %190, %196
br label %199
198: ; preds = %168
br label %199
199: ; preds = %198, %185
%200 = phi i64 [ %197, %185 ], [ -1, %198 ]
%201 = call i32 @_test_MIN_smallerlong_biggerulong(i64 1, i64 %200)
%202 = load i32, i32* @CHAR_BIT
%203 = sext i32 %202 to i64
%204 = mul i64 4, %203
%205 = sub i64 %204, 2
%206 = trunc i64 %205 to i32
%207 = shl i32 1, %206
%208 = load i32, i32* @CHAR_BIT
%209 = sext i32 %208 to i64
%210 = mul i64 4, %209
%211 = sub i64 %210, 2
%212 = trunc i64 %211 to i32
%213 = shl i32 1, %212
%214 = sub nsw i32 %213, 1
%215 = add nsw i32 %207, %214
%216 = sub nsw i32 0, %215
%217 = sub nsw i32 %216, 1
%218 = icmp slt i32 %217, 0
br i1 %218, label %219, label %236
219: ; preds = %199
%220 = load i32, i32* @CHAR_BIT
%221 = sext i32 %220 to i64
%222 = mul i64 4, %221
%223 = sub i64 %222, 2
%224 = trunc i64 %223 to i32
%225 = shl i32 1, %224
%226 = load i32, i32* @CHAR_BIT
%227 = sext i32 %226 to i64
%228 = mul i64 4, %227
%229 = sub i64 %228, 2
%230 = trunc i64 %229 to i32
%231 = shl i32 1, %230
%232 = sub nsw i32 %231, 1
%233 = add nsw i32 %225, %232
%234 = sub nsw i32 0, %233
%235 = sub nsw i32 %234, 1
br label %237
236: ; preds = %199
br label %237
237: ; preds = %236, %219
%238 = phi i32 [ %235, %219 ], [ 0, %236 ]
%239 = sext i32 %238 to i64
%240 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %239, i64 0)
%241 = load i32, i32* @CHAR_BIT
%242 = sext i32 %241 to i64
%243 = mul i64 4, %242
%244 = sub i64 %243, 2
%245 = trunc i64 %244 to i32
%246 = shl i32 1, %245
%247 = load i32, i32* @CHAR_BIT
%248 = sext i32 %247 to i64
%249 = mul i64 4, %248
%250 = sub i64 %249, 2
%251 = trunc i64 %250 to i32
%252 = shl i32 1, %251
%253 = sub nsw i32 %252, 1
%254 = add nsw i32 %246, %253
%255 = sub nsw i32 0, %254
%256 = sub nsw i32 %255, 1
%257 = icmp slt i32 %256, 0
br i1 %257, label %258, label %275
258: ; preds = %237
%259 = load i32, i32* @CHAR_BIT
%260 = sext i32 %259 to i64
%261 = mul i64 4, %260
%262 = sub i64 %261, 2
%263 = trunc i64 %262 to i32
%264 = shl i32 1, %263
%265 = load i32, i32* @CHAR_BIT
%266 = sext i32 %265 to i64
%267 = mul i64 4, %266
%268 = sub i64 %267, 2
%269 = trunc i64 %268 to i32
%270 = shl i32 1, %269
%271 = sub nsw i32 %270, 1
%272 = add nsw i32 %264, %271
%273 = sub nsw i32 0, %272
%274 = sub nsw i32 %273, 1
br label %276
275: ; preds = %237
br label %276
276: ; preds = %275, %258
%277 = phi i32 [ %274, %258 ], [ 0, %275 ]
%278 = sext i32 %277 to i64
%279 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %278, i64 2)
%280 = load i32, i32* @CHAR_BIT
%281 = sext i32 %280 to i64
%282 = mul i64 4, %281
%283 = sub i64 %282, 2
%284 = trunc i64 %283 to i32
%285 = shl i32 1, %284
%286 = load i32, i32* @CHAR_BIT
%287 = sext i32 %286 to i64
%288 = mul i64 4, %287
%289 = sub i64 %288, 2
%290 = trunc i64 %289 to i32
%291 = shl i32 1, %290
%292 = sub nsw i32 %291, 1
%293 = add nsw i32 %285, %292
%294 = sub nsw i32 0, %293
%295 = sub nsw i32 %294, 1
%296 = icmp slt i32 %295, 0
br i1 %296, label %297, label %314
297: ; preds = %276
%298 = load i32, i32* @CHAR_BIT
%299 = sext i32 %298 to i64
%300 = mul i64 4, %299
%301 = sub i64 %300, 2
%302 = trunc i64 %301 to i32
%303 = shl i32 1, %302
%304 = load i32, i32* @CHAR_BIT
%305 = sext i32 %304 to i64
%306 = mul i64 4, %305
%307 = sub i64 %306, 2
%308 = trunc i64 %307 to i32
%309 = shl i32 1, %308
%310 = sub nsw i32 %309, 1
%311 = add nsw i32 %303, %310
%312 = sub nsw i32 0, %311
%313 = sub nsw i32 %312, 1
br label %315
314: ; preds = %276
br label %315
315: ; preds = %314, %297
%316 = phi i32 [ %313, %297 ], [ 0, %314 ]
%317 = sext i32 %316 to i64
%318 = load i32, i32* @CHAR_BIT
%319 = sext i32 %318 to i64
%320 = mul i64 4, %319
%321 = sub i64 %320, 2
%322 = trunc i64 %321 to i32
%323 = shl i32 1, %322
%324 = load i32, i32* @CHAR_BIT
%325 = sext i32 %324 to i64
%326 = mul i64 4, %325
%327 = sub i64 %326, 2
%328 = trunc i64 %327 to i32
%329 = shl i32 1, %328
%330 = sub i32 %329, 1
%331 = add i32 %323, %330
%332 = icmp ugt i32 %331, -1
br i1 %332, label %333, label %348
333: ; preds = %315
%334 = load i32, i32* @CHAR_BIT
%335 = sext i32 %334 to i64
%336 = mul i64 4, %335
%337 = sub i64 %336, 2
%338 = trunc i64 %337 to i32
%339 = shl i32 1, %338
%340 = load i32, i32* @CHAR_BIT
%341 = sext i32 %340 to i64
%342 = mul i64 4, %341
%343 = sub i64 %342, 2
%344 = trunc i64 %343 to i32
%345 = shl i32 1, %344
%346 = sub i32 %345, 1
%347 = add i32 %339, %346
br label %349
348: ; preds = %315
br label %349
349: ; preds = %348, %333
%350 = phi i32 [ %347, %333 ], [ -1, %348 ]
%351 = zext i32 %350 to i64
%352 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %317, i64 %351)
%353 = load i32, i32* @CHAR_BIT
%354 = sext i32 %353 to i64
%355 = mul i64 4, %354
%356 = sub i64 %355, 2
%357 = trunc i64 %356 to i32
%358 = shl i32 1, %357
%359 = load i32, i32* @CHAR_BIT
%360 = sext i32 %359 to i64
%361 = mul i64 4, %360
%362 = sub i64 %361, 2
%363 = trunc i64 %362 to i32
%364 = shl i32 1, %363
%365 = sub nsw i32 %364, 1
%366 = add nsw i32 %358, %365
%367 = sub nsw i32 0, %366
%368 = sub nsw i32 %367, 1
%369 = icmp slt i32 %368, 0
br i1 %369, label %370, label %387
370: ; preds = %349
%371 = load i32, i32* @CHAR_BIT
%372 = sext i32 %371 to i64
%373 = mul i64 4, %372
%374 = sub i64 %373, 2
%375 = trunc i64 %374 to i32
%376 = shl i32 1, %375
%377 = load i32, i32* @CHAR_BIT
%378 = sext i32 %377 to i64
%379 = mul i64 4, %378
%380 = sub i64 %379, 2
%381 = trunc i64 %380 to i32
%382 = shl i32 1, %381
%383 = sub nsw i32 %382, 1
%384 = add nsw i32 %376, %383
%385 = sub nsw i32 0, %384
%386 = sub nsw i32 %385, 1
br label %388
387: ; preds = %349
br label %388
388: ; preds = %387, %370
%389 = phi i32 [ %386, %370 ], [ 0, %387 ]
%390 = sext i32 %389 to i64
%391 = load i32, i32* @CHAR_BIT
%392 = sext i32 %391 to i64
%393 = mul i64 8, %392
%394 = sub i64 %393, 2
%395 = shl i64 1, %394
%396 = load i32, i32* @CHAR_BIT
%397 = sext i32 %396 to i64
%398 = mul i64 8, %397
%399 = sub i64 %398, 2
%400 = shl i64 1, %399
%401 = sub i64 %400, 1
%402 = add i64 %395, %401
%403 = icmp ugt i64 %402, -1
br i1 %403, label %404, label %417
404: ; preds = %388
%405 = load i32, i32* @CHAR_BIT
%406 = sext i32 %405 to i64
%407 = mul i64 8, %406
%408 = sub i64 %407, 2
%409 = shl i64 1, %408
%410 = load i32, i32* @CHAR_BIT
%411 = sext i32 %410 to i64
%412 = mul i64 8, %411
%413 = sub i64 %412, 2
%414 = shl i64 1, %413
%415 = sub i64 %414, 1
%416 = add i64 %409, %415
br label %418
417: ; preds = %388
br label %418
418: ; preds = %417, %404
%419 = phi i64 [ %416, %404 ], [ -1, %417 ]
%420 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %390, i64 %419)
%421 = load i32, i32* @CHAR_BIT
%422 = sext i32 %421 to i64
%423 = mul i64 4, %422
%424 = sub i64 %423, 2
%425 = trunc i64 %424 to i32
%426 = shl i32 1, %425
%427 = load i32, i32* @CHAR_BIT
%428 = sext i32 %427 to i64
%429 = mul i64 4, %428
%430 = sub i64 %429, 2
%431 = trunc i64 %430 to i32
%432 = shl i32 1, %431
%433 = sub nsw i32 %432, 1
%434 = add nsw i32 %426, %433
%435 = sub nsw i32 0, %434
%436 = sub nsw i32 %435, 1
%437 = icmp slt i32 %436, 0
br i1 %437, label %438, label %455
438: ; preds = %418
%439 = load i32, i32* @CHAR_BIT
%440 = sext i32 %439 to i64
%441 = mul i64 4, %440
%442 = sub i64 %441, 2
%443 = trunc i64 %442 to i32
%444 = shl i32 1, %443
%445 = load i32, i32* @CHAR_BIT
%446 = sext i32 %445 to i64
%447 = mul i64 4, %446
%448 = sub i64 %447, 2
%449 = trunc i64 %448 to i32
%450 = shl i32 1, %449
%451 = sub nsw i32 %450, 1
%452 = add nsw i32 %444, %451
%453 = sub nsw i32 0, %452
%454 = sub nsw i32 %453, 1
br label %456
455: ; preds = %418
br label %456
456: ; preds = %455, %438
%457 = phi i32 [ %454, %438 ], [ 0, %455 ]
%458 = sext i32 %457 to i64
%459 = load i32, i32* @CHAR_BIT
%460 = sext i32 %459 to i64
%461 = mul i64 4, %460
%462 = sub i64 %461, 2
%463 = trunc i64 %462 to i32
%464 = shl i32 1, %463
%465 = load i32, i32* @CHAR_BIT
%466 = sext i32 %465 to i64
%467 = mul i64 4, %466
%468 = sub i64 %467, 2
%469 = trunc i64 %468 to i32
%470 = shl i32 1, %469
%471 = sub i32 %470, 1
%472 = add i32 %464, %471
%473 = sub i32 0, %472
%474 = sub i32 %473, 1
%475 = icmp ult i32 %474, 0
br i1 %475, label %476, label %493
476: ; preds = %456
%477 = load i32, i32* @CHAR_BIT
%478 = sext i32 %477 to i64
%479 = mul i64 4, %478
%480 = sub i64 %479, 2
%481 = trunc i64 %480 to i32
%482 = shl i32 1, %481
%483 = load i32, i32* @CHAR_BIT
%484 = sext i32 %483 to i64
%485 = mul i64 4, %484
%486 = sub i64 %485, 2
%487 = trunc i64 %486 to i32
%488 = shl i32 1, %487
%489 = sub i32 %488, 1
%490 = add i32 %482, %489
%491 = sub i32 0, %490
%492 = sub i32 %491, 1
br label %494
493: ; preds = %456
br label %494
494: ; preds = %493, %476
%495 = phi i32 [ %492, %476 ], [ 0, %493 ]
%496 = zext i32 %495 to i64
%497 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %458, i64 %496)
%498 = load i32, i32* @CHAR_BIT
%499 = sext i32 %498 to i64
%500 = mul i64 4, %499
%501 = sub i64 %500, 2
%502 = trunc i64 %501 to i32
%503 = shl i32 1, %502
%504 = load i32, i32* @CHAR_BIT
%505 = sext i32 %504 to i64
%506 = mul i64 4, %505
%507 = sub i64 %506, 2
%508 = trunc i64 %507 to i32
%509 = shl i32 1, %508
%510 = sub nsw i32 %509, 1
%511 = add nsw i32 %503, %510
%512 = sub nsw i32 0, %511
%513 = sub nsw i32 %512, 1
%514 = icmp slt i32 %513, 0
br i1 %514, label %515, label %532
515: ; preds = %494
%516 = load i32, i32* @CHAR_BIT
%517 = sext i32 %516 to i64
%518 = mul i64 4, %517
%519 = sub i64 %518, 2
%520 = trunc i64 %519 to i32
%521 = shl i32 1, %520
%522 = load i32, i32* @CHAR_BIT
%523 = sext i32 %522 to i64
%524 = mul i64 4, %523
%525 = sub i64 %524, 2
%526 = trunc i64 %525 to i32
%527 = shl i32 1, %526
%528 = sub nsw i32 %527, 1
%529 = add nsw i32 %521, %528
%530 = sub nsw i32 0, %529
%531 = sub nsw i32 %530, 1
br label %533
532: ; preds = %494
br label %533
533: ; preds = %532, %515
%534 = phi i32 [ %531, %515 ], [ 0, %532 ]
%535 = sext i32 %534 to i64
%536 = load i32, i32* @CHAR_BIT
%537 = sext i32 %536 to i64
%538 = mul i64 8, %537
%539 = sub i64 %538, 2
%540 = shl i64 1, %539
%541 = load i32, i32* @CHAR_BIT
%542 = sext i32 %541 to i64
%543 = mul i64 8, %542
%544 = sub i64 %543, 2
%545 = shl i64 1, %544
%546 = sub i64 %545, 1
%547 = add i64 %540, %546
%548 = sub i64 0, %547
%549 = sub i64 %548, 1
%550 = icmp ult i64 %549, 0
br i1 %550, label %551, label %566
551: ; preds = %533
%552 = load i32, i32* @CHAR_BIT
%553 = sext i32 %552 to i64
%554 = mul i64 8, %553
%555 = sub i64 %554, 2
%556 = shl i64 1, %555
%557 = load i32, i32* @CHAR_BIT
%558 = sext i32 %557 to i64
%559 = mul i64 8, %558
%560 = sub i64 %559, 2
%561 = shl i64 1, %560
%562 = sub i64 %561, 1
%563 = add i64 %556, %562
%564 = sub i64 0, %563
%565 = sub i64 %564, 1
br label %567
566: ; preds = %533
br label %567
567: ; preds = %566, %551
%568 = phi i64 [ %565, %551 ], [ 0, %566 ]
%569 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %535, i64 %568)
%570 = load i32, i32* @CHAR_BIT
%571 = sext i32 %570 to i64
%572 = mul i64 8, %571
%573 = sub i64 %572, 2
%574 = shl i64 1, %573
%575 = load i32, i32* @CHAR_BIT
%576 = sext i32 %575 to i64
%577 = mul i64 8, %576
%578 = sub i64 %577, 2
%579 = shl i64 1, %578
%580 = sub nsw i64 %579, 1
%581 = add nsw i64 %574, %580
%582 = sub nsw i64 0, %581
%583 = sub nsw i64 %582, 1
%584 = icmp slt i64 %583, 0
br i1 %584, label %585, label %600
585: ; preds = %567
%586 = load i32, i32* @CHAR_BIT
%587 = sext i32 %586 to i64
%588 = mul i64 8, %587
%589 = sub i64 %588, 2
%590 = shl i64 1, %589
%591 = load i32, i32* @CHAR_BIT
%592 = sext i32 %591 to i64
%593 = mul i64 8, %592
%594 = sub i64 %593, 2
%595 = shl i64 1, %594
%596 = sub nsw i64 %595, 1
%597 = add nsw i64 %590, %596
%598 = sub nsw i64 0, %597
%599 = sub nsw i64 %598, 1
br label %601
600: ; preds = %567
br label %601
601: ; preds = %600, %585
%602 = phi i64 [ %599, %585 ], [ 0, %600 ]
%603 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %602, i64 0)
%604 = load i32, i32* @CHAR_BIT
%605 = sext i32 %604 to i64
%606 = mul i64 8, %605
%607 = sub i64 %606, 2
%608 = shl i64 1, %607
%609 = load i32, i32* @CHAR_BIT
%610 = sext i32 %609 to i64
%611 = mul i64 8, %610
%612 = sub i64 %611, 2
%613 = shl i64 1, %612
%614 = sub nsw i64 %613, 1
%615 = add nsw i64 %608, %614
%616 = sub nsw i64 0, %615
%617 = sub nsw i64 %616, 1
%618 = icmp slt i64 %617, 0
br i1 %618, label %619, label %634
619: ; preds = %601
%620 = load i32, i32* @CHAR_BIT
%621 = sext i32 %620 to i64
%622 = mul i64 8, %621
%623 = sub i64 %622, 2
%624 = shl i64 1, %623
%625 = load i32, i32* @CHAR_BIT
%626 = sext i32 %625 to i64
%627 = mul i64 8, %626
%628 = sub i64 %627, 2
%629 = shl i64 1, %628
%630 = sub nsw i64 %629, 1
%631 = add nsw i64 %624, %630
%632 = sub nsw i64 0, %631
%633 = sub nsw i64 %632, 1
br label %635
634: ; preds = %601
br label %635
635: ; preds = %634, %619
%636 = phi i64 [ %633, %619 ], [ 0, %634 ]
%637 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %636, i64 2)
%638 = load i32, i32* @CHAR_BIT
%639 = sext i32 %638 to i64
%640 = mul i64 8, %639
%641 = sub i64 %640, 2
%642 = shl i64 1, %641
%643 = load i32, i32* @CHAR_BIT
%644 = sext i32 %643 to i64
%645 = mul i64 8, %644
%646 = sub i64 %645, 2
%647 = shl i64 1, %646
%648 = sub nsw i64 %647, 1
%649 = add nsw i64 %642, %648
%650 = sub nsw i64 0, %649
%651 = sub nsw i64 %650, 1
%652 = icmp slt i64 %651, 0
br i1 %652, label %653, label %668
653: ; preds = %635
%654 = load i32, i32* @CHAR_BIT
%655 = sext i32 %654 to i64
%656 = mul i64 8, %655
%657 = sub i64 %656, 2
%658 = shl i64 1, %657
%659 = load i32, i32* @CHAR_BIT
%660 = sext i32 %659 to i64
%661 = mul i64 8, %660
%662 = sub i64 %661, 2
%663 = shl i64 1, %662
%664 = sub nsw i64 %663, 1
%665 = add nsw i64 %658, %664
%666 = sub nsw i64 0, %665
%667 = sub nsw i64 %666, 1
br label %669
668: ; preds = %635
br label %669
669: ; preds = %668, %653
%670 = phi i64 [ %667, %653 ], [ 0, %668 ]
%671 = load i32, i32* @CHAR_BIT
%672 = sext i32 %671 to i64
%673 = mul i64 4, %672
%674 = sub i64 %673, 2
%675 = trunc i64 %674 to i32
%676 = shl i32 1, %675
%677 = load i32, i32* @CHAR_BIT
%678 = sext i32 %677 to i64
%679 = mul i64 4, %678
%680 = sub i64 %679, 2
%681 = trunc i64 %680 to i32
%682 = shl i32 1, %681
%683 = sub i32 %682, 1
%684 = add i32 %676, %683
%685 = icmp ugt i32 %684, -1
br i1 %685, label %686, label %701
686: ; preds = %669
%687 = load i32, i32* @CHAR_BIT
%688 = sext i32 %687 to i64
%689 = mul i64 4, %688
%690 = sub i64 %689, 2
%691 = trunc i64 %690 to i32
%692 = shl i32 1, %691
%693 = load i32, i32* @CHAR_BIT
%694 = sext i32 %693 to i64
%695 = mul i64 4, %694
%696 = sub i64 %695, 2
%697 = trunc i64 %696 to i32
%698 = shl i32 1, %697
%699 = sub i32 %698, 1
%700 = add i32 %692, %699
br label %702
701: ; preds = %669
br label %702
702: ; preds = %701, %686
%703 = phi i32 [ %700, %686 ], [ -1, %701 ]
%704 = zext i32 %703 to i64
%705 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %670, i64 %704)
%706 = load i32, i32* @CHAR_BIT
%707 = sext i32 %706 to i64
%708 = mul i64 8, %707
%709 = sub i64 %708, 2
%710 = shl i64 1, %709
%711 = load i32, i32* @CHAR_BIT
%712 = sext i32 %711 to i64
%713 = mul i64 8, %712
%714 = sub i64 %713, 2
%715 = shl i64 1, %714
%716 = sub nsw i64 %715, 1
%717 = add nsw i64 %710, %716
%718 = sub nsw i64 0, %717
%719 = sub nsw i64 %718, 1
%720 = icmp slt i64 %719, 0
br i1 %720, label %721, label %736
721: ; preds = %702
%722 = load i32, i32* @CHAR_BIT
%723 = sext i32 %722 to i64
%724 = mul i64 8, %723
%725 = sub i64 %724, 2
%726 = shl i64 1, %725
%727 = load i32, i32* @CHAR_BIT
%728 = sext i32 %727 to i64
%729 = mul i64 8, %728
%730 = sub i64 %729, 2
%731 = shl i64 1, %730
%732 = sub nsw i64 %731, 1
%733 = add nsw i64 %726, %732
%734 = sub nsw i64 0, %733
%735 = sub nsw i64 %734, 1
br label %737
736: ; preds = %702
br label %737
737: ; preds = %736, %721
%738 = phi i64 [ %735, %721 ], [ 0, %736 ]
%739 = load i32, i32* @CHAR_BIT
%740 = sext i32 %739 to i64
%741 = mul i64 8, %740
%742 = sub i64 %741, 2
%743 = shl i64 1, %742
%744 = load i32, i32* @CHAR_BIT
%745 = sext i32 %744 to i64
%746 = mul i64 8, %745
%747 = sub i64 %746, 2
%748 = shl i64 1, %747
%749 = sub i64 %748, 1
%750 = add i64 %743, %749
%751 = icmp ugt i64 %750, -1
br i1 %751, label %752, label %765
752: ; preds = %737
%753 = load i32, i32* @CHAR_BIT
%754 = sext i32 %753 to i64
%755 = mul i64 8, %754
%756 = sub i64 %755, 2
%757 = shl i64 1, %756
%758 = load i32, i32* @CHAR_BIT
%759 = sext i32 %758 to i64
%760 = mul i64 8, %759
%761 = sub i64 %760, 2
%762 = shl i64 1, %761
%763 = sub i64 %762, 1
%764 = add i64 %757, %763
br label %766
765: ; preds = %737
br label %766
766: ; preds = %765, %752
%767 = phi i64 [ %764, %752 ], [ -1, %765 ]
%768 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %738, i64 %767)
%769 = load i32, i32* @CHAR_BIT
%770 = sext i32 %769 to i64
%771 = mul i64 8, %770
%772 = sub i64 %771, 2
%773 = shl i64 1, %772
%774 = load i32, i32* @CHAR_BIT
%775 = sext i32 %774 to i64
%776 = mul i64 8, %775
%777 = sub i64 %776, 2
%778 = shl i64 1, %777
%779 = sub nsw i64 %778, 1
%780 = add nsw i64 %773, %779
%781 = sub nsw i64 0, %780
%782 = sub nsw i64 %781, 1
%783 = icmp slt i64 %782, 0
br i1 %783, label %784, label %799
784: ; preds = %766
%785 = load i32, i32* @CHAR_BIT
%786 = sext i32 %785 to i64
%787 = mul i64 8, %786
%788 = sub i64 %787, 2
%789 = shl i64 1, %788
%790 = load i32, i32* @CHAR_BIT
%791 = sext i32 %790 to i64
%792 = mul i64 8, %791
%793 = sub i64 %792, 2
%794 = shl i64 1, %793
%795 = sub nsw i64 %794, 1
%796 = add nsw i64 %789, %795
%797 = sub nsw i64 0, %796
%798 = sub nsw i64 %797, 1
br label %800
799: ; preds = %766
br label %800
800: ; preds = %799, %784
%801 = phi i64 [ %798, %784 ], [ 0, %799 ]
%802 = load i32, i32* @CHAR_BIT
%803 = sext i32 %802 to i64
%804 = mul i64 4, %803
%805 = sub i64 %804, 2
%806 = trunc i64 %805 to i32
%807 = shl i32 1, %806
%808 = load i32, i32* @CHAR_BIT
%809 = sext i32 %808 to i64
%810 = mul i64 4, %809
%811 = sub i64 %810, 2
%812 = trunc i64 %811 to i32
%813 = shl i32 1, %812
%814 = sub i32 %813, 1
%815 = add i32 %807, %814
%816 = sub i32 0, %815
%817 = sub i32 %816, 1
%818 = icmp ult i32 %817, 0
br i1 %818, label %819, label %836
819: ; preds = %800
%820 = load i32, i32* @CHAR_BIT
%821 = sext i32 %820 to i64
%822 = mul i64 4, %821
%823 = sub i64 %822, 2
%824 = trunc i64 %823 to i32
%825 = shl i32 1, %824
%826 = load i32, i32* @CHAR_BIT
%827 = sext i32 %826 to i64
%828 = mul i64 4, %827
%829 = sub i64 %828, 2
%830 = trunc i64 %829 to i32
%831 = shl i32 1, %830
%832 = sub i32 %831, 1
%833 = add i32 %825, %832
%834 = sub i32 0, %833
%835 = sub i32 %834, 1
br label %837
836: ; preds = %800
br label %837
837: ; preds = %836, %819
%838 = phi i32 [ %835, %819 ], [ 0, %836 ]
%839 = zext i32 %838 to i64
%840 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %801, i64 %839)
%841 = load i32, i32* @CHAR_BIT
%842 = sext i32 %841 to i64
%843 = mul i64 8, %842
%844 = sub i64 %843, 2
%845 = shl i64 1, %844
%846 = load i32, i32* @CHAR_BIT
%847 = sext i32 %846 to i64
%848 = mul i64 8, %847
%849 = sub i64 %848, 2
%850 = shl i64 1, %849
%851 = sub nsw i64 %850, 1
%852 = add nsw i64 %845, %851
%853 = sub nsw i64 0, %852
%854 = sub nsw i64 %853, 1
%855 = icmp slt i64 %854, 0
br i1 %855, label %856, label %871
856: ; preds = %837
%857 = load i32, i32* @CHAR_BIT
%858 = sext i32 %857 to i64
%859 = mul i64 8, %858
%860 = sub i64 %859, 2
%861 = shl i64 1, %860
%862 = load i32, i32* @CHAR_BIT
%863 = sext i32 %862 to i64
%864 = mul i64 8, %863
%865 = sub i64 %864, 2
%866 = shl i64 1, %865
%867 = sub nsw i64 %866, 1
%868 = add nsw i64 %861, %867
%869 = sub nsw i64 0, %868
%870 = sub nsw i64 %869, 1
br label %872
871: ; preds = %837
br label %872
872: ; preds = %871, %856
%873 = phi i64 [ %870, %856 ], [ 0, %871 ]
%874 = load i32, i32* @CHAR_BIT
%875 = sext i32 %874 to i64
%876 = mul i64 8, %875
%877 = sub i64 %876, 2
%878 = shl i64 1, %877
%879 = load i32, i32* @CHAR_BIT
%880 = sext i32 %879 to i64
%881 = mul i64 8, %880
%882 = sub i64 %881, 2
%883 = shl i64 1, %882
%884 = sub i64 %883, 1
%885 = add i64 %878, %884
%886 = sub i64 0, %885
%887 = sub i64 %886, 1
%888 = icmp ult i64 %887, 0
br i1 %888, label %889, label %904
889: ; preds = %872
%890 = load i32, i32* @CHAR_BIT
%891 = sext i32 %890 to i64
%892 = mul i64 8, %891
%893 = sub i64 %892, 2
%894 = shl i64 1, %893
%895 = load i32, i32* @CHAR_BIT
%896 = sext i32 %895 to i64
%897 = mul i64 8, %896
%898 = sub i64 %897, 2
%899 = shl i64 1, %898
%900 = sub i64 %899, 1
%901 = add i64 %894, %900
%902 = sub i64 0, %901
%903 = sub i64 %902, 1
br label %905
904: ; preds = %872
br label %905
905: ; preds = %904, %889
%906 = phi i64 [ %903, %889 ], [ 0, %904 ]
%907 = call i32 @_test_MIN_smallerlong_biggerulong(i64 %873, i64 %906)
ret i32 0
}

LLVM IR (-O2):
@CHAR_BIT = global i32 0
define i32 @_test_various_MIN_smallerlong_biggerulong() {
%1 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 -1, i64 0)
%2 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 -1, i64 1)
%3 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 -1, i64 4294967295)
%4 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 -1, i64 -1)
%5 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 0, i64 1)
%6 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 0, i64 2)
%7 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 0, i64 4294967295)
%8 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 0, i64 -1)
%9 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 1, i64 2)
%10 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 1, i64 3)
%11 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 1, i64 4294967295)
%12 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 1, i64 -1)
%13 = load i32, i32* @CHAR_BIT
%14 = shl i32 %13, 2
%15 = add i32 %14, -2
%16 = shl i32 -2, %15
%17 = icmp slt i32 %16, 0
%18 = select i1 %17, i32 %16, i32 0
%19 = sext i32 %18 to i64
%20 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %19, i64 0)
%21 = load i32, i32* @CHAR_BIT
%22 = shl i32 %21, 2
%23 = add i32 %22, -2
%24 = shl i32 -2, %23
%25 = icmp slt i32 %24, 0
%26 = select i1 %25, i32 %24, i32 0
%27 = sext i32 %26 to i64
%28 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %27, i64 2)
%29 = load i32, i32* @CHAR_BIT
%30 = shl i32 %29, 2
%31 = add i32 %30, -2
%32 = shl i32 -2, %31
%33 = icmp slt i32 %32, 0
%34 = select i1 %33, i32 %32, i32 0
%35 = sext i32 %34 to i64
%36 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %35, i64 4294967295)
%37 = load i32, i32* @CHAR_BIT
%38 = shl i32 %37, 2
%39 = add i32 %38, -2
%40 = shl i32 -2, %39
%41 = icmp slt i32 %40, 0
%42 = select i1 %41, i32 %40, i32 0
%43 = sext i32 %42 to i64
%44 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %43, i64 -1)
%45 = load i32, i32* @CHAR_BIT
%46 = shl i32 %45, 2
%47 = add i32 %46, -2
%48 = shl i32 -2, %47
%49 = icmp slt i32 %48, 0
%50 = select i1 %49, i32 %48, i32 0
%51 = sext i32 %50 to i64
%52 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %51, i64 0)
%53 = load i32, i32* @CHAR_BIT
%54 = shl i32 %53, 2
%55 = add i32 %54, -2
%56 = shl i32 -2, %55
%57 = icmp slt i32 %56, 0
%58 = select i1 %57, i32 %56, i32 0
%59 = sext i32 %58 to i64
%60 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %59, i64 0)
%61 = load i32, i32* @CHAR_BIT
%62 = sext i32 %61 to i64
%63 = shl nsw i64 %62, 3
%64 = add nsw i64 %63, -2
%65 = shl i64 -2, %64
%66 = icmp slt i64 %65, 0
%67 = select i1 %66, i64 %65, i64 0
%68 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %67, i64 0)
%69 = load i32, i32* @CHAR_BIT
%70 = sext i32 %69 to i64
%71 = shl nsw i64 %70, 3
%72 = add nsw i64 %71, -2
%73 = shl i64 -2, %72
%74 = icmp slt i64 %73, 0
%75 = select i1 %74, i64 %73, i64 0
%76 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %75, i64 2)
%77 = load i32, i32* @CHAR_BIT
%78 = sext i32 %77 to i64
%79 = shl nsw i64 %78, 3
%80 = add nsw i64 %79, -2
%81 = shl i64 -2, %80
%82 = icmp slt i64 %81, 0
%83 = select i1 %82, i64 %81, i64 0
%84 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %83, i64 4294967295)
%85 = load i32, i32* @CHAR_BIT
%86 = sext i32 %85 to i64
%87 = shl nsw i64 %86, 3
%88 = add nsw i64 %87, -2
%89 = shl i64 -2, %88
%90 = icmp slt i64 %89, 0
%91 = select i1 %90, i64 %89, i64 0
%92 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %91, i64 -1)
%93 = load i32, i32* @CHAR_BIT
%94 = sext i32 %93 to i64
%95 = shl nsw i64 %94, 3
%96 = add nsw i64 %95, -2
%97 = shl i64 -2, %96
%98 = icmp slt i64 %97, 0
%99 = select i1 %98, i64 %97, i64 0
%100 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %99, i64 0)
%101 = load i32, i32* @CHAR_BIT
%102 = sext i32 %101 to i64
%103 = shl nsw i64 %102, 3
%104 = add nsw i64 %103, -2
%105 = shl i64 -2, %104
%106 = icmp slt i64 %105, 0
%107 = select i1 %106, i64 %105, i64 0
%108 = tail call i32 @_test_MIN_smallerlong_biggerulong(i64 %107, i64 0)
ret i32 0
}