#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*/ assert(int);
int test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT() {
  assert(!(
      ((((unsigned long)0) - (((unsigned long)0) + 1)) < ((unsigned long)0)) &&
      (sizeof(unsigned long) <= sizeof(signed int))));
  assert(!((((((unsigned long)0) - ((unsigned long)0)) -
             ((((unsigned long)0) - ((unsigned long)0)) + 1)) <
            (((unsigned long)0) - ((unsigned long)0))) &&
           (sizeof((unsigned long)0) <= sizeof(signed int))));
  assert(!((((((unsigned long)-1) - ((unsigned long)-1)) -
             ((((unsigned long)-1) - ((unsigned long)-1)) + 1)) <
            (((unsigned long)-1) - ((unsigned long)-1))) &&
           (sizeof((unsigned long)-1) <= sizeof(signed int))));
  assert(!((((((unsigned long)1) - ((unsigned long)1)) -
             ((((unsigned long)1) - ((unsigned long)1)) + 1)) <
            (((unsigned long)1) - ((unsigned long)1))) &&
           (sizeof((unsigned long)1) <= sizeof(signed int))));
  assert(!((((((unsigned long)2) - ((unsigned long)2)) -
             ((((unsigned long)2) - ((unsigned long)2)) + 1)) <
            (((unsigned long)2) - ((unsigned long)2))) &&
           (sizeof((unsigned long)2) <= sizeof(signed int))));
  assert(!((
               (
                   (((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)))) >
                                      ((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))))) -
                    ((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)))) >
                                         ((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)))))) -
                   ((
                        (
                            (
                                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)))) >
                                                   ((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))))) -
                        ((
                            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)))) >
                                               ((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)))))) +
                    1)) < (((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)))) >
                                             ((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))))) -
                           ((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)))) >
                                                ((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))))))) &&
           (sizeof(
                (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)))) >
                                 ((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))))) <=
            sizeof(signed int))));
  assert(!((
               (
                   (
                       ((unsigned long)((((unsigned long)((-((unsigned long)(((unsigned long)(((unsigned long)1)
                                                                                              << ((
                                                                                                      sizeof(
                                                                                                          unsigned long) *
                                                                                                      CHAR_BIT) -
                                                                                                  2))) +
                                                                             ((
                                                                                 unsigned long)((
                                                                                                    (
                                                                                                        unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) -
                                                                                                                                              2))) -
                                                                                                1))))) -
                                                          1)) <
                                         ((unsigned long)0))
                                            ? (
                                                  (
                                                      unsigned long)((
                                                                         -((unsigned long)(((unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) - 2))) + ((
                                                                                                                                                                                   unsigned long)(((unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) - 2))) - 1))))) -
                                                                     1))
                                            : ((unsigned long)0))) -
                       ((
                           unsigned long)((
                                              (
                                                  (
                                                      unsigned long)((
                                                                         -(
                                                                             (
                                                                                 unsigned long)(((unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) - 2))) +
                                                                                                ((unsigned long)(((unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) -
                                                                                                                                                         2))) -
                                                                                                                 1))))) -
                                                                     1)) <
                                              ((unsigned long)0))
                                              ? (
                                                    (
                                                        unsigned long)((
                                                                           -((unsigned long)((
                                                                                                 (
                                                                                                     unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) - 2))) +
                                                                                             ((unsigned long)((
                                                                                                                  (
                                                                                                                      unsigned long)(((unsigned long)1)
                                                                                                                                     << ((sizeof(unsigned long) * CHAR_BIT) -
                                                                                                                                         2))) -
                                                                                                              1))))) -
                                                                       1))
                                              : ((unsigned long)0)))) -
                   ((
                        (
                            (
                                unsigned long)((
                                                   (
                                                       (
                                                           unsigned long)((
                                                                              -(
                                                                                  (
                                                                                      unsigned long)((
                                                                                                         (unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) -
                                                                                                                                                2))) +
                                                                                                     ((unsigned long)(((
                                                                                                                          unsigned long)(((unsigned long)1)
                                                                                                                                         << ((sizeof(
                                                                                                                                                  unsigned long) *
                                                                                                                                              CHAR_BIT) -
                                                                                                                                             2))) -
                                                                                                                      1))))) -
                                                                          1)) <
                                                   ((unsigned long)0))
                                                   ? (
                                                         (
                                                             unsigned long)((
                                                                                -((unsigned long)((
                                                                                                      (unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) -
                                                                                                                                             2))) +
                                                                                                  ((unsigned long)(((unsigned long)(((unsigned long)1)
                                                                                                                                    << ((sizeof(
                                                                                                                                             unsigned long) *
                                                                                                                                         CHAR_BIT) -
                                                                                                                                        2))) -
                                                                                                                   1))))) -
                                                                            1))
                                                   : ((unsigned long)0))) -
                        ((unsigned long)((
                                             ((unsigned long)((-((unsigned long)(((unsigned long)(((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)))) +
                    1)) <
               ((
                    (
                        unsigned long)((
                                           ((unsigned long)((-(
                                                                (unsigned long)((
                                                                                    (
                                                                                        unsigned long)(((unsigned long)1) << ((
                                                                                                                                  sizeof(unsigned long) * CHAR_BIT) -
                                                                                                                              2))) +
                                                                                ((
                                                                                    unsigned long)(((unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) -
                                                                                                                                           2))) -
                                                                                                   1))))) -
                                                            1)) <
                                           ((unsigned long)0))
                                           ? (
                                                 (
                                                     unsigned long)((
                                                                        -(
                                                                            (
                                                                                unsigned long)(((
                                                                                                   unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) - 2))) +
                                                                                               ((unsigned long)(((unsigned long)(((unsigned long)1) << ((sizeof(unsigned long) * CHAR_BIT) -
                                                                                                                                                        2))) -
                                                                                                                1))))) -
                                                                    1))
                                           : ((unsigned long)0))) -
                ((unsigned long)((
                                     (
                                         (unsigned long)((-((unsigned long)(((unsigned long)(((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))))) &&
           (sizeof((unsigned long)((
                                       (
                                           (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))) <=
            sizeof(signed int))));
  return 1;
}


x86 assembly (clang, -O0):
<test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    $0x1,%edi
call   1030 <assert@plt>
mov    0x2e8c(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2e72(%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    11dc <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0xcc>
mov    0x2e44(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2e2a(%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,-0x8(%rbp)
jmp    11ec <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0xdc>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x8(%rbp)
jmp    11ec <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0xdc>
mov    -0x8(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    0x2de5(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2dcb(%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    1283 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x173>
mov    0x2d9d(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2d83(%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,-0x18(%rbp)
jmp    1293 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x183>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    1293 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x183>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    0x2d37(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2d1d(%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    1331 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x221>
mov    0x2cef(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2cd5(%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,-0x28(%rbp)
jmp    1341 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x231>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1341 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x231>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    0x2c90(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2c76(%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    13d8 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x2c8>
mov    0x2c48(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2c2e(%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,-0x38(%rbp)
jmp    13e8 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x2d8>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    13e8 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x2d8>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rdx
sub    %rdx,%rcx
add    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x2bd7(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2bbd(%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    1491 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x381>
mov    0x2b8f(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2b75(%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,-0x48(%rbp)
jmp    14a1 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x391>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
jmp    14a1 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x391>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    0x2b30(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2b16(%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    1538 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x428>
mov    0x2ae8(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x2ace(%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,-0x58(%rbp)
jmp    1548 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x438>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x58(%rbp)
jmp    1548 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x438>
mov    -0x40(%rbp),%rcx
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rax
sub    %rax,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x59(%rbp)
jae    156f <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x45f>
xor    %eax,%eax
mov    %al,-0x59(%rbp)
jmp    156f <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x45f>
mov    -0x59(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x2a5b(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x68(%rbp)
mov    0x2a3d(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x68(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    1629 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x519>
mov    0x2a05(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x78(%rbp)
mov    0x29e7(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x78(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1634 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x524>
xor    %eax,%eax
mov    %rax,-0x70(%rbp)
jmp    1634 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x524>
mov    -0x70(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    0x299a(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x80(%rbp)
mov    0x297c(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x80(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    16f3 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x5e3>
mov    0x2944(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x98(%rbp)
mov    0x2923(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x90(%rbp)
jmp    1701 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x5f1>
xor    %eax,%eax
mov    %rax,-0x90(%rbp)
jmp    1701 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x5f1>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    0x28c0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xa0(%rbp)
mov    0x289f(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xa0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    17d3 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x6c3>
mov    0x2864(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xb8(%rbp)
mov    0x2843(%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
mov    %rax,-0xb0(%rbp)
jmp    17e1 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x6d1>
xor    %eax,%eax
mov    %rax,-0xb0(%rbp)
jmp    17e1 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x6d1>
mov    -0xb0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    0x27ea(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xc0(%rbp)
mov    0x27c9(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xc0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    18a9 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x799>
mov    0x278e(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xd8(%rbp)
mov    0x276d(%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
mov    %rax,-0xd0(%rbp)
jmp    18b7 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x7a7>
xor    %eax,%eax
mov    %rax,-0xd0(%rbp)
jmp    18b7 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x7a7>
mov    -0xa8(%rbp),%rax
mov    -0xc8(%rbp),%rcx
mov    -0xd0(%rbp),%rdx
sub    %rdx,%rcx
add    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    0x26fc(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xe0(%rbp)
mov    0x26db(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xe0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    1997 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x887>
mov    0x26a0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xf8(%rbp)
mov    0x267f(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0xf8(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0xf0(%rbp)
jmp    19a5 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x895>
xor    %eax,%eax
mov    %rax,-0xf0(%rbp)
jmp    19a5 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x895>
mov    -0xf0(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    0x2626(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x100(%rbp)
mov    0x2605(%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
cmp    $0x0,%rax
jae    1a6d <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x95d>
mov    0x25ca(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x118(%rbp)
mov    0x25a9(%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    1a7b <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x96b>
xor    %eax,%eax
mov    %rax,-0x110(%rbp)
jmp    1a7b <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x96b>
mov    -0xe8(%rbp),%rcx
mov    -0x108(%rbp),%rdx
mov    -0x110(%rbp),%rax
sub    %rax,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x119(%rbp)
jae    1ab1 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x9a1>
xor    %eax,%eax
mov    %al,-0x119(%rbp)
jmp    1ab1 <test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT+0x9a1>
mov    -0x119(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    $0x1,%eax
add    $0x120,%rsp
pop    %rbp
ret

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

LLVM IR (-O0):
@CHAR_BIT = global i32 0
define i32 @test_UNSIGNED_LONG_NOT_FITS_INTO_SIGNED_INT() {
%1 = call i32 @assert(i32 1)
%2 = call i32 @assert(i32 1)
%3 = call i32 @assert(i32 1)
%4 = call i32 @assert(i32 1)
%5 = call i32 @assert(i32 1)
%6 = load i32, i32* @CHAR_BIT
%7 = sext i32 %6 to i64
%8 = mul i64 8, %7
%9 = sub i64 %8, 2
%10 = shl i64 1, %9
%11 = load i32, i32* @CHAR_BIT
%12 = sext i32 %11 to i64
%13 = mul i64 8, %12
%14 = sub i64 %13, 2
%15 = shl i64 1, %14
%16 = sub i64 %15, 1
%17 = add i64 %10, %16
%18 = icmp ugt i64 %17, -1
br i1 %18, label %19, label %32
19: ; preds = %0
%20 = load i32, i32* @CHAR_BIT
%21 = sext i32 %20 to i64
%22 = mul i64 8, %21
%23 = sub i64 %22, 2
%24 = shl i64 1, %23
%25 = load i32, i32* @CHAR_BIT
%26 = sext i32 %25 to i64
%27 = mul i64 8, %26
%28 = sub i64 %27, 2
%29 = shl i64 1, %28
%30 = sub i64 %29, 1
%31 = add i64 %24, %30
br label %33
32: ; preds = %0
br label %33
33: ; preds = %32, %19
%34 = phi i64 [ %31, %19 ], [ -1, %32 ]
%35 = load i32, i32* @CHAR_BIT
%36 = sext i32 %35 to i64
%37 = mul i64 8, %36
%38 = sub i64 %37, 2
%39 = shl i64 1, %38
%40 = load i32, i32* @CHAR_BIT
%41 = sext i32 %40 to i64
%42 = mul i64 8, %41
%43 = sub i64 %42, 2
%44 = shl i64 1, %43
%45 = sub i64 %44, 1
%46 = add i64 %39, %45
%47 = icmp ugt i64 %46, -1
br i1 %47, label %48, label %61
48: ; preds = %33
%49 = load i32, i32* @CHAR_BIT
%50 = sext i32 %49 to i64
%51 = mul i64 8, %50
%52 = sub i64 %51, 2
%53 = shl i64 1, %52
%54 = load i32, i32* @CHAR_BIT
%55 = sext i32 %54 to i64
%56 = mul i64 8, %55
%57 = sub i64 %56, 2
%58 = shl i64 1, %57
%59 = sub i64 %58, 1
%60 = add i64 %53, %59
br label %62
61: ; preds = %33
br label %62
62: ; preds = %61, %48
%63 = phi i64 [ %60, %48 ], [ -1, %61 ]
%64 = sub i64 %34, %63
%65 = load i32, i32* @CHAR_BIT
%66 = sext i32 %65 to i64
%67 = mul i64 8, %66
%68 = sub i64 %67, 2
%69 = shl i64 1, %68
%70 = load i32, i32* @CHAR_BIT
%71 = sext i32 %70 to i64
%72 = mul i64 8, %71
%73 = sub i64 %72, 2
%74 = shl i64 1, %73
%75 = sub i64 %74, 1
%76 = add i64 %69, %75
%77 = icmp ugt i64 %76, -1
br i1 %77, label %78, label %91
78: ; preds = %62
%79 = load i32, i32* @CHAR_BIT
%80 = sext i32 %79 to i64
%81 = mul i64 8, %80
%82 = sub i64 %81, 2
%83 = shl i64 1, %82
%84 = load i32, i32* @CHAR_BIT
%85 = sext i32 %84 to i64
%86 = mul i64 8, %85
%87 = sub i64 %86, 2
%88 = shl i64 1, %87
%89 = sub i64 %88, 1
%90 = add i64 %83, %89
br label %92
91: ; preds = %62
br label %92
92: ; preds = %91, %78
%93 = phi i64 [ %90, %78 ], [ -1, %91 ]
%94 = load i32, i32* @CHAR_BIT
%95 = sext i32 %94 to i64
%96 = mul i64 8, %95
%97 = sub i64 %96, 2
%98 = shl i64 1, %97
%99 = load i32, i32* @CHAR_BIT
%100 = sext i32 %99 to i64
%101 = mul i64 8, %100
%102 = sub i64 %101, 2
%103 = shl i64 1, %102
%104 = sub i64 %103, 1
%105 = add i64 %98, %104
%106 = icmp ugt i64 %105, -1
br i1 %106, label %107, label %120
107: ; preds = %92
%108 = load i32, i32* @CHAR_BIT
%109 = sext i32 %108 to i64
%110 = mul i64 8, %109
%111 = sub i64 %110, 2
%112 = shl i64 1, %111
%113 = load i32, i32* @CHAR_BIT
%114 = sext i32 %113 to i64
%115 = mul i64 8, %114
%116 = sub i64 %115, 2
%117 = shl i64 1, %116
%118 = sub i64 %117, 1
%119 = add i64 %112, %118
br label %121
120: ; preds = %92
br label %121
121: ; preds = %120, %107
%122 = phi i64 [ %119, %107 ], [ -1, %120 ]
%123 = sub i64 %93, %122
%124 = add i64 %123, 1
%125 = sub i64 %64, %124
%126 = load i32, i32* @CHAR_BIT
%127 = sext i32 %126 to i64
%128 = mul i64 8, %127
%129 = sub i64 %128, 2
%130 = shl i64 1, %129
%131 = load i32, i32* @CHAR_BIT
%132 = sext i32 %131 to i64
%133 = mul i64 8, %132
%134 = sub i64 %133, 2
%135 = shl i64 1, %134
%136 = sub i64 %135, 1
%137 = add i64 %130, %136
%138 = icmp ugt i64 %137, -1
br i1 %138, label %139, label %152
139: ; preds = %121
%140 = load i32, i32* @CHAR_BIT
%141 = sext i32 %140 to i64
%142 = mul i64 8, %141
%143 = sub i64 %142, 2
%144 = shl i64 1, %143
%145 = load i32, i32* @CHAR_BIT
%146 = sext i32 %145 to i64
%147 = mul i64 8, %146
%148 = sub i64 %147, 2
%149 = shl i64 1, %148
%150 = sub i64 %149, 1
%151 = add i64 %144, %150
br label %153
152: ; preds = %121
br label %153
153: ; preds = %152, %139
%154 = phi i64 [ %151, %139 ], [ -1, %152 ]
%155 = load i32, i32* @CHAR_BIT
%156 = sext i32 %155 to i64
%157 = mul i64 8, %156
%158 = sub i64 %157, 2
%159 = shl i64 1, %158
%160 = load i32, i32* @CHAR_BIT
%161 = sext i32 %160 to i64
%162 = mul i64 8, %161
%163 = sub i64 %162, 2
%164 = shl i64 1, %163
%165 = sub i64 %164, 1
%166 = add i64 %159, %165
%167 = icmp ugt i64 %166, -1
br i1 %167, label %168, label %181
168: ; preds = %153
%169 = load i32, i32* @CHAR_BIT
%170 = sext i32 %169 to i64
%171 = mul i64 8, %170
%172 = sub i64 %171, 2
%173 = shl i64 1, %172
%174 = load i32, i32* @CHAR_BIT
%175 = sext i32 %174 to i64
%176 = mul i64 8, %175
%177 = sub i64 %176, 2
%178 = shl i64 1, %177
%179 = sub i64 %178, 1
%180 = add i64 %173, %179
br label %182
181: ; preds = %153
br label %182
182: ; preds = %181, %168
%183 = phi i64 [ %180, %168 ], [ -1, %181 ]
%184 = sub i64 %154, %183
%185 = icmp ult i64 %125, %184
br i1 %185, label %186, label %187
186: ; preds = %182
br label %187
187: ; preds = %186, %182
%188 = phi i1 [ false, %182 ], [ false, %186 ]
%189 = xor i1 %188, true
%190 = zext i1 %189 to i32
%191 = call i32 @assert(i32 %190)
%192 = load i32, i32* @CHAR_BIT
%193 = sext i32 %192 to i64
%194 = mul i64 8, %193
%195 = sub i64 %194, 2
%196 = shl i64 1, %195
%197 = load i32, i32* @CHAR_BIT
%198 = sext i32 %197 to i64
%199 = mul i64 8, %198
%200 = sub i64 %199, 2
%201 = shl i64 1, %200
%202 = sub i64 %201, 1
%203 = add i64 %196, %202
%204 = sub i64 0, %203
%205 = sub i64 %204, 1
%206 = icmp ult i64 %205, 0
br i1 %206, label %207, label %222
207: ; preds = %187
%208 = load i32, i32* @CHAR_BIT
%209 = sext i32 %208 to i64
%210 = mul i64 8, %209
%211 = sub i64 %210, 2
%212 = shl i64 1, %211
%213 = load i32, i32* @CHAR_BIT
%214 = sext i32 %213 to i64
%215 = mul i64 8, %214
%216 = sub i64 %215, 2
%217 = shl i64 1, %216
%218 = sub i64 %217, 1
%219 = add i64 %212, %218
%220 = sub i64 0, %219
%221 = sub i64 %220, 1
br label %223
222: ; preds = %187
br label %223
223: ; preds = %222, %207
%224 = phi i64 [ %221, %207 ], [ 0, %222 ]
%225 = load i32, i32* @CHAR_BIT
%226 = sext i32 %225 to i64
%227 = mul i64 8, %226
%228 = sub i64 %227, 2
%229 = shl i64 1, %228
%230 = load i32, i32* @CHAR_BIT
%231 = sext i32 %230 to i64
%232 = mul i64 8, %231
%233 = sub i64 %232, 2
%234 = shl i64 1, %233
%235 = sub i64 %234, 1
%236 = add i64 %229, %235
%237 = sub i64 0, %236
%238 = sub i64 %237, 1
%239 = icmp ult i64 %238, 0
br i1 %239, label %240, label %255
240: ; preds = %223
%241 = load i32, i32* @CHAR_BIT
%242 = sext i32 %241 to i64
%243 = mul i64 8, %242
%244 = sub i64 %243, 2
%245 = shl i64 1, %244
%246 = load i32, i32* @CHAR_BIT
%247 = sext i32 %246 to i64
%248 = mul i64 8, %247
%249 = sub i64 %248, 2
%250 = shl i64 1, %249
%251 = sub i64 %250, 1
%252 = add i64 %245, %251
%253 = sub i64 0, %252
%254 = sub i64 %253, 1
br label %256
255: ; preds = %223
br label %256
256: ; preds = %255, %240
%257 = phi i64 [ %254, %240 ], [ 0, %255 ]
%258 = sub i64 %224, %257
%259 = load i32, i32* @CHAR_BIT
%260 = sext i32 %259 to i64
%261 = mul i64 8, %260
%262 = sub i64 %261, 2
%263 = shl i64 1, %262
%264 = load i32, i32* @CHAR_BIT
%265 = sext i32 %264 to i64
%266 = mul i64 8, %265
%267 = sub i64 %266, 2
%268 = shl i64 1, %267
%269 = sub i64 %268, 1
%270 = add i64 %263, %269
%271 = sub i64 0, %270
%272 = sub i64 %271, 1
%273 = icmp ult i64 %272, 0
br i1 %273, label %274, label %289
274: ; preds = %256
%275 = load i32, i32* @CHAR_BIT
%276 = sext i32 %275 to i64
%277 = mul i64 8, %276
%278 = sub i64 %277, 2
%279 = shl i64 1, %278
%280 = load i32, i32* @CHAR_BIT
%281 = sext i32 %280 to i64
%282 = mul i64 8, %281
%283 = sub i64 %282, 2
%284 = shl i64 1, %283
%285 = sub i64 %284, 1
%286 = add i64 %279, %285
%287 = sub i64 0, %286
%288 = sub i64 %287, 1
br label %290
289: ; preds = %256
br label %290
290: ; preds = %289, %274
%291 = phi i64 [ %288, %274 ], [ 0, %289 ]
%292 = load i32, i32* @CHAR_BIT
%293 = sext i32 %292 to i64
%294 = mul i64 8, %293
%295 = sub i64 %294, 2
%296 = shl i64 1, %295
%297 = load i32, i32* @CHAR_BIT
%298 = sext i32 %297 to i64
%299 = mul i64 8, %298
%300 = sub i64 %299, 2
%301 = shl i64 1, %300
%302 = sub i64 %301, 1
%303 = add i64 %296, %302
%304 = sub i64 0, %303
%305 = sub i64 %304, 1
%306 = icmp ult i64 %305, 0
br i1 %306, label %307, label %322
307: ; preds = %290
%308 = load i32, i32* @CHAR_BIT
%309 = sext i32 %308 to i64
%310 = mul i64 8, %309
%311 = sub i64 %310, 2
%312 = shl i64 1, %311
%313 = load i32, i32* @CHAR_BIT
%314 = sext i32 %313 to i64
%315 = mul i64 8, %314
%316 = sub i64 %315, 2
%317 = shl i64 1, %316
%318 = sub i64 %317, 1
%319 = add i64 %312, %318
%320 = sub i64 0, %319
%321 = sub i64 %320, 1
br label %323
322: ; preds = %290
br label %323
323: ; preds = %322, %307
%324 = phi i64 [ %321, %307 ], [ 0, %322 ]
%325 = sub i64 %291, %324
%326 = add i64 %325, 1
%327 = sub i64 %258, %326
%328 = load i32, i32* @CHAR_BIT
%329 = sext i32 %328 to i64
%330 = mul i64 8, %329
%331 = sub i64 %330, 2
%332 = shl i64 1, %331
%333 = load i32, i32* @CHAR_BIT
%334 = sext i32 %333 to i64
%335 = mul i64 8, %334
%336 = sub i64 %335, 2
%337 = shl i64 1, %336
%338 = sub i64 %337, 1
%339 = add i64 %332, %338
%340 = sub i64 0, %339
%341 = sub i64 %340, 1
%342 = icmp ult i64 %341, 0
br i1 %342, label %343, label %358
343: ; preds = %323
%344 = load i32, i32* @CHAR_BIT
%345 = sext i32 %344 to i64
%346 = mul i64 8, %345
%347 = sub i64 %346, 2
%348 = shl i64 1, %347
%349 = load i32, i32* @CHAR_BIT
%350 = sext i32 %349 to i64
%351 = mul i64 8, %350
%352 = sub i64 %351, 2
%353 = shl i64 1, %352
%354 = sub i64 %353, 1
%355 = add i64 %348, %354
%356 = sub i64 0, %355
%357 = sub i64 %356, 1
br label %359
358: ; preds = %323
br label %359
359: ; preds = %358, %343
%360 = phi i64 [ %357, %343 ], [ 0, %358 ]
%361 = load i32, i32* @CHAR_BIT
%362 = sext i32 %361 to i64
%363 = mul i64 8, %362
%364 = sub i64 %363, 2
%365 = shl i64 1, %364
%366 = load i32, i32* @CHAR_BIT
%367 = sext i32 %366 to i64
%368 = mul i64 8, %367
%369 = sub i64 %368, 2
%370 = shl i64 1, %369
%371 = sub i64 %370, 1
%372 = add i64 %365, %371
%373 = sub i64 0, %372
%374 = sub i64 %373, 1
%375 = icmp ult i64 %374, 0
br i1 %375, label %376, label %391
376: ; preds = %359
%377 = load i32, i32* @CHAR_BIT
%378 = sext i32 %377 to i64
%379 = mul i64 8, %378
%380 = sub i64 %379, 2
%381 = shl i64 1, %380
%382 = load i32, i32* @CHAR_BIT
%383 = sext i32 %382 to i64
%384 = mul i64 8, %383
%385 = sub i64 %384, 2
%386 = shl i64 1, %385
%387 = sub i64 %386, 1
%388 = add i64 %381, %387
%389 = sub i64 0, %388
%390 = sub i64 %389, 1
br label %392
391: ; preds = %359
br label %392
392: ; preds = %391, %376
%393 = phi i64 [ %390, %376 ], [ 0, %391 ]
%394 = sub i64 %360, %393
%395 = icmp ult i64 %327, %394
br i1 %395, label %396, label %397
396: ; preds = %392
br label %397
397: ; preds = %396, %392
%398 = phi i1 [ false, %392 ], [ false, %396 ]
%399 = xor i1 %398, true
%400 = zext i1 %399 to i32
%401 = call i32 @assert(i32 %400)
ret i32 1
}

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