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


x86 assembly (clang, -O0):
<test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x240,%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    0x3e8c(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3e72(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xcc>
mov    0x3e44(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3e2a(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xdc>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x8(%rbp)
jmp    11ec <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xdc>
mov    -0x8(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    0x3de5(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3dcb(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x173>
mov    0x3d9d(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3d83(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x183>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    1293 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x183>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    0x3d37(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3d1d(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x221>
mov    0x3cef(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3cd5(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x231>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1341 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x231>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    0x3c90(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3c76(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x2c8>
mov    0x3c48(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3c2e(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x2d8>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    13e8 <test_UNSIGNED_LONGLONG_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    0x3bd7(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3bbd(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x381>
mov    0x3b8f(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3b75(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x391>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
jmp    14a1 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x391>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    0x3b30(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3b16(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x428>
mov    0x3ae8(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3ace(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x438>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x58(%rbp)
jmp    1548 <test_UNSIGNED_LONGLONG_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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x45f>
xor    %eax,%eax
mov    %al,-0x59(%rbp)
jmp    156f <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x45f>
mov    -0x59(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x3a5b(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x68(%rbp)
mov    0x3a3d(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x519>
mov    0x3a05(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x78(%rbp)
mov    0x39e7(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x524>
xor    %eax,%eax
mov    %rax,-0x70(%rbp)
jmp    1634 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x524>
mov    -0x70(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    0x399a(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x80(%rbp)
mov    0x397c(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x5e3>
mov    0x3944(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x98(%rbp)
mov    0x3923(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x5f1>
xor    %eax,%eax
mov    %rax,-0x90(%rbp)
jmp    1701 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x5f1>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    0x38c0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xa0(%rbp)
mov    0x389f(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x6c3>
mov    0x3864(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xb8(%rbp)
mov    0x3843(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x6d1>
xor    %eax,%eax
mov    %rax,-0xb0(%rbp)
jmp    17e1 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x6d1>
mov    -0xb0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    0x37ea(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xc0(%rbp)
mov    0x37c9(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x799>
mov    0x378e(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xd8(%rbp)
mov    0x376d(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x7a7>
xor    %eax,%eax
mov    %rax,-0xd0(%rbp)
jmp    18b7 <test_UNSIGNED_LONGLONG_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    0x36fc(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xe0(%rbp)
mov    0x36db(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x887>
mov    0x36a0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0xf8(%rbp)
mov    0x367f(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x895>
xor    %eax,%eax
mov    %rax,-0xf0(%rbp)
jmp    19a5 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x895>
mov    -0xf0(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    0x3626(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x100(%rbp)
mov    0x3605(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x95d>
mov    0x35ca(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x118(%rbp)
mov    0x35a9(%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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x96b>
xor    %eax,%eax
mov    %rax,-0x110(%rbp)
jmp    1a7b <test_UNSIGNED_LONGLONG_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_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x9a1>
xor    %eax,%eax
mov    %al,-0x119(%rbp)
jmp    1ab1 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x9a1>
mov    -0x119(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x3516(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x34fc(%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    1b55 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xa45>
mov    0x34ce(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x34b4(%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,-0x128(%rbp)
jmp    1b68 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xa58>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x128(%rbp)
jmp    1b68 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xa58>
mov    -0x128(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    0x3463(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3449(%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    1c08 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xaf8>
mov    0x341b(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3401(%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,-0x138(%rbp)
jmp    1c1b <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xb0b>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x138(%rbp)
jmp    1c1b <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xb0b>
mov    -0x130(%rbp),%rax
mov    -0x138(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x140(%rbp)
mov    0x33a6(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x338c(%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    1cc5 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xbb5>
mov    0x335e(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3344(%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,-0x148(%rbp)
jmp    1cd8 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xbc8>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x148(%rbp)
jmp    1cd8 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xbc8>
mov    -0x148(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    0x32f3(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x32d9(%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    1d78 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xc68>
mov    0x32ab(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3291(%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,-0x158(%rbp)
jmp    1d8b <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xc7b>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x158(%rbp)
jmp    1d8b <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xc7b>
mov    -0x140(%rbp),%rax
mov    -0x150(%rbp),%rcx
mov    -0x158(%rbp),%rdx
sub    %rdx,%rcx
add    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0x160(%rbp)
mov    0x3228(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x320e(%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    1e43 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xd33>
mov    0x31e0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x31c6(%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,-0x168(%rbp)
jmp    1e56 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xd46>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x168(%rbp)
jmp    1e56 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xd46>
mov    -0x168(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    0x3175(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x315b(%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    1ef6 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xde6>
mov    0x312d(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    0x3113(%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,-0x178(%rbp)
jmp    1f09 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xdf9>
mov    $0xffffffffffffffff,%rax
mov    %rax,-0x178(%rbp)
jmp    1f09 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xdf9>
mov    -0x160(%rbp),%rcx
mov    -0x170(%rbp),%rdx
mov    -0x178(%rbp),%rax
sub    %rax,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x179(%rbp)
jae    1f3f <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xe2f>
xor    %eax,%eax
mov    %al,-0x179(%rbp)
jmp    1f3f <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xe2f>
mov    -0x179(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x3088(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x188(%rbp)
mov    0x3067(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x188(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    200b <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xefb>
mov    0x302c(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x198(%rbp)
mov    0x300b(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x198(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x190(%rbp)
jmp    2019 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xf09>
xor    %eax,%eax
mov    %rax,-0x190(%rbp)
jmp    2019 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xf09>
mov    -0x190(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    0x2fb2(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x1a0(%rbp)
mov    0x2f91(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x1a0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    20e1 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xfd1>
mov    0x2f56(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x1b8(%rbp)
mov    0x2f35(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x1b8(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x1b0(%rbp)
jmp    20ef <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xfdf>
xor    %eax,%eax
mov    %rax,-0x1b0(%rbp)
jmp    20ef <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0xfdf>
mov    -0x1a8(%rbp),%rax
mov    -0x1b0(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x1c8(%rbp)
mov    0x2ed2(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x1c0(%rbp)
mov    0x2eb1(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x1c0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    21c1 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x10b1>
mov    0x2e76(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x1d8(%rbp)
mov    0x2e55(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x1d8(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x1d0(%rbp)
jmp    21cf <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x10bf>
xor    %eax,%eax
mov    %rax,-0x1d0(%rbp)
jmp    21cf <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x10bf>
mov    -0x1d0(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    0x2dfc(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x1e0(%rbp)
mov    0x2ddb(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x1e0(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    2297 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x1187>
mov    0x2da0(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x1f8(%rbp)
mov    0x2d7f(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x1f8(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x1f0(%rbp)
jmp    22a5 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x1195>
xor    %eax,%eax
mov    %rax,-0x1f0(%rbp)
jmp    22a5 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x1195>
mov    -0x1c8(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
mov    -0x1f0(%rbp),%rdx
sub    %rdx,%rcx
add    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0x208(%rbp)
mov    0x2d0e(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x200(%rbp)
mov    0x2ced(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x200(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    2385 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x1275>
mov    0x2cb2(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x218(%rbp)
mov    0x2c91(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x218(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x210(%rbp)
jmp    2393 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x1283>
xor    %eax,%eax
mov    %rax,-0x210(%rbp)
jmp    2393 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x1283>
mov    -0x210(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    0x2c38(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x220(%rbp)
mov    0x2c17(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x220(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
cmp    $0x0,%rax
jae    245b <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x134b>
mov    0x2bdc(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x238(%rbp)
mov    0x2bbb(%rip),%rax
movslq (%rax),%rcx
shl    $0x3,%rcx
sub    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    -0x238(%rbp),%rcx
sub    $0x1,%rax
add    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x230(%rbp)
jmp    2469 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x1359>
xor    %eax,%eax
mov    %rax,-0x230(%rbp)
jmp    2469 <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x1359>
mov    -0x208(%rbp),%rcx
mov    -0x228(%rbp),%rdx
mov    -0x230(%rbp),%rax
sub    %rax,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x239(%rbp)
jae    249f <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x138f>
xor    %eax,%eax
mov    %al,-0x239(%rbp)
jmp    249f <test_UNSIGNED_LONGLONG_NOT_FITS_INTO_SIGNED_INT+0x138f>
mov    -0x239(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    $0x1,%eax
add    $0x240,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_UNSIGNED_LONGLONG_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,%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_LONGLONG_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)
%402 = load i32, i32* @CHAR_BIT
%403 = sext i32 %402 to i64
%404 = mul i64 8, %403
%405 = sub i64 %404, 2
%406 = shl i64 1, %405
%407 = load i32, i32* @CHAR_BIT
%408 = sext i32 %407 to i64
%409 = mul i64 8, %408
%410 = sub i64 %409, 2
%411 = shl i64 1, %410
%412 = sub i64 %411, 1
%413 = add i64 %406, %412
%414 = icmp ugt i64 %413, -1
br i1 %414, label %415, label %428
415: ; preds = %397
%416 = load i32, i32* @CHAR_BIT
%417 = sext i32 %416 to i64
%418 = mul i64 8, %417
%419 = sub i64 %418, 2
%420 = shl i64 1, %419
%421 = load i32, i32* @CHAR_BIT
%422 = sext i32 %421 to i64
%423 = mul i64 8, %422
%424 = sub i64 %423, 2
%425 = shl i64 1, %424
%426 = sub i64 %425, 1
%427 = add i64 %420, %426
br label %429
428: ; preds = %397
br label %429
429: ; preds = %428, %415
%430 = phi i64 [ %427, %415 ], [ -1, %428 ]
%431 = load i32, i32* @CHAR_BIT
%432 = sext i32 %431 to i64
%433 = mul i64 8, %432
%434 = sub i64 %433, 2
%435 = shl i64 1, %434
%436 = load i32, i32* @CHAR_BIT
%437 = sext i32 %436 to i64
%438 = mul i64 8, %437
%439 = sub i64 %438, 2
%440 = shl i64 1, %439
%441 = sub i64 %440, 1
%442 = add i64 %435, %441
%443 = icmp ugt i64 %442, -1
br i1 %443, label %444, label %457
444: ; preds = %429
%445 = load i32, i32* @CHAR_BIT
%446 = sext i32 %445 to i64
%447 = mul i64 8, %446
%448 = sub i64 %447, 2
%449 = shl i64 1, %448
%450 = load i32, i32* @CHAR_BIT
%451 = sext i32 %450 to i64
%452 = mul i64 8, %451
%453 = sub i64 %452, 2
%454 = shl i64 1, %453
%455 = sub i64 %454, 1
%456 = add i64 %449, %455
br label %458
457: ; preds = %429
br label %458
458: ; preds = %457, %444
%459 = phi i64 [ %456, %444 ], [ -1, %457 ]
%460 = sub i64 %430, %459
%461 = load i32, i32* @CHAR_BIT
%462 = sext i32 %461 to i64
%463 = mul i64 8, %462
%464 = sub i64 %463, 2
%465 = shl i64 1, %464
%466 = load i32, i32* @CHAR_BIT
%467 = sext i32 %466 to i64
%468 = mul i64 8, %467
%469 = sub i64 %468, 2
%470 = shl i64 1, %469
%471 = sub i64 %470, 1
%472 = add i64 %465, %471
%473 = icmp ugt i64 %472, -1
br i1 %473, label %474, label %487
474: ; preds = %458
%475 = load i32, i32* @CHAR_BIT
%476 = sext i32 %475 to i64
%477 = mul i64 8, %476
%478 = sub i64 %477, 2
%479 = shl i64 1, %478
%480 = load i32, i32* @CHAR_BIT
%481 = sext i32 %480 to i64
%482 = mul i64 8, %481
%483 = sub i64 %482, 2
%484 = shl i64 1, %483
%485 = sub i64 %484, 1
%486 = add i64 %479, %485
br label %488
487: ; preds = %458
br label %488
488: ; preds = %487, %474
%489 = phi i64 [ %486, %474 ], [ -1, %487 ]
%490 = load i32, i32* @CHAR_BIT
%491 = sext i32 %490 to i64
%492 = mul i64 8, %491
%493 = sub i64 %492, 2
%494 = shl i64 1, %493
%495 = load i32, i32* @CHAR_BIT
%496 = sext i32 %495 to i64
%497 = mul i64 8, %496
%498 = sub i64 %497, 2
%499 = shl i64 1, %498
%500 = sub i64 %499, 1
%501 = add i64 %494, %500
%502 = icmp ugt i64 %501, -1
br i1 %502, label %503, label %516
503: ; preds = %488
%504 = load i32, i32* @CHAR_BIT
%505 = sext i32 %504 to i64
%506 = mul i64 8, %505
%507 = sub i64 %506, 2
%508 = shl i64 1, %507
%509 = load i32, i32* @CHAR_BIT
%510 = sext i32 %509 to i64
%511 = mul i64 8, %510
%512 = sub i64 %511, 2
%513 = shl i64 1, %512
%514 = sub i64 %513, 1
%515 = add i64 %508, %514
br label %517
516: ; preds = %488
br label %517
517: ; preds = %516, %503
%518 = phi i64 [ %515, %503 ], [ -1, %516 ]
%519 = sub i64 %489, %518
%520 = add i64 %519, 1
%521 = sub i64 %460, %520
%522 = load i32, i32* @CHAR_BIT
%523 = sext i32 %522 to i64
%524 = mul i64 8, %523
%525 = sub i64 %524, 2
%526 = shl i64 1, %525
%527 = load i32, i32* @CHAR_BIT
%528 = sext i32 %527 to i64
%529 = mul i64 8, %528
%530 = sub i64 %529, 2
%531 = shl i64 1, %530
%532 = sub i64 %531, 1
%533 = add i64 %526, %532
%534 = icmp ugt i64 %533, -1
br i1 %534, label %535, label %548
535: ; preds = %517
%536 = load i32, i32* @CHAR_BIT
%537 = sext i32 %536 to i64
%538 = mul i64 8, %537
%539 = sub i64 %538, 2
%540 = shl i64 1, %539
%541 = load i32, i32* @CHAR_BIT
%542 = sext i32 %541 to i64
%543 = mul i64 8, %542
%544 = sub i64 %543, 2
%545 = shl i64 1, %544
%546 = sub i64 %545, 1
%547 = add i64 %540, %546
br label %549
548: ; preds = %517
br label %549
549: ; preds = %548, %535
%550 = phi i64 [ %547, %535 ], [ -1, %548 ]
%551 = load i32, i32* @CHAR_BIT
%552 = sext i32 %551 to i64
%553 = mul i64 8, %552
%554 = sub i64 %553, 2
%555 = shl i64 1, %554
%556 = load i32, i32* @CHAR_BIT
%557 = sext i32 %556 to i64
%558 = mul i64 8, %557
%559 = sub i64 %558, 2
%560 = shl i64 1, %559
%561 = sub i64 %560, 1
%562 = add i64 %555, %561
%563 = icmp ugt i64 %562, -1
br i1 %563, label %564, label %577
564: ; preds = %549
%565 = load i32, i32* @CHAR_BIT
%566 = sext i32 %565 to i64
%567 = mul i64 8, %566
%568 = sub i64 %567, 2
%569 = shl i64 1, %568
%570 = load i32, i32* @CHAR_BIT
%571 = sext i32 %570 to i64
%572 = mul i64 8, %571
%573 = sub i64 %572, 2
%574 = shl i64 1, %573
%575 = sub i64 %574, 1
%576 = add i64 %569, %575
br label %578
577: ; preds = %549
br label %578
578: ; preds = %577, %564
%579 = phi i64 [ %576, %564 ], [ -1, %577 ]
%580 = sub i64 %550, %579
%581 = icmp ult i64 %521, %580
br i1 %581, label %582, label %583
582: ; preds = %578
br label %583
583: ; preds = %582, %578
%584 = phi i1 [ false, %578 ], [ false, %582 ]
%585 = xor i1 %584, true
%586 = zext i1 %585 to i32
%587 = call i32 @assert(i32 %586)
%588 = load i32, i32* @CHAR_BIT
%589 = sext i32 %588 to i64
%590 = mul i64 8, %589
%591 = sub i64 %590, 2
%592 = shl i64 1, %591
%593 = load i32, i32* @CHAR_BIT
%594 = sext i32 %593 to i64
%595 = mul i64 8, %594
%596 = sub i64 %595, 2
%597 = shl i64 1, %596
%598 = sub i64 %597, 1
%599 = add i64 %592, %598
%600 = sub i64 0, %599
%601 = sub i64 %600, 1
%602 = icmp ult i64 %601, 0
br i1 %602, label %603, label %618
603: ; preds = %583
%604 = load i32, i32* @CHAR_BIT
%605 = sext i32 %604 to i64
%606 = mul i64 8, %605
%607 = sub i64 %606, 2
%608 = shl i64 1, %607
%609 = load i32, i32* @CHAR_BIT
%610 = sext i32 %609 to i64
%611 = mul i64 8, %610
%612 = sub i64 %611, 2
%613 = shl i64 1, %612
%614 = sub i64 %613, 1
%615 = add i64 %608, %614
%616 = sub i64 0, %615
%617 = sub i64 %616, 1
br label %619
618: ; preds = %583
br label %619
619: ; preds = %618, %603
%620 = phi i64 [ %617, %603 ], [ 0, %618 ]
%621 = load i32, i32* @CHAR_BIT
%622 = sext i32 %621 to i64
%623 = mul i64 8, %622
%624 = sub i64 %623, 2
%625 = shl i64 1, %624
%626 = load i32, i32* @CHAR_BIT
%627 = sext i32 %626 to i64
%628 = mul i64 8, %627
%629 = sub i64 %628, 2
%630 = shl i64 1, %629
%631 = sub i64 %630, 1
%632 = add i64 %625, %631
%633 = sub i64 0, %632
%634 = sub i64 %633, 1
%635 = icmp ult i64 %634, 0
br i1 %635, label %636, label %651
636: ; preds = %619
%637 = load i32, i32* @CHAR_BIT
%638 = sext i32 %637 to i64
%639 = mul i64 8, %638
%640 = sub i64 %639, 2
%641 = shl i64 1, %640
%642 = load i32, i32* @CHAR_BIT
%643 = sext i32 %642 to i64
%644 = mul i64 8, %643
%645 = sub i64 %644, 2
%646 = shl i64 1, %645
%647 = sub i64 %646, 1
%648 = add i64 %641, %647
%649 = sub i64 0, %648
%650 = sub i64 %649, 1
br label %652
651: ; preds = %619
br label %652
652: ; preds = %651, %636
%653 = phi i64 [ %650, %636 ], [ 0, %651 ]
%654 = sub i64 %620, %653
%655 = load i32, i32* @CHAR_BIT
%656 = sext i32 %655 to i64
%657 = mul i64 8, %656
%658 = sub i64 %657, 2
%659 = shl i64 1, %658
%660 = load i32, i32* @CHAR_BIT
%661 = sext i32 %660 to i64
%662 = mul i64 8, %661
%663 = sub i64 %662, 2
%664 = shl i64 1, %663
%665 = sub i64 %664, 1
%666 = add i64 %659, %665
%667 = sub i64 0, %666
%668 = sub i64 %667, 1
%669 = icmp ult i64 %668, 0
br i1 %669, label %670, label %685
670: ; preds = %652
%671 = load i32, i32* @CHAR_BIT
%672 = sext i32 %671 to i64
%673 = mul i64 8, %672
%674 = sub i64 %673, 2
%675 = shl i64 1, %674
%676 = load i32, i32* @CHAR_BIT
%677 = sext i32 %676 to i64
%678 = mul i64 8, %677
%679 = sub i64 %678, 2
%680 = shl i64 1, %679
%681 = sub i64 %680, 1
%682 = add i64 %675, %681
%683 = sub i64 0, %682
%684 = sub i64 %683, 1
br label %686
685: ; preds = %652
br label %686
686: ; preds = %685, %670
%687 = phi i64 [ %684, %670 ], [ 0, %685 ]
%688 = load i32, i32* @CHAR_BIT
%689 = sext i32 %688 to i64
%690 = mul i64 8, %689
%691 = sub i64 %690, 2
%692 = shl i64 1, %691
%693 = load i32, i32* @CHAR_BIT
%694 = sext i32 %693 to i64
%695 = mul i64 8, %694
%696 = sub i64 %695, 2
%697 = shl i64 1, %696
%698 = sub i64 %697, 1
%699 = add i64 %692, %698
%700 = sub i64 0, %699
%701 = sub i64 %700, 1
%702 = icmp ult i64 %701, 0
br i1 %702, label %703, label %718
703: ; preds = %686
%704 = load i32, i32* @CHAR_BIT
%705 = sext i32 %704 to i64
%706 = mul i64 8, %705
%707 = sub i64 %706, 2
%708 = shl i64 1, %707
%709 = load i32, i32* @CHAR_BIT
%710 = sext i32 %709 to i64
%711 = mul i64 8, %710
%712 = sub i64 %711, 2
%713 = shl i64 1, %712
%714 = sub i64 %713, 1
%715 = add i64 %708, %714
%716 = sub i64 0, %715
%717 = sub i64 %716, 1
br label %719
718: ; preds = %686
br label %719
719: ; preds = %718, %703
%720 = phi i64 [ %717, %703 ], [ 0, %718 ]
%721 = sub i64 %687, %720
%722 = add i64 %721, 1
%723 = sub i64 %654, %722
%724 = load i32, i32* @CHAR_BIT
%725 = sext i32 %724 to i64
%726 = mul i64 8, %725
%727 = sub i64 %726, 2
%728 = shl i64 1, %727
%729 = load i32, i32* @CHAR_BIT
%730 = sext i32 %729 to i64
%731 = mul i64 8, %730
%732 = sub i64 %731, 2
%733 = shl i64 1, %732
%734 = sub i64 %733, 1
%735 = add i64 %728, %734
%736 = sub i64 0, %735
%737 = sub i64 %736, 1
%738 = icmp ult i64 %737, 0
br i1 %738, label %739, label %754
739: ; preds = %719
%740 = load i32, i32* @CHAR_BIT
%741 = sext i32 %740 to i64
%742 = mul i64 8, %741
%743 = sub i64 %742, 2
%744 = shl i64 1, %743
%745 = load i32, i32* @CHAR_BIT
%746 = sext i32 %745 to i64
%747 = mul i64 8, %746
%748 = sub i64 %747, 2
%749 = shl i64 1, %748
%750 = sub i64 %749, 1
%751 = add i64 %744, %750
%752 = sub i64 0, %751
%753 = sub i64 %752, 1
br label %755
754: ; preds = %719
br label %755
755: ; preds = %754, %739
%756 = phi i64 [ %753, %739 ], [ 0, %754 ]
%757 = load i32, i32* @CHAR_BIT
%758 = sext i32 %757 to i64
%759 = mul i64 8, %758
%760 = sub i64 %759, 2
%761 = shl i64 1, %760
%762 = load i32, i32* @CHAR_BIT
%763 = sext i32 %762 to i64
%764 = mul i64 8, %763
%765 = sub i64 %764, 2
%766 = shl i64 1, %765
%767 = sub i64 %766, 1
%768 = add i64 %761, %767
%769 = sub i64 0, %768
%770 = sub i64 %769, 1
%771 = icmp ult i64 %770, 0
br i1 %771, label %772, label %787
772: ; preds = %755
%773 = load i32, i32* @CHAR_BIT
%774 = sext i32 %773 to i64
%775 = mul i64 8, %774
%776 = sub i64 %775, 2
%777 = shl i64 1, %776
%778 = load i32, i32* @CHAR_BIT
%779 = sext i32 %778 to i64
%780 = mul i64 8, %779
%781 = sub i64 %780, 2
%782 = shl i64 1, %781
%783 = sub i64 %782, 1
%784 = add i64 %777, %783
%785 = sub i64 0, %784
%786 = sub i64 %785, 1
br label %788
787: ; preds = %755
br label %788
788: ; preds = %787, %772
%789 = phi i64 [ %786, %772 ], [ 0, %787 ]
%790 = sub i64 %756, %789
%791 = icmp ult i64 %723, %790
br i1 %791, label %792, label %793
792: ; preds = %788
br label %793
793: ; preds = %792, %788
%794 = phi i1 [ false, %788 ], [ false, %792 ]
%795 = xor i1 %794, true
%796 = zext i1 %795 to i32
%797 = call i32 @assert(i32 %796)
ret i32 1
}

LLVM IR (-O2):
@CHAR_BIT = global i32 0
define i32 @test_UNSIGNED_LONGLONG_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)
%8 = tail call i32 @assert(i32 1)
%9 = tail call i32 @assert(i32 1)
ret i32 1
}