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


x86 assembly (clang, -O0):
<test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2e71(%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    11d4 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0xc4>
mov    0x2e48(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2e2d(%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    11e1 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0xd1>
mov    $0xffffffff,%eax
mov    %eax,-0x4(%rbp)
jmp    11e1 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0xd1>
mov    -0x4(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    0x2df2(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2dd7(%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    126e <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x15e>
mov    0x2dae(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2d93(%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,-0xc(%rbp)
jmp    127b <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x16b>
mov    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    127b <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x16b>
mov    -0x8(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x10(%rbp)
mov    0x2d53(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2d38(%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    130d <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x1fd>
mov    0x2d0f(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2cf4(%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    131a <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x20a>
mov    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    131a <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x20a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    0x2cb9(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2c9e(%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    13a7 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x297>
mov    0x2c75(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2c5a(%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,-0x1c(%rbp)
jmp    13b4 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x2a4>
mov    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    13b4 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x2a4>
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
sub    %edx,%ecx
add    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    0x2c12(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2bf7(%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    144e <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x33e>
mov    0x2bce(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2bb3(%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    145b <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x34b>
mov    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    145b <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x34b>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    0x2b78(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2b5d(%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    14e8 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x3d8>
mov    0x2b34(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    0x2b19(%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,-0x2c(%rbp)
jmp    14f5 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x3e5>
mov    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    14f5 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x3e5>
mov    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%eax
sub    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x2d(%rbp)
jae    1517 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x407>
mov    $0x1,%al
mov    %al,-0x2d(%rbp)
jmp    1517 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x407>
mov    -0x2d(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x2ab3(%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    0x2a95(%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
jae    15c7 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x4b7>
mov    0x2a62(%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    0x2a44(%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    15d1 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x4c1>
xor    %eax,%eax
mov    %eax,-0x38(%rbp)
jmp    15d1 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x4c1>
mov    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    0x2a02(%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    0x29e4(%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
jae    1678 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x568>
mov    0x29b1(%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    0x2993(%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
mov    %eax,-0x48(%rbp)
jmp    1682 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x572>
xor    %eax,%eax
mov    %eax,-0x48(%rbp)
jmp    1682 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x572>
mov    -0x44(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    0x294c(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x50(%rbp)
mov    0x292e(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x50(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jae    172e <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x61e>
mov    0x28fb(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x5c(%rbp)
mov    0x28dd(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1738 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x628>
xor    %eax,%eax
mov    %eax,-0x58(%rbp)
jmp    1738 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x628>
mov    -0x58(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    0x289b(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x60(%rbp)
mov    0x287d(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x60(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jae    17df <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x6cf>
mov    0x284a(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x6c(%rbp)
mov    0x282c(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    17e9 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x6d9>
xor    %eax,%eax
mov    %eax,-0x68(%rbp)
jmp    17e9 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x6d9>
mov    -0x54(%rbp),%eax
mov    -0x64(%rbp),%ecx
mov    -0x68(%rbp),%edx
sub    %edx,%ecx
add    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    0x27dd(%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    0x27bf(%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
cmp    $0x0,%eax
jae    189d <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x78d>
mov    0x278c(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x7c(%rbp)
mov    0x276e(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    18a7 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x797>
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    18a7 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x797>
mov    -0x78(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    0x2729(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x80(%rbp)
mov    0x270b(%rip),%rax
movslq (%rax),%rax
shl    $0x2,%rax
sub    $0x2,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x80(%rbp),%ecx
sub    $0x1,%eax
add    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
sub    $0x1,%eax
cmp    $0x0,%eax
jae    195a <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x84a>
mov    0x26d8(%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    0x26b7(%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    1967 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x857>
xor    %eax,%eax
mov    %eax,-0x88(%rbp)
jmp    1967 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x857>
mov    -0x74(%rbp),%ecx
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%eax
sub    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x8d(%rbp)
jae    1995 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x885>
mov    $0x1,%al
mov    %al,-0x8d(%rbp)
jmp    1995 <test_UNSIGNED_INT_NOT_FITS_INTO_SIGNED_INT+0x885>
mov    -0x8d(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    $0x1,%eax
add    $0x90,%rsp
pop    %rbp
ret

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

LLVM IR (-O2):
@CHAR_BIT = global i32 0
define i32 @test_UNSIGNED_INT_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
}