void check_add_float(void) {
  do {
    do {
      float a1;
      _Complex float b1, c1;
      volatile float a2;
      volatile _Complex float b2, c2;
      a1 = +0.0f;
      b1 = (+1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b1) != 0 || __builtin_copysignf(1.0, __real__(b1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(b1)) != +1.0)
          abort();
      } while (0);
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != +1.0)
          abort();
      } while (0);
      a2 = +0.0f;
      b2 = (+1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b2) != 0 || __builtin_copysignf(1.0, __real__(b2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(b2)) != +1.0)
          abort();
      } while (0);
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != +1.0)
          abort();
      } while (0);
    } while (0);
    do {
      float a1;
      _Complex float b1, c1;
      volatile float a2;
      volatile _Complex float b2, c2;
      a1 = +0.0f;
      b1 = (+1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b1) != 0 || __builtin_copysignf(1.0, __real__(b1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(b1)) != -1.0)
          abort();
      } while (0);
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != -1.0)
          abort();
      } while (0);
      a2 = +0.0f;
      b2 = (+1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b2) != 0 || __builtin_copysignf(1.0, __real__(b2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(b2)) != -1.0)
          abort();
      } while (0);
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != -1.0)
          abort();
      } while (0);
    } while (0);
    do {
      float a1;
      _Complex float b1, c1;
      volatile float a2;
      volatile _Complex float b2, c2;
      a1 = +0.0f;
      b1 = (-1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b1) != 0 || __builtin_copysignf(1.0, __real__(b1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(b1)) != +1.0)
          abort();
      } while (0);
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != +1.0)
          abort();
      } while (0);
      a2 = +0.0f;
      b2 = (-1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b2) != 0 || __builtin_copysignf(1.0, __real__(b2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(b2)) != +1.0)
          abort();
      } while (0);
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != +1.0)
          abort();
      } while (0);
    } while (0);
    do {
      float a1;
      _Complex float b1, c1;
      volatile float a2;
      volatile _Complex float b2, c2;
      a1 = +0.0f;
      b1 = (-1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b1) != 0 || __builtin_copysignf(1.0, __real__(b1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(b1)) != -1.0)
          abort();
      } while (0);
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != -1.0)
          abort();
      } while (0);
      a2 = +0.0f;
      b2 = (-1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b2) != 0 || __builtin_copysignf(1.0, __real__(b2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(b2)) != -1.0)
          abort();
      } while (0);
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != -1.0)
          abort();
      } while (0);
    } while (0);
    do {
      float a1;
      _Complex float b1, c1;
      volatile float a2;
      volatile _Complex float b2, c2;
      a1 = -0.0f;
      b1 = (+1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b1) != 0 || __builtin_copysignf(1.0, __real__(b1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(b1)) != +1.0)
          abort();
      } while (0);
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != +1.0)
          abort();
      } while (0);
      a2 = -0.0f;
      b2 = (+1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b2) != 0 || __builtin_copysignf(1.0, __real__(b2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(b2)) != +1.0)
          abort();
      } while (0);
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != +1.0)
          abort();
      } while (0);
    } while (0);
    do {
      float a1;
      _Complex float b1, c1;
      volatile float a2;
      volatile _Complex float b2, c2;
      a1 = -0.0f;
      b1 = (+1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b1) != 0 || __builtin_copysignf(1.0, __real__(b1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(b1)) != -1.0)
          abort();
      } while (0);
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != -1.0)
          abort();
      } while (0);
      a2 = -0.0f;
      b2 = (+1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b2) != 0 || __builtin_copysignf(1.0, __real__(b2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(b2)) != -1.0)
          abort();
      } while (0);
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != -1.0)
          abort();
      } while (0);
    } while (0);
    do {
      float a1;
      _Complex float b1, c1;
      volatile float a2;
      volatile _Complex float b2, c2;
      a1 = -0.0f;
      b1 = (-1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b1) != 0 || __builtin_copysignf(1.0, __real__(b1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(b1)) != +1.0)
          abort();
      } while (0);
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != +1.0)
          abort();
      } while (0);
      a2 = -0.0f;
      b2 = (-1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b2) != 0 || __builtin_copysignf(1.0, __real__(b2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(b2)) != +1.0)
          abort();
      } while (0);
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != +1.0)
          abort();
      } while (0);
    } while (0);
    do {
      float a1;
      _Complex float b1, c1;
      volatile float a2;
      volatile _Complex float b2, c2;
      a1 = -0.0f;
      b1 = (-1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b1) != 0 || __builtin_copysignf(1.0, __real__(b1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(b1)) != -1.0)
          abort();
      } while (0);
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != -1.0)
          abort();
      } while (0);
      a2 = -0.0f;
      b2 = (-1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((b2) != 0 || __builtin_copysignf(1.0, __real__(b2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(b2)) != -1.0)
          abort();
      } while (0);
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != -1.0)
          abort();
      } while (0);
    } while (0);
    do {
      _Complex float a1, c1;
      float b1;
      volatile _Complex float a2, c2;
      volatile float b2;
      a1 = (+1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a1) != 0 || __builtin_copysignf(1.0, __real__(a1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(a1)) != +1.0)
          abort();
      } while (0);
      b1 = +0.0f;
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != +1.0)
          abort();
      } while (0);
      a2 = (+1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a2) != 0 || __builtin_copysignf(1.0, __real__(a2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(a2)) != +1.0)
          abort();
      } while (0);
      b2 = +0.0f;
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != +1.0)
          abort();
      } while (0);
    } while (0);
    do {
      _Complex float a1, c1;
      float b1;
      volatile _Complex float a2, c2;
      volatile float b2;
      a1 = (+1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a1) != 0 || __builtin_copysignf(1.0, __real__(a1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(a1)) != +1.0)
          abort();
      } while (0);
      b1 = -0.0f;
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != +1.0)
          abort();
      } while (0);
      a2 = (+1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a2) != 0 || __builtin_copysignf(1.0, __real__(a2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(a2)) != +1.0)
          abort();
      } while (0);
      b2 = -0.0f;
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != +1.0)
          abort();
      } while (0);
    } while (0);
    do {
      _Complex float a1, c1;
      float b1;
      volatile _Complex float a2, c2;
      volatile float b2;
      a1 = (+1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a1) != 0 || __builtin_copysignf(1.0, __real__(a1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(a1)) != -1.0)
          abort();
      } while (0);
      b1 = +0.0f;
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != -1.0)
          abort();
      } while (0);
      a2 = (+1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a2) != 0 || __builtin_copysignf(1.0, __real__(a2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(a2)) != -1.0)
          abort();
      } while (0);
      b2 = +0.0f;
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != -1.0)
          abort();
      } while (0);
    } while (0);
    do {
      _Complex float a1, c1;
      float b1;
      volatile _Complex float a2, c2;
      volatile float b2;
      a1 = (+1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a1) != 0 || __builtin_copysignf(1.0, __real__(a1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(a1)) != -1.0)
          abort();
      } while (0);
      b1 = -0.0f;
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != -1.0)
          abort();
      } while (0);
      a2 = (+1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a2) != 0 || __builtin_copysignf(1.0, __real__(a2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(a2)) != -1.0)
          abort();
      } while (0);
      b2 = -0.0f;
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != -1.0)
          abort();
      } while (0);
    } while (0);
    do {
      _Complex float a1, c1;
      float b1;
      volatile _Complex float a2, c2;
      volatile float b2;
      a1 = (-1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a1) != 0 || __builtin_copysignf(1.0, __real__(a1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(a1)) != +1.0)
          abort();
      } while (0);
      b1 = +0.0f;
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != +1.0)
          abort();
      } while (0);
      a2 = (-1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a2) != 0 || __builtin_copysignf(1.0, __real__(a2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(a2)) != +1.0)
          abort();
      } while (0);
      b2 = +0.0f;
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != +1.0)
          abort();
      } while (0);
    } while (0);
    do {
      _Complex float a1, c1;
      float b1;
      volatile _Complex float a2, c2;
      volatile float b2;
      a1 = (-1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a1) != 0 || __builtin_copysignf(1.0, __real__(a1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(a1)) != +1.0)
          abort();
      } while (0);
      b1 = -0.0f;
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != +1.0)
          abort();
      } while (0);
      a2 = (-1 == 1   ? +1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : +1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a2) != 0 || __builtin_copysignf(1.0, __real__(a2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(a2)) != +1.0)
          abort();
      } while (0);
      b2 = -0.0f;
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != +1.0)
          abort();
      } while (0);
    } while (0);
    do {
      _Complex float a1, c1;
      float b1;
      volatile _Complex float a2, c2;
      volatile float b2;
      a1 = (-1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a1) != 0 || __builtin_copysignf(1.0, __real__(a1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(a1)) != -1.0)
          abort();
      } while (0);
      b1 = +0.0f;
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != -1.0)
          abort();
      } while (0);
      a2 = (-1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a2) != 0 || __builtin_copysignf(1.0, __real__(a2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(a2)) != -1.0)
          abort();
      } while (0);
      b2 = +0.0f;
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != +1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != -1.0)
          abort();
      } while (0);
    } while (0);
    do {
      _Complex float a1, c1;
      float b1;
      volatile _Complex float a2, c2;
      volatile float b2;
      a1 = (-1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a1) != 0 || __builtin_copysignf(1.0, __real__(a1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(a1)) != -1.0)
          abort();
      } while (0);
      b1 = -0.0f;
      c1 = a1 + b1;
      do {
        if ((c1) != 0 || __builtin_copysignf(1.0, __real__(c1)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(c1)) != -1.0)
          abort();
      } while (0);
      a2 = (-1 == 1   ? -1 == 1 ? 0.0f + 0.0if : 0.0f - 0.0if
            : -1 == 1 ? -(0.0f - 0.0if)
                      : -(0.0f + 0.0if));
      do {
        if ((a2) != 0 || __builtin_copysignf(1.0, __real__(a2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(a2)) != -1.0)
          abort();
      } while (0);
      b2 = -0.0f;
      c2 = a2 + b2;
      do {
        if ((c2) != 0 || __builtin_copysignf(1.0, __real__(c2)) != -1.0 ||
            __builtin_copysignf(1.0, __imag__(c2)) != -1.0)
          abort();
      } while (0);
    } while (0);
  } while (0);
}


x86 assembly (clang, -O0):
<check_add_float>:
push   %rbp
mov    %rsp,%rbp
sub    $0x600,%rsp
jmp    1120 <check_add_float+0x10>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
mov    $0x1,%al
test   $0x1,%al
jne    1137 <check_add_float+0x27>
jmp    11a6 <check_add_float+0x96>
mov    $0x1,%al
test   $0x1,%al
jne    1146 <check_add_float+0x36>
jmp    1161 <check_add_float+0x51>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x304(%rbp)
ff
movss  %xmm0,-0x300(%rbp)
ff
jmp    1181 <check_add_float+0x71>
xorps  %xmm1,%xmm1
movss  0x5e94(%rip),%xmm0
movss  %xmm1,-0x304(%rbp)
ff
movss  %xmm0,-0x300(%rbp)
ff
jmp    1181 <check_add_float+0x71>
movss  -0x304(%rbp),%xmm1
ff
movss  -0x300(%rbp),%xmm0
ff
movss  %xmm1,-0x30c(%rbp)
ff
movss  %xmm0,-0x308(%rbp)
ff
jmp    1215 <check_add_float+0x105>
mov    $0x1,%al
test   $0x1,%al
jne    11b5 <check_add_float+0xa5>
jmp    11d5 <check_add_float+0xc5>
movss  0x5e43(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x314(%rbp)
ff
movss  %xmm0,-0x310(%rbp)
ff
jmp    11f5 <check_add_float+0xe5>
movss  0x5e23(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x314(%rbp)
ff
movss  %xmm0,-0x310(%rbp)
ff
jmp    11f5 <check_add_float+0xe5>
movss  -0x314(%rbp),%xmm1
ff
movss  -0x310(%rbp),%xmm0
ff
movss  %xmm1,-0x30c(%rbp)
ff
movss  %xmm0,-0x308(%rbp)
ff
movss  -0x30c(%rbp),%xmm1
ff
movss  -0x308(%rbp),%xmm0
ff
movss  %xmm1,-0x10(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    12d2 <check_add_float+0x1c2>
movss  -0x10(%rbp),%xmm0
movaps 0x5db5(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5dba(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5d82(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    12d2 <check_add_float+0x1c2>
jp     12d2 <check_add_float+0x1c2>
movss  -0xc(%rbp),%xmm0
movaps 0x5d7e(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5d83(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5d4b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    12d2 <check_add_float+0x1c2>
jp     12d2 <check_add_float+0x1c2>
jmp    12d7 <check_add_float+0x1c7>
call   1030 <abort@plt>
jmp    12dc <check_add_float+0x1cc>
movss  -0x4(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm0
addss  %xmm2,%xmm1
movss  %xmm1,-0x18(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  -0x18(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    139c <check_add_float+0x28c>
movss  -0x18(%rbp),%xmm0
movaps 0x5ceb(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5cf0(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5cb8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    139c <check_add_float+0x28c>
jp     139c <check_add_float+0x28c>
movss  -0x14(%rbp),%xmm0
movaps 0x5cb4(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5cb9(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5c81(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    139c <check_add_float+0x28c>
jp     139c <check_add_float+0x28c>
jmp    13a1 <check_add_float+0x291>
call   1030 <abort@plt>
jmp    13a6 <check_add_float+0x296>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    $0x1,%al
test   $0x1,%al
jne    13bd <check_add_float+0x2ad>
jmp    142c <check_add_float+0x31c>
mov    $0x1,%al
test   $0x1,%al
jne    13cc <check_add_float+0x2bc>
jmp    13e7 <check_add_float+0x2d7>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x31c(%rbp)
ff
movss  %xmm0,-0x318(%rbp)
ff
jmp    1407 <check_add_float+0x2f7>
xorps  %xmm1,%xmm1
movss  0x5c0e(%rip),%xmm0
movss  %xmm1,-0x31c(%rbp)
ff
movss  %xmm0,-0x318(%rbp)
ff
jmp    1407 <check_add_float+0x2f7>
movss  -0x31c(%rbp),%xmm1
ff
movss  -0x318(%rbp),%xmm0
ff
movss  %xmm1,-0x324(%rbp)
ff
movss  %xmm0,-0x320(%rbp)
ff
jmp    149b <check_add_float+0x38b>
mov    $0x1,%al
test   $0x1,%al
jne    143b <check_add_float+0x32b>
jmp    145b <check_add_float+0x34b>
movss  0x5bbd(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x32c(%rbp)
ff
movss  %xmm0,-0x328(%rbp)
ff
jmp    147b <check_add_float+0x36b>
movss  0x5b9d(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x32c(%rbp)
ff
movss  %xmm0,-0x328(%rbp)
ff
jmp    147b <check_add_float+0x36b>
movss  -0x32c(%rbp),%xmm1
ff
movss  -0x328(%rbp),%xmm0
ff
movss  %xmm1,-0x324(%rbp)
ff
movss  %xmm0,-0x320(%rbp)
ff
movss  -0x324(%rbp),%xmm1
ff
movss  -0x320(%rbp),%xmm0
ff
movss  %xmm1,-0x28(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1558 <check_add_float+0x448>
movss  -0x28(%rbp),%xmm0
movaps 0x5b2f(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5b34(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5afc(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1558 <check_add_float+0x448>
jp     1558 <check_add_float+0x448>
movss  -0x24(%rbp),%xmm0
movaps 0x5af8(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5afd(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5ac5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1558 <check_add_float+0x448>
jp     1558 <check_add_float+0x448>
jmp    155d <check_add_float+0x44d>
call   1030 <abort@plt>
jmp    1562 <check_add_float+0x452>
movss  -0x1c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
movss  -0x24(%rbp),%xmm0
addss  %xmm2,%xmm1
movss  %xmm1,-0x30(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1622 <check_add_float+0x512>
movss  -0x30(%rbp),%xmm0
movaps 0x5a65(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5a6a(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5a32(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1622 <check_add_float+0x512>
jp     1622 <check_add_float+0x512>
movss  -0x2c(%rbp),%xmm0
movaps 0x5a2e(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5a33(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x59fb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1622 <check_add_float+0x512>
jp     1622 <check_add_float+0x512>
jmp    1627 <check_add_float+0x517>
call   1030 <abort@plt>
jmp    162c <check_add_float+0x51c>
jmp    1631 <check_add_float+0x521>
jmp    1636 <check_add_float+0x526>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    $0x1,%al
test   $0x1,%al
jne    164d <check_add_float+0x53d>
jmp    16bc <check_add_float+0x5ac>
xor    %eax,%eax
test   $0x1,%al
jne    165c <check_add_float+0x54c>
jmp    1677 <check_add_float+0x567>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x334(%rbp)
ff
movss  %xmm0,-0x330(%rbp)
ff
jmp    1697 <check_add_float+0x587>
xorps  %xmm1,%xmm1
movss  0x597e(%rip),%xmm0
movss  %xmm1,-0x334(%rbp)
ff
movss  %xmm0,-0x330(%rbp)
ff
jmp    1697 <check_add_float+0x587>
movss  -0x334(%rbp),%xmm1
ff
movss  -0x330(%rbp),%xmm0
ff
movss  %xmm1,-0x33c(%rbp)
ff
movss  %xmm0,-0x338(%rbp)
ff
jmp    172b <check_add_float+0x61b>
xor    %eax,%eax
test   $0x1,%al
jne    16cb <check_add_float+0x5bb>
jmp    16eb <check_add_float+0x5db>
movss  0x592d(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x344(%rbp)
ff
movss  %xmm0,-0x340(%rbp)
ff
jmp    170b <check_add_float+0x5fb>
movss  0x590d(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x344(%rbp)
ff
movss  %xmm0,-0x340(%rbp)
ff
jmp    170b <check_add_float+0x5fb>
movss  -0x344(%rbp),%xmm1
ff
movss  -0x340(%rbp),%xmm0
ff
movss  %xmm1,-0x33c(%rbp)
ff
movss  %xmm0,-0x338(%rbp)
ff
movss  -0x33c(%rbp),%xmm1
ff
movss  -0x338(%rbp),%xmm0
ff
movss  %xmm1,-0x40(%rbp)
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    17e8 <check_add_float+0x6d8>
movss  -0x40(%rbp),%xmm0
movaps 0x589f(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x58a4(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x586c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    17e8 <check_add_float+0x6d8>
jp     17e8 <check_add_float+0x6d8>
movss  -0x3c(%rbp),%xmm0
movaps 0x5868(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x586d(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x583d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    17e8 <check_add_float+0x6d8>
jp     17e8 <check_add_float+0x6d8>
jmp    17ed <check_add_float+0x6dd>
call   1030 <abort@plt>
jmp    17f2 <check_add_float+0x6e2>
movss  -0x34(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
addss  %xmm2,%xmm1
movss  %xmm1,-0x48(%rbp)
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    18b2 <check_add_float+0x7a2>
movss  -0x48(%rbp),%xmm0
movaps 0x57d5(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x57da(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x57a2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    18b2 <check_add_float+0x7a2>
jp     18b2 <check_add_float+0x7a2>
movss  -0x44(%rbp),%xmm0
movaps 0x579e(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x57a3(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5773(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    18b2 <check_add_float+0x7a2>
jp     18b2 <check_add_float+0x7a2>
jmp    18b7 <check_add_float+0x7a7>
call   1030 <abort@plt>
jmp    18bc <check_add_float+0x7ac>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    $0x1,%al
test   $0x1,%al
jne    18d3 <check_add_float+0x7c3>
jmp    1942 <check_add_float+0x832>
xor    %eax,%eax
test   $0x1,%al
jne    18e2 <check_add_float+0x7d2>
jmp    18fd <check_add_float+0x7ed>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x34c(%rbp)
ff
movss  %xmm0,-0x348(%rbp)
ff
jmp    191d <check_add_float+0x80d>
xorps  %xmm1,%xmm1
movss  0x56f8(%rip),%xmm0
movss  %xmm1,-0x34c(%rbp)
ff
movss  %xmm0,-0x348(%rbp)
ff
jmp    191d <check_add_float+0x80d>
movss  -0x34c(%rbp),%xmm1
ff
movss  -0x348(%rbp),%xmm0
ff
movss  %xmm1,-0x354(%rbp)
ff
movss  %xmm0,-0x350(%rbp)
ff
jmp    19b1 <check_add_float+0x8a1>
xor    %eax,%eax
test   $0x1,%al
jne    1951 <check_add_float+0x841>
jmp    1971 <check_add_float+0x861>
movss  0x56a7(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x35c(%rbp)
ff
movss  %xmm0,-0x358(%rbp)
ff
jmp    1991 <check_add_float+0x881>
movss  0x5687(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x35c(%rbp)
ff
movss  %xmm0,-0x358(%rbp)
ff
jmp    1991 <check_add_float+0x881>
movss  -0x35c(%rbp),%xmm1
ff
movss  -0x358(%rbp),%xmm0
ff
movss  %xmm1,-0x354(%rbp)
ff
movss  %xmm0,-0x350(%rbp)
ff
movss  -0x354(%rbp),%xmm1
ff
movss  -0x350(%rbp),%xmm0
ff
movss  %xmm1,-0x58(%rbp)
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1a6e <check_add_float+0x95e>
movss  -0x58(%rbp),%xmm0
movaps 0x5619(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x561e(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x55e6(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1a6e <check_add_float+0x95e>
jp     1a6e <check_add_float+0x95e>
movss  -0x54(%rbp),%xmm0
movaps 0x55e2(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x55e7(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x55b7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1a6e <check_add_float+0x95e>
jp     1a6e <check_add_float+0x95e>
jmp    1a73 <check_add_float+0x963>
call   1030 <abort@plt>
jmp    1a78 <check_add_float+0x968>
movss  -0x4c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x54(%rbp),%xmm0
addss  %xmm2,%xmm1
movss  %xmm1,-0x60(%rbp)
movss  %xmm0,-0x5c(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1b38 <check_add_float+0xa28>
movss  -0x60(%rbp),%xmm0
movaps 0x554f(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5554(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x551c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1b38 <check_add_float+0xa28>
jp     1b38 <check_add_float+0xa28>
movss  -0x5c(%rbp),%xmm0
movaps 0x5518(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x551d(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x54ed(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1b38 <check_add_float+0xa28>
jp     1b38 <check_add_float+0xa28>
jmp    1b3d <check_add_float+0xa2d>
call   1030 <abort@plt>
jmp    1b42 <check_add_float+0xa32>
jmp    1b47 <check_add_float+0xa37>
jmp    1b4c <check_add_float+0xa3c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xor    %eax,%eax
test   $0x1,%al
jne    1b63 <check_add_float+0xa53>
jmp    1bd2 <check_add_float+0xac2>
mov    $0x1,%al
test   $0x1,%al
jne    1b72 <check_add_float+0xa62>
jmp    1b8d <check_add_float+0xa7d>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x364(%rbp)
ff
movss  %xmm0,-0x360(%rbp)
ff
jmp    1bad <check_add_float+0xa9d>
xorps  %xmm1,%xmm1
movss  0x5468(%rip),%xmm0
movss  %xmm1,-0x364(%rbp)
ff
movss  %xmm0,-0x360(%rbp)
ff
jmp    1bad <check_add_float+0xa9d>
movss  -0x364(%rbp),%xmm1
ff
movss  -0x360(%rbp),%xmm0
ff
movss  %xmm1,-0x36c(%rbp)
ff
movss  %xmm0,-0x368(%rbp)
ff
jmp    1c41 <check_add_float+0xb31>
mov    $0x1,%al
test   $0x1,%al
jne    1be1 <check_add_float+0xad1>
jmp    1c01 <check_add_float+0xaf1>
movss  0x5417(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x374(%rbp)
ff
movss  %xmm0,-0x370(%rbp)
ff
jmp    1c21 <check_add_float+0xb11>
movss  0x53f7(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x374(%rbp)
ff
movss  %xmm0,-0x370(%rbp)
ff
jmp    1c21 <check_add_float+0xb11>
movss  -0x374(%rbp),%xmm1
ff
movss  -0x370(%rbp),%xmm0
ff
movss  %xmm1,-0x36c(%rbp)
ff
movss  %xmm0,-0x368(%rbp)
ff
movss  -0x36c(%rbp),%xmm1
ff
movss  -0x368(%rbp),%xmm0
ff
movss  %xmm1,-0x70(%rbp)
movss  %xmm0,-0x6c(%rbp)
movss  -0x70(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1cfe <check_add_float+0xbee>
movss  -0x70(%rbp),%xmm0
movaps 0x5389(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x538e(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x535e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1cfe <check_add_float+0xbee>
jp     1cfe <check_add_float+0xbee>
movss  -0x6c(%rbp),%xmm0
movaps 0x5352(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5357(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x531f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1cfe <check_add_float+0xbee>
jp     1cfe <check_add_float+0xbee>
jmp    1d03 <check_add_float+0xbf3>
call   1030 <abort@plt>
jmp    1d08 <check_add_float+0xbf8>
movss  -0x64(%rbp),%xmm1
movss  -0x70(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm0
addss  %xmm2,%xmm1
movss  %xmm1,-0x78(%rbp)
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm1
movss  -0x74(%rbp),%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1dc8 <check_add_float+0xcb8>
movss  -0x78(%rbp),%xmm0
movaps 0x52bf(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x52c4(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x528c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1dc8 <check_add_float+0xcb8>
jp     1dc8 <check_add_float+0xcb8>
movss  -0x74(%rbp),%xmm0
movaps 0x5288(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x528d(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5255(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1dc8 <check_add_float+0xcb8>
jp     1dc8 <check_add_float+0xcb8>
jmp    1dcd <check_add_float+0xcbd>
call   1030 <abort@plt>
jmp    1dd2 <check_add_float+0xcc2>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
xor    %eax,%eax
test   $0x1,%al
jne    1de9 <check_add_float+0xcd9>
jmp    1e58 <check_add_float+0xd48>
mov    $0x1,%al
test   $0x1,%al
jne    1df8 <check_add_float+0xce8>
jmp    1e13 <check_add_float+0xd03>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x37c(%rbp)
ff
movss  %xmm0,-0x378(%rbp)
ff
jmp    1e33 <check_add_float+0xd23>
xorps  %xmm1,%xmm1
movss  0x51e2(%rip),%xmm0
movss  %xmm1,-0x37c(%rbp)
ff
movss  %xmm0,-0x378(%rbp)
ff
jmp    1e33 <check_add_float+0xd23>
movss  -0x37c(%rbp),%xmm1
ff
movss  -0x378(%rbp),%xmm0
ff
movss  %xmm1,-0x384(%rbp)
ff
movss  %xmm0,-0x380(%rbp)
ff
jmp    1ec7 <check_add_float+0xdb7>
mov    $0x1,%al
test   $0x1,%al
jne    1e67 <check_add_float+0xd57>
jmp    1e87 <check_add_float+0xd77>
movss  0x5191(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x38c(%rbp)
ff
movss  %xmm0,-0x388(%rbp)
ff
jmp    1ea7 <check_add_float+0xd97>
movss  0x5171(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x38c(%rbp)
ff
movss  %xmm0,-0x388(%rbp)
ff
jmp    1ea7 <check_add_float+0xd97>
movss  -0x38c(%rbp),%xmm1
ff
movss  -0x388(%rbp),%xmm0
ff
movss  %xmm1,-0x384(%rbp)
ff
movss  %xmm0,-0x380(%rbp)
ff
movss  -0x384(%rbp),%xmm1
ff
movss  -0x380(%rbp),%xmm0
ff
movss  %xmm1,-0x88(%rbp)
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1f96 <check_add_float+0xe86>
movss  -0x88(%rbp),%xmm0
ff
movaps 0x50f4(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x50f9(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x50c9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1f96 <check_add_float+0xe86>
jp     1f96 <check_add_float+0xe86>
movss  -0x84(%rbp),%xmm0
ff
movaps 0x50ba(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x50bf(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5087(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1f96 <check_add_float+0xe86>
jp     1f96 <check_add_float+0xe86>
jmp    1f9b <check_add_float+0xe8b>
call   1030 <abort@plt>
jmp    1fa0 <check_add_float+0xe90>
movss  -0x7c(%rbp),%xmm1
movss  -0x88(%rbp),%xmm2
ff
movss  -0x84(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x90(%rbp)
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x90(%rbp),%xmm1
ff
movss  -0x8c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2078 <check_add_float+0xf68>
movss  -0x90(%rbp),%xmm0
movaps 0x5012(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x5017(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4fdf(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2078 <check_add_float+0xf68>
jp     2078 <check_add_float+0xf68>
movss  -0x8c(%rbp),%xmm0
ff
movaps 0x4fd8(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4fdd(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4fa5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2078 <check_add_float+0xf68>
jp     2078 <check_add_float+0xf68>
jmp    207d <check_add_float+0xf6d>
call   1030 <abort@plt>
jmp    2082 <check_add_float+0xf72>
jmp    2087 <check_add_float+0xf77>
jmp    208c <check_add_float+0xf7c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
xor    %eax,%eax
test   $0x1,%al
jne    20a6 <check_add_float+0xf96>
jmp    2115 <check_add_float+0x1005>
xor    %eax,%eax
test   $0x1,%al
jne    20b5 <check_add_float+0xfa5>
jmp    20d0 <check_add_float+0xfc0>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x394(%rbp)
ff
movss  %xmm0,-0x390(%rbp)
ff
jmp    20f0 <check_add_float+0xfe0>
xorps  %xmm1,%xmm1
movss  0x4f25(%rip),%xmm0
movss  %xmm1,-0x394(%rbp)
ff
movss  %xmm0,-0x390(%rbp)
ff
jmp    20f0 <check_add_float+0xfe0>
movss  -0x394(%rbp),%xmm1
ff
movss  -0x390(%rbp),%xmm0
ff
movss  %xmm1,-0x39c(%rbp)
ff
movss  %xmm0,-0x398(%rbp)
ff
jmp    2184 <check_add_float+0x1074>
xor    %eax,%eax
test   $0x1,%al
jne    2124 <check_add_float+0x1014>
jmp    2144 <check_add_float+0x1034>
movss  0x4ed4(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x3a4(%rbp)
ff
movss  %xmm0,-0x3a0(%rbp)
ff
jmp    2164 <check_add_float+0x1054>
movss  0x4eb4(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x3a4(%rbp)
ff
movss  %xmm0,-0x3a0(%rbp)
ff
jmp    2164 <check_add_float+0x1054>
movss  -0x3a4(%rbp),%xmm1
ff
movss  -0x3a0(%rbp),%xmm0
ff
movss  %xmm1,-0x39c(%rbp)
ff
movss  %xmm0,-0x398(%rbp)
ff
movss  -0x39c(%rbp),%xmm1
ff
movss  -0x398(%rbp),%xmm0
ff
movss  %xmm1,-0xa0(%rbp)
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2253 <check_add_float+0x1143>
movss  -0xa0(%rbp),%xmm0
ff
movaps 0x4e37(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4e3c(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4e0c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2253 <check_add_float+0x1143>
jp     2253 <check_add_float+0x1143>
movss  -0x9c(%rbp),%xmm0
ff
movaps 0x4dfd(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4e02(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4dd2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2253 <check_add_float+0x1143>
jp     2253 <check_add_float+0x1143>
jmp    2258 <check_add_float+0x1148>
call   1030 <abort@plt>
jmp    225d <check_add_float+0x114d>
movss  -0x94(%rbp),%xmm1
ff
movss  -0xa0(%rbp),%xmm2
ff
movss  -0x9c(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0xa8(%rbp)
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa8(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2338 <check_add_float+0x1228>
movss  -0xa8(%rbp),%xmm0
ff
movaps 0x4d52(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4d57(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4d1f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2338 <check_add_float+0x1228>
jp     2338 <check_add_float+0x1228>
movss  -0xa4(%rbp),%xmm0
movaps 0x4d18(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4d1d(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4ced(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2338 <check_add_float+0x1228>
jp     2338 <check_add_float+0x1228>
jmp    233d <check_add_float+0x122d>
call   1030 <abort@plt>
jmp    2342 <check_add_float+0x1232>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
xor    %eax,%eax
test   $0x1,%al
jne    235c <check_add_float+0x124c>
jmp    23cb <check_add_float+0x12bb>
xor    %eax,%eax
test   $0x1,%al
jne    236b <check_add_float+0x125b>
jmp    2386 <check_add_float+0x1276>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x3ac(%rbp)
ff
movss  %xmm0,-0x3a8(%rbp)
ff
jmp    23a6 <check_add_float+0x1296>
xorps  %xmm1,%xmm1
movss  0x4c6f(%rip),%xmm0
movss  %xmm1,-0x3ac(%rbp)
ff
movss  %xmm0,-0x3a8(%rbp)
ff
jmp    23a6 <check_add_float+0x1296>
movss  -0x3ac(%rbp),%xmm1
ff
movss  -0x3a8(%rbp),%xmm0
ff
movss  %xmm1,-0x3b4(%rbp)
ff
movss  %xmm0,-0x3b0(%rbp)
ff
jmp    243a <check_add_float+0x132a>
xor    %eax,%eax
test   $0x1,%al
jne    23da <check_add_float+0x12ca>
jmp    23fa <check_add_float+0x12ea>
movss  0x4c1e(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x3bc(%rbp)
ff
movss  %xmm0,-0x3b8(%rbp)
ff
jmp    241a <check_add_float+0x130a>
movss  0x4bfe(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x3bc(%rbp)
ff
movss  %xmm0,-0x3b8(%rbp)
ff
jmp    241a <check_add_float+0x130a>
movss  -0x3bc(%rbp),%xmm1
ff
movss  -0x3b8(%rbp),%xmm0
ff
movss  %xmm1,-0x3b4(%rbp)
ff
movss  %xmm0,-0x3b0(%rbp)
ff
movss  -0x3b4(%rbp),%xmm1
ff
movss  -0x3b0(%rbp),%xmm0
ff
movss  %xmm1,-0xb8(%rbp)
ff
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb8(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2509 <check_add_float+0x13f9>
movss  -0xb8(%rbp),%xmm0
ff
movaps 0x4b81(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4b86(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4b56(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2509 <check_add_float+0x13f9>
jp     2509 <check_add_float+0x13f9>
movss  -0xb4(%rbp),%xmm0
ff
movaps 0x4b47(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4b4c(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4b1c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2509 <check_add_float+0x13f9>
jp     2509 <check_add_float+0x13f9>
jmp    250e <check_add_float+0x13fe>
call   1030 <abort@plt>
jmp    2513 <check_add_float+0x1403>
movss  -0xac(%rbp),%xmm1
ff
movss  -0xb8(%rbp),%xmm2
ff
movss  -0xb4(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0xc0(%rbp)
ff
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xc0(%rbp),%xmm1
ff
movss  -0xbc(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    25ee <check_add_float+0x14de>
movss  -0xc0(%rbp),%xmm0
ff
movaps 0x4a9c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4aa1(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4a69(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    25ee <check_add_float+0x14de>
jp     25ee <check_add_float+0x14de>
movss  -0xbc(%rbp),%xmm0
ff
movaps 0x4a62(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4a67(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4a37(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    25ee <check_add_float+0x14de>
jp     25ee <check_add_float+0x14de>
jmp    25f3 <check_add_float+0x14e3>
call   1030 <abort@plt>
jmp    25f8 <check_add_float+0x14e8>
jmp    25fd <check_add_float+0x14ed>
jmp    2602 <check_add_float+0x14f2>
movss  0x49f6(%rip),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    $0x1,%al
test   $0x1,%al
jne    2621 <check_add_float+0x1511>
jmp    2690 <check_add_float+0x1580>
mov    $0x1,%al
test   $0x1,%al
jne    2630 <check_add_float+0x1520>
jmp    264b <check_add_float+0x153b>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x3c4(%rbp)
ff
movss  %xmm0,-0x3c0(%rbp)
ff
jmp    266b <check_add_float+0x155b>
xorps  %xmm1,%xmm1
movss  0x49aa(%rip),%xmm0
movss  %xmm1,-0x3c4(%rbp)
ff
movss  %xmm0,-0x3c0(%rbp)
ff
jmp    266b <check_add_float+0x155b>
movss  -0x3c4(%rbp),%xmm1
ff
movss  -0x3c0(%rbp),%xmm0
ff
movss  %xmm1,-0x3cc(%rbp)
ff
movss  %xmm0,-0x3c8(%rbp)
ff
jmp    26ff <check_add_float+0x15ef>
mov    $0x1,%al
test   $0x1,%al
jne    269f <check_add_float+0x158f>
jmp    26bf <check_add_float+0x15af>
movss  0x4959(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x3d4(%rbp)
ff
movss  %xmm0,-0x3d0(%rbp)
ff
jmp    26df <check_add_float+0x15cf>
movss  0x4939(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x3d4(%rbp)
ff
movss  %xmm0,-0x3d0(%rbp)
ff
jmp    26df <check_add_float+0x15cf>
movss  -0x3d4(%rbp),%xmm1
ff
movss  -0x3d0(%rbp),%xmm0
ff
movss  %xmm1,-0x3cc(%rbp)
ff
movss  %xmm0,-0x3c8(%rbp)
ff
movss  -0x3cc(%rbp),%xmm1
ff
movss  -0x3c8(%rbp),%xmm0
ff
movss  %xmm1,-0xd0(%rbp)
ff
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xd0(%rbp),%xmm1
ff
movss  -0xcc(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    27ce <check_add_float+0x16be>
movss  -0xd0(%rbp),%xmm0
ff
movaps 0x48bc(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x48c1(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4889(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    27ce <check_add_float+0x16be>
jp     27ce <check_add_float+0x16be>
movss  -0xcc(%rbp),%xmm0
ff
movaps 0x4882(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4887(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x484f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    27ce <check_add_float+0x16be>
jp     27ce <check_add_float+0x16be>
jmp    27d3 <check_add_float+0x16c3>
call   1030 <abort@plt>
jmp    27d8 <check_add_float+0x16c8>
movss  -0xc4(%rbp),%xmm1
ff
movss  -0xd0(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0xd8(%rbp)
ff
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd8(%rbp),%xmm1
ff
movss  -0xd4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    28b3 <check_add_float+0x17a3>
movss  -0xd8(%rbp),%xmm0
ff
movaps 0x47d7(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x47dc(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x47a4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    28b3 <check_add_float+0x17a3>
jp     28b3 <check_add_float+0x17a3>
movss  -0xd4(%rbp),%xmm0
ff
movaps 0x479d(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x47a2(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x476a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    28b3 <check_add_float+0x17a3>
jp     28b3 <check_add_float+0x17a3>
jmp    28b8 <check_add_float+0x17a8>
call   1030 <abort@plt>
jmp    28bd <check_add_float+0x17ad>
movss  0x473b(%rip),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    $0x1,%al
test   $0x1,%al
jne    28dc <check_add_float+0x17cc>
jmp    294b <check_add_float+0x183b>
mov    $0x1,%al
test   $0x1,%al
jne    28eb <check_add_float+0x17db>
jmp    2906 <check_add_float+0x17f6>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x3dc(%rbp)
ff
movss  %xmm0,-0x3d8(%rbp)
jmp    2926 <check_add_float+0x1816>
xorps  %xmm1,%xmm1
movss  0x46ef(%rip),%xmm0
movss  %xmm1,-0x3dc(%rbp)
ff
movss  %xmm0,-0x3d8(%rbp)
ff
jmp    2926 <check_add_float+0x1816>
movss  -0x3dc(%rbp),%xmm1
ff
movss  -0x3d8(%rbp),%xmm0
ff
movss  %xmm1,-0x3e4(%rbp)
ff
movss  %xmm0,-0x3e0(%rbp)
ff
jmp    29ba <check_add_float+0x18aa>
mov    $0x1,%al
test   $0x1,%al
jne    295a <check_add_float+0x184a>
jmp    297a <check_add_float+0x186a>
movss  0x469e(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x3ec(%rbp)
ff
movss  %xmm0,-0x3e8(%rbp)
ff
jmp    299a <check_add_float+0x188a>
movss  0x467e(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x3ec(%rbp)
ff
movss  %xmm0,-0x3e8(%rbp)
ff
jmp    299a <check_add_float+0x188a>
movss  -0x3ec(%rbp),%xmm1
ff
movss  -0x3e8(%rbp),%xmm0
ff
movss  %xmm1,-0x3e4(%rbp)
ff
movss  %xmm0,-0x3e0(%rbp)
ff
movss  -0x3e4(%rbp),%xmm1
ff
movss  -0x3e0(%rbp),%xmm0
ff
movss  %xmm1,-0xe8(%rbp)
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xe8(%rbp),%xmm1
ff
movss  -0xe4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2a89 <check_add_float+0x1979>
movss  -0xe8(%rbp),%xmm0
ff
movaps 0x4601(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4606(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x45ce(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2a89 <check_add_float+0x1979>
jp     2a89 <check_add_float+0x1979>
movss  -0xe4(%rbp),%xmm0
ff
movaps 0x45c7(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x45cc(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4594(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2a89 <check_add_float+0x1979>
jp     2a89 <check_add_float+0x1979>
jmp    2a8e <check_add_float+0x197e>
call   1030 <abort@plt>
jmp    2a93 <check_add_float+0x1983>
movss  -0xdc(%rbp),%xmm1
ff
movss  -0xe8(%rbp),%xmm2
ff
movss  -0xe4(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0xf0(%rbp)
ff
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xf0(%rbp),%xmm1
ff
movss  -0xec(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2b6e <check_add_float+0x1a5e>
movss  -0xf0(%rbp),%xmm0
ff
movaps 0x451c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4521(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x44e9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2b6e <check_add_float+0x1a5e>
jp     2b6e <check_add_float+0x1a5e>
movss  -0xec(%rbp),%xmm0
ff
movaps 0x44e2(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x44e7(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x44af(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2b6e <check_add_float+0x1a5e>
jp     2b6e <check_add_float+0x1a5e>
jmp    2b73 <check_add_float+0x1a63>
call   1030 <abort@plt>
jmp    2b78 <check_add_float+0x1a68>
jmp    2b7d <check_add_float+0x1a6d>
jmp    2b82 <check_add_float+0x1a72>
movss  0x4476(%rip),%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
mov    $0x1,%al
test   $0x1,%al
jne    2ba1 <check_add_float+0x1a91>
jmp    2c10 <check_add_float+0x1b00>
xor    %eax,%eax
test   $0x1,%al
jne    2bb0 <check_add_float+0x1aa0>
jmp    2bcb <check_add_float+0x1abb>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x3f4(%rbp)
ff
movss  %xmm0,-0x3f0(%rbp)
ff
jmp    2beb <check_add_float+0x1adb>
xorps  %xmm1,%xmm1
movss  0x442a(%rip),%xmm0
movss  %xmm1,-0x3f4(%rbp)
ff
movss  %xmm0,-0x3f0(%rbp)
ff
jmp    2beb <check_add_float+0x1adb>
movss  -0x3f4(%rbp),%xmm1
ff
movss  -0x3f0(%rbp),%xmm0
ff
movss  %xmm1,-0x3fc(%rbp)
ff
movss  %xmm0,-0x3f8(%rbp)
ff
jmp    2c7f <check_add_float+0x1b6f>
xor    %eax,%eax
test   $0x1,%al
jne    2c1f <check_add_float+0x1b0f>
jmp    2c3f <check_add_float+0x1b2f>
movss  0x43d9(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x404(%rbp)
ff
movss  %xmm0,-0x400(%rbp)
ff
jmp    2c5f <check_add_float+0x1b4f>
movss  0x43b9(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x404(%rbp)
ff
movss  %xmm0,-0x400(%rbp)
ff
jmp    2c5f <check_add_float+0x1b4f>
movss  -0x404(%rbp),%xmm1
ff
movss  -0x400(%rbp),%xmm0
ff
movss  %xmm1,-0x3fc(%rbp)
ff
movss  %xmm0,-0x3f8(%rbp)
ff
movss  -0x3fc(%rbp),%xmm1
ff
movss  -0x3f8(%rbp),%xmm0
ff
movss  %xmm1,-0x100(%rbp)
ff
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x100(%rbp),%xmm1
ff
movss  -0xfc(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2d4e <check_add_float+0x1c3e>
movss  -0x100(%rbp),%xmm0
ff
movaps 0x433c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4341(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4309(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2d4e <check_add_float+0x1c3e>
jp     2d4e <check_add_float+0x1c3e>
movss  -0xfc(%rbp),%xmm0
ff
movaps 0x4302(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4307(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x42d7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2d4e <check_add_float+0x1c3e>
jp     2d4e <check_add_float+0x1c3e>
jmp    2d53 <check_add_float+0x1c43>
call   1030 <abort@plt>
jmp    2d58 <check_add_float+0x1c48>
movss  -0xf4(%rbp),%xmm1
ff
movss  -0x100(%rbp),%xmm2
ff
movss  -0xfc(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x108(%rbp)
ff
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x108(%rbp),%xmm1
ff
movss  -0x104(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2e33 <check_add_float+0x1d23>
movss  -0x108(%rbp),%xmm0
ff
movaps 0x4257(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x425c(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4224(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2e33 <check_add_float+0x1d23>
jp     2e33 <check_add_float+0x1d23>
movss  -0x104(%rbp),%xmm0
ff
movaps 0x421d(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4222(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x41f2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2e33 <check_add_float+0x1d23>
jp     2e33 <check_add_float+0x1d23>
jmp    2e38 <check_add_float+0x1d28>
call   1030 <abort@plt>
jmp    2e3d <check_add_float+0x1d2d>
movss  0x41bb(%rip),%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
mov    $0x1,%al
test   $0x1,%al
jne    2e5c <check_add_float+0x1d4c>
jmp    2ecb <check_add_float+0x1dbb>
xor    %eax,%eax
test   $0x1,%al
jne    2e6b <check_add_float+0x1d5b>
jmp    2e86 <check_add_float+0x1d76>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x40c(%rbp)
ff
movss  %xmm0,-0x408(%rbp)
ff
jmp    2ea6 <check_add_float+0x1d96>
xorps  %xmm1,%xmm1
movss  0x416f(%rip),%xmm0
movss  %xmm1,-0x40c(%rbp)
ff
movss  %xmm0,-0x408(%rbp)
ff
jmp    2ea6 <check_add_float+0x1d96>
movss  -0x40c(%rbp),%xmm1
ff
movss  -0x408(%rbp),%xmm0
ff
movss  %xmm1,-0x414(%rbp)
ff
movss  %xmm0,-0x410(%rbp)
ff
jmp    2f3a <check_add_float+0x1e2a>
xor    %eax,%eax
test   $0x1,%al
jne    2eda <check_add_float+0x1dca>
jmp    2efa <check_add_float+0x1dea>
movss  0x411e(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x41c(%rbp)
ff
movss  %xmm0,-0x418(%rbp)
ff
jmp    2f1a <check_add_float+0x1e0a>
movss  0x40fe(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x41c(%rbp)
ff
movss  %xmm0,-0x418(%rbp)
ff
jmp    2f1a <check_add_float+0x1e0a>
movss  -0x41c(%rbp),%xmm1
ff
movss  -0x418(%rbp),%xmm0
ff
movss  %xmm1,-0x414(%rbp)
ff
movss  %xmm0,-0x410(%rbp)
ff
movss  -0x414(%rbp),%xmm1
ff
movss  -0x410(%rbp),%xmm0
ff
movss  %xmm1,-0x118(%rbp)
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x118(%rbp),%xmm1
ff
movss  -0x114(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    3009 <check_add_float+0x1ef9>
movss  -0x118(%rbp),%xmm0
ff
movaps 0x4081(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x4086(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x404e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3009 <check_add_float+0x1ef9>
jp     3009 <check_add_float+0x1ef9>
movss  -0x114(%rbp),%xmm0
ff
movaps 0x4047(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x404c(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x401c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3009 <check_add_float+0x1ef9>
jp     3009 <check_add_float+0x1ef9>
jmp    300e <check_add_float+0x1efe>
call   1030 <abort@plt>
jmp    3013 <check_add_float+0x1f03>
movss  -0x10c(%rbp),%xmm1
ff
movss  -0x118(%rbp),%xmm2
ff
movss  -0x114(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x120(%rbp)
ff
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0x120(%rbp),%xmm1
ff
movss  -0x11c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    30ee <check_add_float+0x1fde>
movss  -0x120(%rbp),%xmm0
ff
movaps 0x3f9c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3fa1(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3f69(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    30ee <check_add_float+0x1fde>
jp     30ee <check_add_float+0x1fde>
movss  -0x11c(%rbp),%xmm0
ff
movaps 0x3f62(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3f67(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3f37(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    30ee <check_add_float+0x1fde>
jp     30ee <check_add_float+0x1fde>
jmp    30f3 <check_add_float+0x1fe3>
call   1030 <abort@plt>
jmp    30f8 <check_add_float+0x1fe8>
jmp    30fd <check_add_float+0x1fed>
jmp    3102 <check_add_float+0x1ff2>
movss  0x3ef6(%rip),%xmm0
movss  %xmm0,-0x124(%rbp)
ff
xor    %eax,%eax
test   $0x1,%al
jne    3121 <check_add_float+0x2011>
jmp    3190 <check_add_float+0x2080>
mov    $0x1,%al
test   $0x1,%al
jne    3130 <check_add_float+0x2020>
jmp    314b <check_add_float+0x203b>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x424(%rbp)
ff
movss  %xmm0,-0x420(%rbp)
ff
jmp    316b <check_add_float+0x205b>
xorps  %xmm1,%xmm1
movss  0x3eaa(%rip),%xmm0
movss  %xmm1,-0x424(%rbp)
ff
movss  %xmm0,-0x420(%rbp)
ff
jmp    316b <check_add_float+0x205b>
movss  -0x424(%rbp),%xmm1
ff
movss  -0x420(%rbp),%xmm0
ff
movss  %xmm1,-0x42c(%rbp)
ff
movss  %xmm0,-0x428(%rbp)
ff
jmp    31ff <check_add_float+0x20ef>
mov    $0x1,%al
test   $0x1,%al
jne    319f <check_add_float+0x208f>
jmp    31bf <check_add_float+0x20af>
movss  0x3e59(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x434(%rbp)
ff
movss  %xmm0,-0x430(%rbp)
ff
jmp    31df <check_add_float+0x20cf>
movss  0x3e39(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x434(%rbp)
ff
movss  %xmm0,-0x430(%rbp)
ff
jmp    31df <check_add_float+0x20cf>
movss  -0x434(%rbp),%xmm1
ff
movss  -0x430(%rbp),%xmm0
ff
movss  %xmm1,-0x42c(%rbp)
ff
movss  %xmm0,-0x428(%rbp)
ff
movss  -0x42c(%rbp),%xmm1
ff
movss  -0x428(%rbp),%xmm0
ff
movss  %xmm1,-0x130(%rbp)
ff
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0x130(%rbp),%xmm1
ff
movss  -0x12c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    32ce <check_add_float+0x21be>
movss  -0x130(%rbp),%xmm0
ff
movaps 0x3dbc(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3dc1(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3d91(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    32ce <check_add_float+0x21be>
jp     32ce <check_add_float+0x21be>
movss  -0x12c(%rbp),%xmm0
ff
movaps 0x3d82(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3d87(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3d4f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    32ce <check_add_float+0x21be>
jp     32ce <check_add_float+0x21be>
jmp    32d3 <check_add_float+0x21c3>
call   1030 <abort@plt>
jmp    32d8 <check_add_float+0x21c8>
movss  -0x124(%rbp),%xmm1
ff
movss  -0x130(%rbp),%xmm2
ff
movss  -0x12c(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x138(%rbp)
ff
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x138(%rbp),%xmm1
ff
movss  -0x134(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    33b3 <check_add_float+0x22a3>
movss  -0x138(%rbp),%xmm0
ff
movaps 0x3cd7(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3cdc(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3cac(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    33b3 <check_add_float+0x22a3>
jp     33b3 <check_add_float+0x22a3>
movss  -0x134(%rbp),%xmm0
ff
movaps 0x3c9d(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3ca2(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3c6a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    33b3 <check_add_float+0x22a3>
jp     33b3 <check_add_float+0x22a3>
jmp    33b8 <check_add_float+0x22a8>
call   1030 <abort@plt>
jmp    33bd <check_add_float+0x22ad>
movss  0x3c3b(%rip),%xmm0
movss  %xmm0,-0x13c(%rbp)
ff
xor    %eax,%eax
test   $0x1,%al
jne    33dc <check_add_float+0x22cc>
jmp    344b <check_add_float+0x233b>
mov    $0x1,%al
test   $0x1,%al
jne    33eb <check_add_float+0x22db>
jmp    3406 <check_add_float+0x22f6>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x43c(%rbp)
ff
movss  %xmm0,-0x438(%rbp)
jmp    3426 <check_add_float+0x2316>
xorps  %xmm1,%xmm1
movss  0x3bef(%rip),%xmm0
movss  %xmm1,-0x43c(%rbp)
ff
movss  %xmm0,-0x438(%rbp)
ff
jmp    3426 <check_add_float+0x2316>
movss  -0x43c(%rbp),%xmm1
ff
movss  -0x438(%rbp),%xmm0
ff
movss  %xmm1,-0x444(%rbp)
ff
movss  %xmm0,-0x440(%rbp)
ff
jmp    34ba <check_add_float+0x23aa>
mov    $0x1,%al
test   $0x1,%al
jne    345a <check_add_float+0x234a>
jmp    347a <check_add_float+0x236a>
movss  0x3b9e(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x44c(%rbp)
ff
movss  %xmm0,-0x448(%rbp)
ff
jmp    349a <check_add_float+0x238a>
movss  0x3b7e(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x44c(%rbp)
ff
movss  %xmm0,-0x448(%rbp)
ff
jmp    349a <check_add_float+0x238a>
movss  -0x44c(%rbp),%xmm1
ff
movss  -0x448(%rbp),%xmm0
ff
movss  %xmm1,-0x444(%rbp)
ff
movss  %xmm0,-0x440(%rbp)
ff
movss  -0x444(%rbp),%xmm1
ff
movss  -0x440(%rbp),%xmm0
ff
movss  %xmm1,-0x148(%rbp)
ff
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x148(%rbp),%xmm1
ff
movss  -0x144(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    3589 <check_add_float+0x2479>
movss  -0x148(%rbp),%xmm0
ff
movaps 0x3b01(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3b06(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3ad6(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3589 <check_add_float+0x2479>
jp     3589 <check_add_float+0x2479>
movss  -0x144(%rbp),%xmm0
ff
movaps 0x3ac7(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3acc(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3a94(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3589 <check_add_float+0x2479>
jp     3589 <check_add_float+0x2479>
jmp    358e <check_add_float+0x247e>
call   1030 <abort@plt>
jmp    3593 <check_add_float+0x2483>
movss  -0x13c(%rbp),%xmm1
ff
movss  -0x148(%rbp),%xmm2
ff
movss  -0x144(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x150(%rbp)
ff
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x150(%rbp),%xmm1
ff
movss  -0x14c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    366e <check_add_float+0x255e>
movss  -0x150(%rbp),%xmm0
ff
movaps 0x3a1c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3a21(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x39f1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    366e <check_add_float+0x255e>
jp     366e <check_add_float+0x255e>
movss  -0x14c(%rbp),%xmm0
ff
movaps 0x39e2(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x39e7(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x39af(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    366e <check_add_float+0x255e>
jp     366e <check_add_float+0x255e>
jmp    3673 <check_add_float+0x2563>
call   1030 <abort@plt>
jmp    3678 <check_add_float+0x2568>
jmp    367d <check_add_float+0x256d>
jmp    3682 <check_add_float+0x2572>
movss  0x3976(%rip),%xmm0
movss  %xmm0,-0x154(%rbp)
ff
xor    %eax,%eax
test   $0x1,%al
jne    36a1 <check_add_float+0x2591>
jmp    3710 <check_add_float+0x2600>
xor    %eax,%eax
test   $0x1,%al
jne    36b0 <check_add_float+0x25a0>
jmp    36cb <check_add_float+0x25bb>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x454(%rbp)
ff
movss  %xmm0,-0x450(%rbp)
ff
jmp    36eb <check_add_float+0x25db>
xorps  %xmm1,%xmm1
movss  0x392a(%rip),%xmm0
movss  %xmm1,-0x454(%rbp)
ff
movss  %xmm0,-0x450(%rbp)
ff
jmp    36eb <check_add_float+0x25db>
movss  -0x454(%rbp),%xmm1
ff
movss  -0x450(%rbp),%xmm0
ff
movss  %xmm1,-0x45c(%rbp)
ff
movss  %xmm0,-0x458(%rbp)
ff
jmp    377f <check_add_float+0x266f>
xor    %eax,%eax
test   $0x1,%al
jne    371f <check_add_float+0x260f>
jmp    373f <check_add_float+0x262f>
movss  0x38d9(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x464(%rbp)
ff
movss  %xmm0,-0x460(%rbp)
ff
jmp    375f <check_add_float+0x264f>
movss  0x38b9(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x464(%rbp)
ff
movss  %xmm0,-0x460(%rbp)
ff
jmp    375f <check_add_float+0x264f>
movss  -0x464(%rbp),%xmm1
ff
movss  -0x460(%rbp),%xmm0
ff
movss  %xmm1,-0x45c(%rbp)
ff
movss  %xmm0,-0x458(%rbp)
ff
movss  -0x45c(%rbp),%xmm1
ff
movss  -0x458(%rbp),%xmm0
ff
movss  %xmm1,-0x160(%rbp)
ff
movss  %xmm0,-0x15c(%rbp)
ff
movss  -0x160(%rbp),%xmm1
ff
movss  -0x15c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    384e <check_add_float+0x273e>
movss  -0x160(%rbp),%xmm0
ff
movaps 0x383c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3841(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3811(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    384e <check_add_float+0x273e>
jp     384e <check_add_float+0x273e>
movss  -0x15c(%rbp),%xmm0
ff
movaps 0x3802(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3807(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x37d7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    384e <check_add_float+0x273e>
jp     384e <check_add_float+0x273e>
jmp    3853 <check_add_float+0x2743>
call   1030 <abort@plt>
jmp    3858 <check_add_float+0x2748>
movss  -0x154(%rbp),%xmm1
ff
movss  -0x160(%rbp),%xmm2
ff
movss  -0x15c(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x168(%rbp)
ff
movss  %xmm0,-0x164(%rbp)
ff
movss  -0x168(%rbp),%xmm1
ff
movss  -0x164(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    3933 <check_add_float+0x2823>
movss  -0x168(%rbp),%xmm0
ff
movaps 0x3757(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x375c(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x372c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3933 <check_add_float+0x2823>
jp     3933 <check_add_float+0x2823>
movss  -0x164(%rbp),%xmm0
ff
movaps 0x371d(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3722(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x36f2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3933 <check_add_float+0x2823>
jp     3933 <check_add_float+0x2823>
jmp    3938 <check_add_float+0x2828>
call   1030 <abort@plt>
jmp    393d <check_add_float+0x282d>
movss  0x36bb(%rip),%xmm0
movss  %xmm0,-0x16c(%rbp)
ff
xor    %eax,%eax
test   $0x1,%al
jne    395c <check_add_float+0x284c>
jmp    39cb <check_add_float+0x28bb>
xor    %eax,%eax
test   $0x1,%al
jne    396b <check_add_float+0x285b>
jmp    3986 <check_add_float+0x2876>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x46c(%rbp)
ff
movss  %xmm0,-0x468(%rbp)
ff
jmp    39a6 <check_add_float+0x2896>
xorps  %xmm1,%xmm1
movss  0x366f(%rip),%xmm0
movss  %xmm1,-0x46c(%rbp)
ff
movss  %xmm0,-0x468(%rbp)
ff
jmp    39a6 <check_add_float+0x2896>
movss  -0x46c(%rbp),%xmm1
ff
movss  -0x468(%rbp),%xmm0
ff
movss  %xmm1,-0x474(%rbp)
ff
movss  %xmm0,-0x470(%rbp)
ff
jmp    3a3a <check_add_float+0x292a>
xor    %eax,%eax
test   $0x1,%al
jne    39da <check_add_float+0x28ca>
jmp    39fa <check_add_float+0x28ea>
movss  0x361e(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x47c(%rbp)
ff
movss  %xmm0,-0x478(%rbp)
ff
jmp    3a1a <check_add_float+0x290a>
movss  0x35fe(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x47c(%rbp)
ff
movss  %xmm0,-0x478(%rbp)
ff
jmp    3a1a <check_add_float+0x290a>
movss  -0x47c(%rbp),%xmm1
ff
movss  -0x478(%rbp),%xmm0
ff
movss  %xmm1,-0x474(%rbp)
ff
movss  %xmm0,-0x470(%rbp)
ff
movss  -0x474(%rbp),%xmm1
ff
movss  -0x470(%rbp),%xmm0
ff
movss  %xmm1,-0x178(%rbp)
ff
movss  %xmm0,-0x174(%rbp)
ff
movss  -0x178(%rbp),%xmm1
ff
movss  -0x174(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    3b09 <check_add_float+0x29f9>
movss  -0x178(%rbp),%xmm0
ff
movaps 0x3581(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3586(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3556(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3b09 <check_add_float+0x29f9>
jp     3b09 <check_add_float+0x29f9>
movss  -0x174(%rbp),%xmm0
ff
movaps 0x3547(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x354c(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x351c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3b09 <check_add_float+0x29f9>
jp     3b09 <check_add_float+0x29f9>
jmp    3b0e <check_add_float+0x29fe>
call   1030 <abort@plt>
jmp    3b13 <check_add_float+0x2a03>
movss  -0x16c(%rbp),%xmm1
ff
movss  -0x178(%rbp),%xmm2
ff
movss  -0x174(%rbp),%xmm0
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x180(%rbp)
ff
movss  %xmm0,-0x17c(%rbp)
ff
movss  -0x180(%rbp),%xmm1
ff
movss  -0x17c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    3bee <check_add_float+0x2ade>
movss  -0x180(%rbp),%xmm0
ff
movaps 0x349c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x34a1(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3471(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3bee <check_add_float+0x2ade>
jp     3bee <check_add_float+0x2ade>
movss  -0x17c(%rbp),%xmm0
ff
movaps 0x3462(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3467(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3437(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3bee <check_add_float+0x2ade>
jp     3bee <check_add_float+0x2ade>
jmp    3bf3 <check_add_float+0x2ae3>
call   1030 <abort@plt>
jmp    3bf8 <check_add_float+0x2ae8>
jmp    3bfd <check_add_float+0x2aed>
jmp    3c02 <check_add_float+0x2af2>
mov    $0x1,%al
test   $0x1,%al
jne    3c11 <check_add_float+0x2b01>
jmp    3c80 <check_add_float+0x2b70>
mov    $0x1,%al
test   $0x1,%al
jne    3c20 <check_add_float+0x2b10>
jmp    3c3b <check_add_float+0x2b2b>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x484(%rbp)
ff
movss  %xmm0,-0x480(%rbp)
ff
jmp    3c5b <check_add_float+0x2b4b>
xorps  %xmm1,%xmm1
movss  0x33ba(%rip),%xmm0
movss  %xmm1,-0x484(%rbp)
ff
movss  %xmm0,-0x480(%rbp)
ff
jmp    3c5b <check_add_float+0x2b4b>
movss  -0x484(%rbp),%xmm1
ff
movss  -0x480(%rbp),%xmm0
ff
movss  %xmm1,-0x48c(%rbp)
ff
movss  %xmm0,-0x488(%rbp)
ff
jmp    3cef <check_add_float+0x2bdf>
mov    $0x1,%al
test   $0x1,%al
jne    3c8f <check_add_float+0x2b7f>
jmp    3caf <check_add_float+0x2b9f>
movss  0x3369(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x494(%rbp)
ff
movss  %xmm0,-0x490(%rbp)
ff
jmp    3ccf <check_add_float+0x2bbf>
movss  0x3349(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x494(%rbp)
ff
movss  %xmm0,-0x490(%rbp)
ff
jmp    3ccf <check_add_float+0x2bbf>
movss  -0x494(%rbp),%xmm1
ff
movss  -0x490(%rbp),%xmm0
ff
movss  %xmm1,-0x48c(%rbp)
ff
movss  %xmm0,-0x488(%rbp)
ff
movss  -0x48c(%rbp),%xmm1
ff
movss  -0x488(%rbp),%xmm0
ff
movss  %xmm1,-0x188(%rbp)
ff
movss  %xmm0,-0x184(%rbp)
ff
movss  -0x188(%rbp),%xmm1
ff
movss  -0x184(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    3dbe <check_add_float+0x2cae>
movss  -0x188(%rbp),%xmm0
ff
movaps 0x32cc(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x32d1(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3299(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3dbe <check_add_float+0x2cae>
jp     3dbe <check_add_float+0x2cae>
movss  -0x184(%rbp),%xmm0
ff
movaps 0x3292(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x3297(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x325f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3dbe <check_add_float+0x2cae>
jp     3dbe <check_add_float+0x2cae>
jmp    3dc3 <check_add_float+0x2cb3>
call   1030 <abort@plt>
jmp    3dc8 <check_add_float+0x2cb8>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x194(%rbp)
ff
movss  -0x188(%rbp),%xmm1
ff
movss  -0x184(%rbp),%xmm0
ff
addss  -0x194(%rbp),%xmm1
ff
movss  %xmm1,-0x190(%rbp)
ff
movss  %xmm0,-0x18c(%rbp)
ff
movss  -0x190(%rbp),%xmm1
ff
movss  -0x18c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    3eaa <check_add_float+0x2d9a>
movss  -0x190(%rbp),%xmm0
ff
movaps 0x31e0(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x31e5(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x31ad(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3eaa <check_add_float+0x2d9a>
jp     3eaa <check_add_float+0x2d9a>
movss  -0x18c(%rbp),%xmm0
ff
movaps 0x31a6(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x31ab(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3173(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    3eaa <check_add_float+0x2d9a>
jp     3eaa <check_add_float+0x2d9a>
jmp    3eaf <check_add_float+0x2d9f>
call   1030 <abort@plt>
jmp    3eb4 <check_add_float+0x2da4>
mov    $0x1,%al
test   $0x1,%al
jne    3ec3 <check_add_float+0x2db3>
jmp    3f32 <check_add_float+0x2e22>
mov    $0x1,%al
test   $0x1,%al
jne    3ed2 <check_add_float+0x2dc2>
jmp    3eed <check_add_float+0x2ddd>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x49c(%rbp)
ff
movss  %xmm0,-0x498(%rbp)
ff
jmp    3f0d <check_add_float+0x2dfd>
xorps  %xmm1,%xmm1
movss  0x3108(%rip),%xmm0
movss  %xmm1,-0x49c(%rbp)
ff
movss  %xmm0,-0x498(%rbp)
ff
jmp    3f0d <check_add_float+0x2dfd>
movss  -0x49c(%rbp),%xmm1
ff
movss  -0x498(%rbp),%xmm0
ff
movss  %xmm1,-0x4a4(%rbp)
ff
movss  %xmm0,-0x4a0(%rbp)
ff
jmp    3fa1 <check_add_float+0x2e91>
mov    $0x1,%al
test   $0x1,%al
jne    3f41 <check_add_float+0x2e31>
jmp    3f61 <check_add_float+0x2e51>
movss  0x30b7(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x4ac(%rbp)
ff
movss  %xmm0,-0x4a8(%rbp)
ff
jmp    3f81 <check_add_float+0x2e71>
movss  0x3097(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x4ac(%rbp)
ff
movss  %xmm0,-0x4a8(%rbp)
ff
jmp    3f81 <check_add_float+0x2e71>
movss  -0x4ac(%rbp),%xmm1
ff
movss  -0x4a8(%rbp),%xmm0
ff
movss  %xmm1,-0x4a4(%rbp)
ff
movss  %xmm0,-0x4a0(%rbp)
ff
movss  -0x4a4(%rbp),%xmm1
ff
movss  -0x4a0(%rbp),%xmm0
ff
movss  %xmm1,-0x1a0(%rbp)
ff
movss  %xmm0,-0x19c(%rbp)
ff
movss  -0x1a0(%rbp),%xmm1
ff
movss  -0x19c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4070 <check_add_float+0x2f60>
movss  -0x1a0(%rbp),%xmm0
ff
movaps 0x301a(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x301f(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2fe7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4070 <check_add_float+0x2f60>
jp     4070 <check_add_float+0x2f60>
movss  -0x19c(%rbp),%xmm0
ff
movaps 0x2fe0(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2fe5(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2fad(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4070 <check_add_float+0x2f60>
jp     4070 <check_add_float+0x2f60>
jmp    4075 <check_add_float+0x2f65>
call   1030 <abort@plt>
jmp    407a <check_add_float+0x2f6a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1ac(%rbp)
ff
movss  -0x1a0(%rbp),%xmm1
ff
movss  -0x19c(%rbp),%xmm0
ff
movss  -0x1ac(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x1a8(%rbp)
ff
movss  %xmm0,-0x1a4(%rbp)
ff
movss  -0x1a8(%rbp),%xmm1
ff
movss  -0x1a4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4160 <check_add_float+0x3050>
movss  -0x1a8(%rbp),%xmm0
ff
movaps 0x2f2a(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2f2f(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2ef7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4160 <check_add_float+0x3050>
jp     4160 <check_add_float+0x3050>
movss  -0x1a4(%rbp),%xmm0
ff
movaps 0x2ef0(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2ef5(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2ebd(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4160 <check_add_float+0x3050>
jp     4160 <check_add_float+0x3050>
jmp    4165 <check_add_float+0x3055>
call   1030 <abort@plt>
jmp    416a <check_add_float+0x305a>
jmp    416f <check_add_float+0x305f>
jmp    4174 <check_add_float+0x3064>
mov    $0x1,%al
test   $0x1,%al
jne    4183 <check_add_float+0x3073>
jmp    41f2 <check_add_float+0x30e2>
mov    $0x1,%al
test   $0x1,%al
jne    4192 <check_add_float+0x3082>
jmp    41ad <check_add_float+0x309d>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x4b4(%rbp)
ff
movss  %xmm0,-0x4b0(%rbp)
ff
jmp    41cd <check_add_float+0x30bd>
xorps  %xmm1,%xmm1
movss  0x2e48(%rip),%xmm0
movss  %xmm1,-0x4b4(%rbp)
ff
movss  %xmm0,-0x4b0(%rbp)
ff
jmp    41cd <check_add_float+0x30bd>
movss  -0x4b4(%rbp),%xmm1
ff
movss  -0x4b0(%rbp),%xmm0
ff
movss  %xmm1,-0x4bc(%rbp)
ff
movss  %xmm0,-0x4b8(%rbp)
ff
jmp    4261 <check_add_float+0x3151>
mov    $0x1,%al
test   $0x1,%al
jne    4201 <check_add_float+0x30f1>
jmp    4221 <check_add_float+0x3111>
movss  0x2df7(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x4c4(%rbp)
ff
movss  %xmm0,-0x4c0(%rbp)
ff
jmp    4241 <check_add_float+0x3131>
movss  0x2dd7(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x4c4(%rbp)
ff
movss  %xmm0,-0x4c0(%rbp)
ff
jmp    4241 <check_add_float+0x3131>
movss  -0x4c4(%rbp),%xmm1
ff
movss  -0x4c0(%rbp),%xmm0
ff
movss  %xmm1,-0x4bc(%rbp)
ff
movss  %xmm0,-0x4b8(%rbp)
ff
movss  -0x4bc(%rbp),%xmm1
ff
movss  -0x4b8(%rbp),%xmm0
ff
movss  %xmm1,-0x1b8(%rbp)
ff
movss  %xmm0,-0x1b4(%rbp)
ff
movss  -0x1b8(%rbp),%xmm1
ff
movss  -0x1b4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4330 <check_add_float+0x3220>
movss  -0x1b8(%rbp),%xmm0
ff
movaps 0x2d5a(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2d5f(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2d27(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4330 <check_add_float+0x3220>
jp     4330 <check_add_float+0x3220>
movss  -0x1b4(%rbp),%xmm0
ff
movaps 0x2d20(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2d25(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2ced(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4330 <check_add_float+0x3220>
jp     4330 <check_add_float+0x3220>
jmp    4335 <check_add_float+0x3225>
call   1030 <abort@plt>
jmp    433a <check_add_float+0x322a>
movss  0x2cbe(%rip),%xmm0
movss  %xmm0,-0x1c4(%rbp)
ff
movss  -0x1b8(%rbp),%xmm1
ff
movss  -0x1b4(%rbp),%xmm0
ff
addss  -0x1c4(%rbp),%xmm1
ff
movss  %xmm1,-0x1c0(%rbp)
ff
movss  %xmm0,-0x1bc(%rbp)
ff
movss  -0x1c0(%rbp),%xmm1
ff
movss  -0x1bc(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4421 <check_add_float+0x3311>
movss  -0x1c0(%rbp),%xmm0
ff
movaps 0x2c69(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2c6e(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2c36(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4421 <check_add_float+0x3311>
jp     4421 <check_add_float+0x3311>
movss  -0x1bc(%rbp),%xmm0
ff
movaps 0x2c2f(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2c34(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2bfc(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4421 <check_add_float+0x3311>
jp     4421 <check_add_float+0x3311>
jmp    4426 <check_add_float+0x3316>
call   1030 <abort@plt>
jmp    442b <check_add_float+0x331b>
mov    $0x1,%al
test   $0x1,%al
jne    443a <check_add_float+0x332a>
jmp    44a9 <check_add_float+0x3399>
mov    $0x1,%al
test   $0x1,%al
jne    4449 <check_add_float+0x3339>
jmp    4464 <check_add_float+0x3354>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x4cc(%rbp)
ff
movss  %xmm0,-0x4c8(%rbp)
ff
jmp    4484 <check_add_float+0x3374>
xorps  %xmm1,%xmm1
movss  0x2b91(%rip),%xmm0
movss  %xmm1,-0x4cc(%rbp)
ff
movss  %xmm0,-0x4c8(%rbp)
ff
jmp    4484 <check_add_float+0x3374>
movss  -0x4cc(%rbp),%xmm1
ff
movss  -0x4c8(%rbp),%xmm0
ff
movss  %xmm1,-0x4d4(%rbp)
ff
movss  %xmm0,-0x4d0(%rbp)
ff
jmp    4518 <check_add_float+0x3408>
mov    $0x1,%al
test   $0x1,%al
jne    44b8 <check_add_float+0x33a8>
jmp    44d8 <check_add_float+0x33c8>
movss  0x2b40(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x4dc(%rbp)
ff
movss  %xmm0,-0x4d8(%rbp)
ff
jmp    44f8 <check_add_float+0x33e8>
movss  0x2b20(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x4dc(%rbp)
ff
movss  %xmm0,-0x4d8(%rbp)
ff
jmp    44f8 <check_add_float+0x33e8>
movss  -0x4dc(%rbp),%xmm1
ff
movss  -0x4d8(%rbp),%xmm0
ff
movss  %xmm1,-0x4d4(%rbp)
ff
movss  %xmm0,-0x4d0(%rbp)
ff
movss  -0x4d4(%rbp),%xmm1
ff
movss  -0x4d0(%rbp),%xmm0
ff
movss  %xmm1,-0x1d0(%rbp)
ff
movss  %xmm0,-0x1cc(%rbp)
ff
movss  -0x1d0(%rbp),%xmm1
ff
movss  -0x1cc(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    45e7 <check_add_float+0x34d7>
movss  -0x1d0(%rbp),%xmm0
ff
movaps 0x2aa3(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2aa8(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2a70(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    45e7 <check_add_float+0x34d7>
jp     45e7 <check_add_float+0x34d7>
movss  -0x1cc(%rbp),%xmm0
ff
movaps 0x2a69(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2a6e(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2a36(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    45e7 <check_add_float+0x34d7>
jp     45e7 <check_add_float+0x34d7>
jmp    45ec <check_add_float+0x34dc>
call   1030 <abort@plt>
jmp    45f1 <check_add_float+0x34e1>
movss  0x2a07(%rip),%xmm0
movss  %xmm0,-0x1dc(%rbp)
movss  -0x1d0(%rbp),%xmm1
ff
movss  -0x1cc(%rbp),%xmm0
ff
movss  -0x1dc(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x1d8(%rbp)
ff
movss  %xmm0,-0x1d4(%rbp)
ff
movss  -0x1d8(%rbp),%xmm1
ff
movss  -0x1d4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    46dc <check_add_float+0x35cc>
movss  -0x1d8(%rbp),%xmm0
ff
movaps 0x29ae(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x29b3(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x297b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    46dc <check_add_float+0x35cc>
jp     46dc <check_add_float+0x35cc>
movss  -0x1d4(%rbp),%xmm0
ff
movaps 0x2974(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2979(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2941(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    46dc <check_add_float+0x35cc>
jp     46dc <check_add_float+0x35cc>
jmp    46e1 <check_add_float+0x35d1>
call   1030 <abort@plt>
jmp    46e6 <check_add_float+0x35d6>
jmp    46eb <check_add_float+0x35db>
jmp    46f0 <check_add_float+0x35e0>
mov    $0x1,%al
test   $0x1,%al
jne    46ff <check_add_float+0x35ef>
jmp    476e <check_add_float+0x365e>
xor    %eax,%eax
test   $0x1,%al
jne    470e <check_add_float+0x35fe>
jmp    4729 <check_add_float+0x3619>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x4e4(%rbp)
ff
movss  %xmm0,-0x4e0(%rbp)
ff
jmp    4749 <check_add_float+0x3639>
xorps  %xmm1,%xmm1
movss  0x28cc(%rip),%xmm0
movss  %xmm1,-0x4e4(%rbp)
ff
movss  %xmm0,-0x4e0(%rbp)
ff
jmp    4749 <check_add_float+0x3639>
movss  -0x4e4(%rbp),%xmm1
ff
movss  -0x4e0(%rbp),%xmm0
ff
movss  %xmm1,-0x4ec(%rbp)
ff
movss  %xmm0,-0x4e8(%rbp)
ff
jmp    47dd <check_add_float+0x36cd>
xor    %eax,%eax
test   $0x1,%al
jne    477d <check_add_float+0x366d>
jmp    479d <check_add_float+0x368d>
movss  0x287b(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x4f4(%rbp)
ff
movss  %xmm0,-0x4f0(%rbp)
ff
jmp    47bd <check_add_float+0x36ad>
movss  0x285b(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x4f4(%rbp)
ff
movss  %xmm0,-0x4f0(%rbp)
ff
jmp    47bd <check_add_float+0x36ad>
movss  -0x4f4(%rbp),%xmm1
ff
movss  -0x4f0(%rbp),%xmm0
ff
movss  %xmm1,-0x4ec(%rbp)
ff
movss  %xmm0,-0x4e8(%rbp)
ff
movss  -0x4ec(%rbp),%xmm1
ff
movss  -0x4e8(%rbp),%xmm0
ff
movss  %xmm1,-0x1e8(%rbp)
ff
movss  %xmm0,-0x1e4(%rbp)
ff
movss  -0x1e8(%rbp),%xmm1
ff
movss  -0x1e4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    48ac <check_add_float+0x379c>
movss  -0x1e8(%rbp),%xmm0
ff
movaps 0x27de(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x27e3(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x27ab(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    48ac <check_add_float+0x379c>
jp     48ac <check_add_float+0x379c>
movss  -0x1e4(%rbp),%xmm0
ff
movaps 0x27a4(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x27a9(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2779(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    48ac <check_add_float+0x379c>
jp     48ac <check_add_float+0x379c>
jmp    48b1 <check_add_float+0x37a1>
call   1030 <abort@plt>
jmp    48b6 <check_add_float+0x37a6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1f4(%rbp)
ff
movss  -0x1e8(%rbp),%xmm1
ff
movss  -0x1e4(%rbp),%xmm0
ff
addss  -0x1f4(%rbp),%xmm1
ff
movss  %xmm1,-0x1f0(%rbp)
ff
movss  %xmm0,-0x1ec(%rbp)
ff
movss  -0x1f0(%rbp),%xmm1
ff
movss  -0x1ec(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4998 <check_add_float+0x3888>
movss  -0x1f0(%rbp),%xmm0
ff
movaps 0x26f2(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x26f7(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x26bf(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4998 <check_add_float+0x3888>
jp     4998 <check_add_float+0x3888>
movss  -0x1ec(%rbp),%xmm0
ff
movaps 0x26b8(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x26bd(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x268d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4998 <check_add_float+0x3888>
jp     4998 <check_add_float+0x3888>
jmp    499d <check_add_float+0x388d>
call   1030 <abort@plt>
jmp    49a2 <check_add_float+0x3892>
mov    $0x1,%al
test   $0x1,%al
jne    49b1 <check_add_float+0x38a1>
jmp    4a20 <check_add_float+0x3910>
xor    %eax,%eax
test   $0x1,%al
jne    49c0 <check_add_float+0x38b0>
jmp    49db <check_add_float+0x38cb>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x4fc(%rbp)
ff
movss  %xmm0,-0x4f8(%rbp)
ff
jmp    49fb <check_add_float+0x38eb>
xorps  %xmm1,%xmm1
movss  0x261a(%rip),%xmm0
movss  %xmm1,-0x4fc(%rbp)
ff
movss  %xmm0,-0x4f8(%rbp)
ff
jmp    49fb <check_add_float+0x38eb>
movss  -0x4fc(%rbp),%xmm1
ff
movss  -0x4f8(%rbp),%xmm0
ff
movss  %xmm1,-0x504(%rbp)
ff
movss  %xmm0,-0x500(%rbp)
ff
jmp    4a8f <check_add_float+0x397f>
xor    %eax,%eax
test   $0x1,%al
jne    4a2f <check_add_float+0x391f>
jmp    4a4f <check_add_float+0x393f>
movss  0x25c9(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x50c(%rbp)
ff
movss  %xmm0,-0x508(%rbp)
ff
jmp    4a6f <check_add_float+0x395f>
movss  0x25a9(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x50c(%rbp)
ff
movss  %xmm0,-0x508(%rbp)
ff
jmp    4a6f <check_add_float+0x395f>
movss  -0x50c(%rbp),%xmm1
ff
movss  -0x508(%rbp),%xmm0
ff
movss  %xmm1,-0x504(%rbp)
ff
movss  %xmm0,-0x500(%rbp)
ff
movss  -0x504(%rbp),%xmm1
ff
movss  -0x500(%rbp),%xmm0
ff
movss  %xmm1,-0x200(%rbp)
ff
movss  %xmm0,-0x1fc(%rbp)
ff
movss  -0x200(%rbp),%xmm1
ff
movss  -0x1fc(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4b5e <check_add_float+0x3a4e>
movss  -0x200(%rbp),%xmm0
ff
movaps 0x252c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2531(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x24f9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4b5e <check_add_float+0x3a4e>
jp     4b5e <check_add_float+0x3a4e>
movss  -0x1fc(%rbp),%xmm0
ff
movaps 0x24f2(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x24f7(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x24c7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4b5e <check_add_float+0x3a4e>
jp     4b5e <check_add_float+0x3a4e>
jmp    4b63 <check_add_float+0x3a53>
call   1030 <abort@plt>
jmp    4b68 <check_add_float+0x3a58>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x20c(%rbp)
ff
movss  -0x200(%rbp),%xmm1
ff
movss  -0x1fc(%rbp),%xmm0
ff
movss  -0x20c(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x208(%rbp)
ff
movss  %xmm0,-0x204(%rbp)
ff
movss  -0x208(%rbp),%xmm1
ff
movss  -0x204(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4c4e <check_add_float+0x3b3e>
movss  -0x208(%rbp),%xmm0
ff
movaps 0x243c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2441(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2409(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4c4e <check_add_float+0x3b3e>
jp     4c4e <check_add_float+0x3b3e>
movss  -0x204(%rbp),%xmm0
ff
movaps 0x2402(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2407(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x23d7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4c4e <check_add_float+0x3b3e>
jp     4c4e <check_add_float+0x3b3e>
jmp    4c53 <check_add_float+0x3b43>
call   1030 <abort@plt>
jmp    4c58 <check_add_float+0x3b48>
jmp    4c5d <check_add_float+0x3b4d>
jmp    4c62 <check_add_float+0x3b52>
mov    $0x1,%al
test   $0x1,%al
jne    4c71 <check_add_float+0x3b61>
jmp    4ce0 <check_add_float+0x3bd0>
xor    %eax,%eax
test   $0x1,%al
jne    4c80 <check_add_float+0x3b70>
jmp    4c9b <check_add_float+0x3b8b>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x514(%rbp)
ff
movss  %xmm0,-0x510(%rbp)
ff
jmp    4cbb <check_add_float+0x3bab>
xorps  %xmm1,%xmm1
movss  0x235a(%rip),%xmm0
movss  %xmm1,-0x514(%rbp)
ff
movss  %xmm0,-0x510(%rbp)
ff
jmp    4cbb <check_add_float+0x3bab>
movss  -0x514(%rbp),%xmm1
ff
movss  -0x510(%rbp),%xmm0
ff
movss  %xmm1,-0x51c(%rbp)
ff
movss  %xmm0,-0x518(%rbp)
ff
jmp    4d4f <check_add_float+0x3c3f>
xor    %eax,%eax
test   $0x1,%al
jne    4cef <check_add_float+0x3bdf>
jmp    4d0f <check_add_float+0x3bff>
movss  0x2309(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x524(%rbp)
ff
movss  %xmm0,-0x520(%rbp)
ff
jmp    4d2f <check_add_float+0x3c1f>
movss  0x22e9(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x524(%rbp)
ff
movss  %xmm0,-0x520(%rbp)
ff
jmp    4d2f <check_add_float+0x3c1f>
movss  -0x524(%rbp),%xmm1
ff
movss  -0x520(%rbp),%xmm0
ff
movss  %xmm1,-0x51c(%rbp)
ff
movss  %xmm0,-0x518(%rbp)
ff
movss  -0x51c(%rbp),%xmm1
ff
movss  -0x518(%rbp),%xmm0
ff
movss  %xmm1,-0x218(%rbp)
ff
movss  %xmm0,-0x214(%rbp)
ff
movss  -0x218(%rbp),%xmm1
ff
movss  -0x214(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4e1e <check_add_float+0x3d0e>
movss  -0x218(%rbp),%xmm0
ff
movaps 0x226c(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2271(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2239(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4e1e <check_add_float+0x3d0e>
jp     4e1e <check_add_float+0x3d0e>
movss  -0x214(%rbp),%xmm0
ff
movaps 0x2232(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2237(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2207(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4e1e <check_add_float+0x3d0e>
jp     4e1e <check_add_float+0x3d0e>
jmp    4e23 <check_add_float+0x3d13>
call   1030 <abort@plt>
jmp    4e28 <check_add_float+0x3d18>
movss  0x21d0(%rip),%xmm0
movss  %xmm0,-0x224(%rbp)
ff
movss  -0x218(%rbp),%xmm1
ff
movss  -0x214(%rbp),%xmm0
ff
addss  -0x224(%rbp),%xmm1
ff
movss  %xmm1,-0x220(%rbp)
ff
movss  %xmm0,-0x21c(%rbp)
ff
movss  -0x220(%rbp),%xmm1
ff
movss  -0x21c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    4f0f <check_add_float+0x3dff>
movss  -0x220(%rbp),%xmm0
ff
movaps 0x217b(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2180(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2148(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4f0f <check_add_float+0x3dff>
jp     4f0f <check_add_float+0x3dff>
movss  -0x21c(%rbp),%xmm0
ff
movaps 0x2141(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x2146(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2116(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    4f0f <check_add_float+0x3dff>
jp     4f0f <check_add_float+0x3dff>
jmp    4f14 <check_add_float+0x3e04>
call   1030 <abort@plt>
jmp    4f19 <check_add_float+0x3e09>
mov    $0x1,%al
test   $0x1,%al
jne    4f28 <check_add_float+0x3e18>
jmp    4f97 <check_add_float+0x3e87>
xor    %eax,%eax
test   $0x1,%al
jne    4f37 <check_add_float+0x3e27>
jmp    4f52 <check_add_float+0x3e42>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x52c(%rbp)
ff
movss  %xmm0,-0x528(%rbp)
ff
jmp    4f72 <check_add_float+0x3e62>
xorps  %xmm1,%xmm1
movss  0x20a3(%rip),%xmm0
movss  %xmm1,-0x52c(%rbp)
ff
movss  %xmm0,-0x528(%rbp)
ff
jmp    4f72 <check_add_float+0x3e62>
movss  -0x52c(%rbp),%xmm1
ff
movss  -0x528(%rbp),%xmm0
ff
movss  %xmm1,-0x534(%rbp)
ff
movss  %xmm0,-0x530(%rbp)
ff
jmp    5006 <check_add_float+0x3ef6>
xor    %eax,%eax
test   $0x1,%al
jne    4fa6 <check_add_float+0x3e96>
jmp    4fc6 <check_add_float+0x3eb6>
movss  0x2052(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x53c(%rbp)
ff
movss  %xmm0,-0x538(%rbp)
ff
jmp    4fe6 <check_add_float+0x3ed6>
movss  0x2032(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x53c(%rbp)
ff
movss  %xmm0,-0x538(%rbp)
ff
jmp    4fe6 <check_add_float+0x3ed6>
movss  -0x53c(%rbp),%xmm1
ff
movss  -0x538(%rbp),%xmm0
ff
movss  %xmm1,-0x534(%rbp)
ff
movss  %xmm0,-0x530(%rbp)
movss  -0x534(%rbp),%xmm1
movss  -0x530(%rbp),%xmm0
ff
movss  %xmm1,-0x230(%rbp)
ff
movss  %xmm0,-0x22c(%rbp)
ff
movss  -0x230(%rbp),%xmm1
ff
movss  -0x22c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    50d5 <check_add_float+0x3fc5>
movss  -0x230(%rbp),%xmm0
ff
movaps 0x1fb5(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1fba(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1f82(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    50d5 <check_add_float+0x3fc5>
jp     50d5 <check_add_float+0x3fc5>
movss  -0x22c(%rbp),%xmm0
ff
movaps 0x1f7b(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1f80(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1f50(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    50d5 <check_add_float+0x3fc5>
jp     50d5 <check_add_float+0x3fc5>
jmp    50da <check_add_float+0x3fca>
call   1030 <abort@plt>
jmp    50df <check_add_float+0x3fcf>
movss  0x1f19(%rip),%xmm0
movss  %xmm0,-0x23c(%rbp)
ff
movss  -0x230(%rbp),%xmm1
ff
movss  -0x22c(%rbp),%xmm0
ff
movss  -0x23c(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x238(%rbp)
ff
movss  %xmm0,-0x234(%rbp)
ff
movss  -0x238(%rbp),%xmm1
ff
movss  -0x234(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    51ca <check_add_float+0x40ba>
movss  -0x238(%rbp),%xmm0
ff
movaps 0x1ec0(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1ec5(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e8d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    51ca <check_add_float+0x40ba>
jp     51ca <check_add_float+0x40ba>
movss  -0x234(%rbp),%xmm0
ff
movaps 0x1e86(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1e8b(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e5b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    51ca <check_add_float+0x40ba>
jp     51ca <check_add_float+0x40ba>
jmp    51cf <check_add_float+0x40bf>
call   1030 <abort@plt>
jmp    51d4 <check_add_float+0x40c4>
jmp    51d9 <check_add_float+0x40c9>
jmp    51de <check_add_float+0x40ce>
xor    %eax,%eax
test   $0x1,%al
jne    51ed <check_add_float+0x40dd>
jmp    525c <check_add_float+0x414c>
mov    $0x1,%al
test   $0x1,%al
jne    51fc <check_add_float+0x40ec>
jmp    5217 <check_add_float+0x4107>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x544(%rbp)
ff
movss  %xmm0,-0x540(%rbp)
ff
jmp    5237 <check_add_float+0x4127>
xorps  %xmm1,%xmm1
movss  0x1dde(%rip),%xmm0
movss  %xmm1,-0x544(%rbp)
ff
movss  %xmm0,-0x540(%rbp)
ff
jmp    5237 <check_add_float+0x4127>
movss  -0x544(%rbp),%xmm1
ff
movss  -0x540(%rbp),%xmm0
ff
movss  %xmm1,-0x54c(%rbp)
ff
movss  %xmm0,-0x548(%rbp)
ff
jmp    52cb <check_add_float+0x41bb>
mov    $0x1,%al
test   $0x1,%al
jne    526b <check_add_float+0x415b>
jmp    528b <check_add_float+0x417b>
movss  0x1d8d(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x554(%rbp)
ff
movss  %xmm0,-0x550(%rbp)
ff
jmp    52ab <check_add_float+0x419b>
movss  0x1d6d(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x554(%rbp)
ff
movss  %xmm0,-0x550(%rbp)
ff
jmp    52ab <check_add_float+0x419b>
movss  -0x554(%rbp),%xmm1
ff
movss  -0x550(%rbp),%xmm0
ff
movss  %xmm1,-0x54c(%rbp)
ff
movss  %xmm0,-0x548(%rbp)
ff
movss  -0x54c(%rbp),%xmm1
ff
movss  -0x548(%rbp),%xmm0
ff
movss  %xmm1,-0x248(%rbp)
ff
movss  %xmm0,-0x244(%rbp)
ff
movss  -0x248(%rbp),%xmm1
ff
movss  -0x244(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    539a <check_add_float+0x428a>
movss  -0x248(%rbp),%xmm0
ff
movaps 0x1cf0(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1cf5(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1cc5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    539a <check_add_float+0x428a>
jp     539a <check_add_float+0x428a>
movss  -0x244(%rbp),%xmm0
ff
movaps 0x1cb6(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1cbb(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c83(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    539a <check_add_float+0x428a>
jp     539a <check_add_float+0x428a>
jmp    539f <check_add_float+0x428f>
call   1030 <abort@plt>
jmp    53a4 <check_add_float+0x4294>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x254(%rbp)
ff
movss  -0x248(%rbp),%xmm1
ff
movss  -0x244(%rbp),%xmm0
ff
addss  -0x254(%rbp),%xmm1
ff
movss  %xmm1,-0x250(%rbp)
ff
movss  %xmm0,-0x24c(%rbp)
ff
movss  -0x250(%rbp),%xmm1
ff
movss  -0x24c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    5486 <check_add_float+0x4376>
movss  -0x250(%rbp),%xmm0
ff
movaps 0x1c04(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1c09(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1bd1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5486 <check_add_float+0x4376>
jp     5486 <check_add_float+0x4376>
movss  -0x24c(%rbp),%xmm0
ff
movaps 0x1bca(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1bcf(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1b97(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5486 <check_add_float+0x4376>
jp     5486 <check_add_float+0x4376>
jmp    548b <check_add_float+0x437b>
call   1030 <abort@plt>
jmp    5490 <check_add_float+0x4380>
xor    %eax,%eax
test   $0x1,%al
jne    549f <check_add_float+0x438f>
jmp    550e <check_add_float+0x43fe>
mov    $0x1,%al
test   $0x1,%al
jne    54ae <check_add_float+0x439e>
jmp    54c9 <check_add_float+0x43b9>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x55c(%rbp)
ff
movss  %xmm0,-0x558(%rbp)
ff
jmp    54e9 <check_add_float+0x43d9>
xorps  %xmm1,%xmm1
movss  0x1b2c(%rip),%xmm0
movss  %xmm1,-0x55c(%rbp)
ff
movss  %xmm0,-0x558(%rbp)
ff
jmp    54e9 <check_add_float+0x43d9>
movss  -0x55c(%rbp),%xmm1
ff
movss  -0x558(%rbp),%xmm0
ff
movss  %xmm1,-0x564(%rbp)
movss  %xmm0,-0x560(%rbp)
ff
jmp    557d <check_add_float+0x446d>
mov    $0x1,%al
test   $0x1,%al
jne    551d <check_add_float+0x440d>
jmp    553d <check_add_float+0x442d>
movss  0x1adb(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x56c(%rbp)
ff
movss  %xmm0,-0x568(%rbp)
ff
jmp    555d <check_add_float+0x444d>
movss  0x1abb(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x56c(%rbp)
ff
movss  %xmm0,-0x568(%rbp)
ff
jmp    555d <check_add_float+0x444d>
movss  -0x56c(%rbp),%xmm1
ff
movss  -0x568(%rbp),%xmm0
ff
movss  %xmm1,-0x564(%rbp)
ff
movss  %xmm0,-0x560(%rbp)
ff
movss  -0x564(%rbp),%xmm1
ff
movss  -0x560(%rbp),%xmm0
ff
movss  %xmm1,-0x260(%rbp)
ff
movss  %xmm0,-0x25c(%rbp)
ff
movss  -0x260(%rbp),%xmm1
ff
movss  -0x25c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    564c <check_add_float+0x453c>
movss  -0x260(%rbp),%xmm0
ff
movaps 0x1a3e(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1a43(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1a13(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    564c <check_add_float+0x453c>
jp     564c <check_add_float+0x453c>
movss  -0x25c(%rbp),%xmm0
ff
movaps 0x1a04(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1a09(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x19d1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    564c <check_add_float+0x453c>
jp     564c <check_add_float+0x453c>
jmp    5651 <check_add_float+0x4541>
call   1030 <abort@plt>
jmp    5656 <check_add_float+0x4546>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x26c(%rbp)
ff
movss  -0x260(%rbp),%xmm1
ff
movss  -0x25c(%rbp),%xmm0
ff
movss  -0x26c(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x268(%rbp)
ff
movss  %xmm0,-0x264(%rbp)
ff
movss  -0x268(%rbp),%xmm1
ff
movss  -0x264(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    573c <check_add_float+0x462c>
movss  -0x268(%rbp),%xmm0
ff
movaps 0x194e(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1953(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x191b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    573c <check_add_float+0x462c>
jp     573c <check_add_float+0x462c>
movss  -0x264(%rbp),%xmm0
ff
movaps 0x1914(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1919(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x18e1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    573c <check_add_float+0x462c>
jp     573c <check_add_float+0x462c>
jmp    5741 <check_add_float+0x4631>
call   1030 <abort@plt>
jmp    5746 <check_add_float+0x4636>
jmp    574b <check_add_float+0x463b>
jmp    5750 <check_add_float+0x4640>
xor    %eax,%eax
test   $0x1,%al
jne    575f <check_add_float+0x464f>
jmp    57ce <check_add_float+0x46be>
mov    $0x1,%al
test   $0x1,%al
jne    576e <check_add_float+0x465e>
jmp    5789 <check_add_float+0x4679>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x574(%rbp)
ff
movss  %xmm0,-0x570(%rbp)
ff
jmp    57a9 <check_add_float+0x4699>
xorps  %xmm1,%xmm1
movss  0x186c(%rip),%xmm0
movss  %xmm1,-0x574(%rbp)
ff
movss  %xmm0,-0x570(%rbp)
ff
jmp    57a9 <check_add_float+0x4699>
movss  -0x574(%rbp),%xmm1
ff
movss  -0x570(%rbp),%xmm0
ff
movss  %xmm1,-0x57c(%rbp)
ff
movss  %xmm0,-0x578(%rbp)
ff
jmp    583d <check_add_float+0x472d>
mov    $0x1,%al
test   $0x1,%al
jne    57dd <check_add_float+0x46cd>
jmp    57fd <check_add_float+0x46ed>
movss  0x181b(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x584(%rbp)
ff
movss  %xmm0,-0x580(%rbp)
ff
jmp    581d <check_add_float+0x470d>
movss  0x17fb(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x584(%rbp)
ff
movss  %xmm0,-0x580(%rbp)
ff
jmp    581d <check_add_float+0x470d>
movss  -0x584(%rbp),%xmm1
ff
movss  -0x580(%rbp),%xmm0
ff
movss  %xmm1,-0x57c(%rbp)
ff
movss  %xmm0,-0x578(%rbp)
ff
movss  -0x57c(%rbp),%xmm1
ff
movss  -0x578(%rbp),%xmm0
ff
movss  %xmm1,-0x278(%rbp)
ff
movss  %xmm0,-0x274(%rbp)
ff
movss  -0x278(%rbp),%xmm1
ff
movss  -0x274(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    590c <check_add_float+0x47fc>
movss  -0x278(%rbp),%xmm0
ff
movaps 0x177e(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1783(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1753(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    590c <check_add_float+0x47fc>
jp     590c <check_add_float+0x47fc>
movss  -0x274(%rbp),%xmm0
ff
movaps 0x1744(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1749(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1711(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    590c <check_add_float+0x47fc>
jp     590c <check_add_float+0x47fc>
jmp    5911 <check_add_float+0x4801>
call   1030 <abort@plt>
jmp    5916 <check_add_float+0x4806>
movss  0x16e2(%rip),%xmm0
movss  %xmm0,-0x284(%rbp)
ff
movss  -0x278(%rbp),%xmm1
ff
movss  -0x274(%rbp),%xmm0
ff
addss  -0x284(%rbp),%xmm1
ff
movss  %xmm1,-0x280(%rbp)
ff
movss  %xmm0,-0x27c(%rbp)
ff
movss  -0x280(%rbp),%xmm1
ff
movss  -0x27c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    59fd <check_add_float+0x48ed>
movss  -0x280(%rbp),%xmm0
ff
movaps 0x168d(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1692(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1662(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    59fd <check_add_float+0x48ed>
jp     59fd <check_add_float+0x48ed>
movss  -0x27c(%rbp),%xmm0
ff
movaps 0x1653(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1658(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1620(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    59fd <check_add_float+0x48ed>
jp     59fd <check_add_float+0x48ed>
jmp    5a02 <check_add_float+0x48f2>
call   1030 <abort@plt>
jmp    5a07 <check_add_float+0x48f7>
xor    %eax,%eax
test   $0x1,%al
jne    5a16 <check_add_float+0x4906>
jmp    5a85 <check_add_float+0x4975>
mov    $0x1,%al
test   $0x1,%al
jne    5a25 <check_add_float+0x4915>
jmp    5a40 <check_add_float+0x4930>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x58c(%rbp)
ff
movss  %xmm0,-0x588(%rbp)
ff
jmp    5a60 <check_add_float+0x4950>
xorps  %xmm1,%xmm1
movss  0x15b5(%rip),%xmm0
movss  %xmm1,-0x58c(%rbp)
ff
movss  %xmm0,-0x588(%rbp)
ff
jmp    5a60 <check_add_float+0x4950>
movss  -0x58c(%rbp),%xmm1
ff
movss  -0x588(%rbp),%xmm0
ff
movss  %xmm1,-0x594(%rbp)
ff
movss  %xmm0,-0x590(%rbp)
ff
jmp    5af4 <check_add_float+0x49e4>
mov    $0x1,%al
test   $0x1,%al
jne    5a94 <check_add_float+0x4984>
jmp    5ab4 <check_add_float+0x49a4>
movss  0x1564(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x59c(%rbp)
ff
movss  %xmm0,-0x598(%rbp)
ff
jmp    5ad4 <check_add_float+0x49c4>
movss  0x1544(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x59c(%rbp)
ff
movss  %xmm0,-0x598(%rbp)
ff
jmp    5ad4 <check_add_float+0x49c4>
movss  -0x59c(%rbp),%xmm1
ff
movss  -0x598(%rbp),%xmm0
ff
movss  %xmm1,-0x594(%rbp)
ff
movss  %xmm0,-0x590(%rbp)
ff
movss  -0x594(%rbp),%xmm1
ff
movss  -0x590(%rbp),%xmm0
ff
movss  %xmm1,-0x290(%rbp)
ff
movss  %xmm0,-0x28c(%rbp)
ff
movss  -0x290(%rbp),%xmm1
ff
movss  -0x28c(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    5bc3 <check_add_float+0x4ab3>
movss  -0x290(%rbp),%xmm0
ff
movaps 0x14c7(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x14cc(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x149c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5bc3 <check_add_float+0x4ab3>
jp     5bc3 <check_add_float+0x4ab3>
movss  -0x28c(%rbp),%xmm0
ff
movaps 0x148d(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1492(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x145a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5bc3 <check_add_float+0x4ab3>
jp     5bc3 <check_add_float+0x4ab3>
jmp    5bc8 <check_add_float+0x4ab8>
call   1030 <abort@plt>
jmp    5bcd <check_add_float+0x4abd>
movss  0x142b(%rip),%xmm0
movss  %xmm0,-0x29c(%rbp)
ff
movss  -0x290(%rbp),%xmm1
ff
movss  -0x28c(%rbp),%xmm0
ff
movss  -0x29c(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x298(%rbp)
movss  %xmm0,-0x294(%rbp)
ff
movss  -0x298(%rbp),%xmm1
ff
movss  -0x294(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    5cb8 <check_add_float+0x4ba8>
movss  -0x298(%rbp),%xmm0
ff
movaps 0x13d2(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x13d7(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x13a7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5cb8 <check_add_float+0x4ba8>
jp     5cb8 <check_add_float+0x4ba8>
movss  -0x294(%rbp),%xmm0
ff
movaps 0x1398(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x139d(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1365(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5cb8 <check_add_float+0x4ba8>
jp     5cb8 <check_add_float+0x4ba8>
jmp    5cbd <check_add_float+0x4bad>
call   1030 <abort@plt>
jmp    5cc2 <check_add_float+0x4bb2>
jmp    5cc7 <check_add_float+0x4bb7>
jmp    5ccc <check_add_float+0x4bbc>
xor    %eax,%eax
test   $0x1,%al
jne    5cdb <check_add_float+0x4bcb>
jmp    5d4a <check_add_float+0x4c3a>
xor    %eax,%eax
test   $0x1,%al
jne    5cea <check_add_float+0x4bda>
jmp    5d05 <check_add_float+0x4bf5>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x5a4(%rbp)
ff
movss  %xmm0,-0x5a0(%rbp)
ff
jmp    5d25 <check_add_float+0x4c15>
xorps  %xmm1,%xmm1
movss  0x12f0(%rip),%xmm0
movss  %xmm1,-0x5a4(%rbp)
ff
movss  %xmm0,-0x5a0(%rbp)
ff
jmp    5d25 <check_add_float+0x4c15>
movss  -0x5a4(%rbp),%xmm1
ff
movss  -0x5a0(%rbp),%xmm0
ff
movss  %xmm1,-0x5ac(%rbp)
ff
movss  %xmm0,-0x5a8(%rbp)
ff
jmp    5db9 <check_add_float+0x4ca9>
xor    %eax,%eax
test   $0x1,%al
jne    5d59 <check_add_float+0x4c49>
jmp    5d79 <check_add_float+0x4c69>
movss  0x129f(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x5b4(%rbp)
ff
movss  %xmm0,-0x5b0(%rbp)
ff
jmp    5d99 <check_add_float+0x4c89>
movss  0x127f(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x5b4(%rbp)
ff
movss  %xmm0,-0x5b0(%rbp)
ff
jmp    5d99 <check_add_float+0x4c89>
movss  -0x5b4(%rbp),%xmm1
ff
movss  -0x5b0(%rbp),%xmm0
ff
movss  %xmm1,-0x5ac(%rbp)
ff
movss  %xmm0,-0x5a8(%rbp)
ff
movss  -0x5ac(%rbp),%xmm1
ff
movss  -0x5a8(%rbp),%xmm0
ff
movss  %xmm1,-0x2a8(%rbp)
ff
movss  %xmm0,-0x2a4(%rbp)
ff
movss  -0x2a8(%rbp),%xmm1
ff
movss  -0x2a4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    5e88 <check_add_float+0x4d78>
movss  -0x2a8(%rbp),%xmm0
ff
movaps 0x1202(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x1207(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x11d7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5e88 <check_add_float+0x4d78>
jp     5e88 <check_add_float+0x4d78>
movss  -0x2a4(%rbp),%xmm0
ff
movaps 0x11c8(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x11cd(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x119d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5e88 <check_add_float+0x4d78>
jp     5e88 <check_add_float+0x4d78>
jmp    5e8d <check_add_float+0x4d7d>
call   1030 <abort@plt>
jmp    5e92 <check_add_float+0x4d82>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2b4(%rbp)
ff
movss  -0x2a8(%rbp),%xmm1
ff
movss  -0x2a4(%rbp),%xmm0
ff
addss  -0x2b4(%rbp),%xmm1
ff
movss  %xmm1,-0x2b0(%rbp)
ff
movss  %xmm0,-0x2ac(%rbp)
ff
movss  -0x2b0(%rbp),%xmm1
ff
movss  -0x2ac(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    5f74 <check_add_float+0x4e64>
movss  -0x2b0(%rbp),%xmm0
ff
movaps 0x1116(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x111b(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x10e3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5f74 <check_add_float+0x4e64>
jp     5f74 <check_add_float+0x4e64>
movss  -0x2ac(%rbp),%xmm0
ff
movaps 0x10dc(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x10e1(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x10b1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    5f74 <check_add_float+0x4e64>
jp     5f74 <check_add_float+0x4e64>
jmp    5f79 <check_add_float+0x4e69>
call   1030 <abort@plt>
jmp    5f7e <check_add_float+0x4e6e>
xor    %eax,%eax
test   $0x1,%al
jne    5f8d <check_add_float+0x4e7d>
jmp    5ffc <check_add_float+0x4eec>
xor    %eax,%eax
test   $0x1,%al
jne    5f9c <check_add_float+0x4e8c>
jmp    5fb7 <check_add_float+0x4ea7>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x5bc(%rbp)
ff
movss  %xmm0,-0x5b8(%rbp)
ff
jmp    5fd7 <check_add_float+0x4ec7>
xorps  %xmm1,%xmm1
movss  0x103e(%rip),%xmm0
movss  %xmm1,-0x5bc(%rbp)
ff
movss  %xmm0,-0x5b8(%rbp)
ff
jmp    5fd7 <check_add_float+0x4ec7>
movss  -0x5bc(%rbp),%xmm1
ff
movss  -0x5b8(%rbp),%xmm0
ff
movss  %xmm1,-0x5c4(%rbp)
ff
movss  %xmm0,-0x5c0(%rbp)
ff
jmp    606b <check_add_float+0x4f5b>
xor    %eax,%eax
test   $0x1,%al
jne    600b <check_add_float+0x4efb>
jmp    602b <check_add_float+0x4f1b>
movss  0xfed(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x5cc(%rbp)
ff
movss  %xmm0,-0x5c8(%rbp)
ff
jmp    604b <check_add_float+0x4f3b>
movss  0xfcd(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x5cc(%rbp)
ff
movss  %xmm0,-0x5c8(%rbp)
ff
jmp    604b <check_add_float+0x4f3b>
movss  -0x5cc(%rbp),%xmm1
ff
movss  -0x5c8(%rbp),%xmm0
ff
movss  %xmm1,-0x5c4(%rbp)
ff
movss  %xmm0,-0x5c0(%rbp)
ff
movss  -0x5c4(%rbp),%xmm1
ff
movss  -0x5c0(%rbp),%xmm0
ff
movss  %xmm1,-0x2c0(%rbp)
ff
movss  %xmm0,-0x2bc(%rbp)
ff
movss  -0x2c0(%rbp),%xmm1
ff
movss  -0x2bc(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    613a <check_add_float+0x502a>
movss  -0x2c0(%rbp),%xmm0
ff
movaps 0xf50(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0xf55(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf25(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    613a <check_add_float+0x502a>
jp     613a <check_add_float+0x502a>
movss  -0x2bc(%rbp),%xmm0
ff
movaps 0xf16(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0xf1b(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xeeb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    613a <check_add_float+0x502a>
jp     613a <check_add_float+0x502a>
jmp    613f <check_add_float+0x502f>
call   1030 <abort@plt>
jmp    6144 <check_add_float+0x5034>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2cc(%rbp)
ff
movss  -0x2c0(%rbp),%xmm1
ff
movss  -0x2bc(%rbp),%xmm0
ff
movss  -0x2cc(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x2c8(%rbp)
ff
movss  %xmm0,-0x2c4(%rbp)
ff
movss  -0x2c8(%rbp),%xmm1
ff
movss  -0x2c4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    622a <check_add_float+0x511a>
movss  -0x2c8(%rbp),%xmm0
ff
movaps 0xe60(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0xe65(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe2d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    622a <check_add_float+0x511a>
jp     622a <check_add_float+0x511a>
movss  -0x2c4(%rbp),%xmm0
ff
movaps 0xe26(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0xe2b(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdfb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    622a <check_add_float+0x511a>
jp     622a <check_add_float+0x511a>
jmp    622f <check_add_float+0x511f>
call   1030 <abort@plt>
jmp    6234 <check_add_float+0x5124>
jmp    6239 <check_add_float+0x5129>
jmp    623e <check_add_float+0x512e>
xor    %eax,%eax
test   $0x1,%al
jne    624d <check_add_float+0x513d>
jmp    62bc <check_add_float+0x51ac>
xor    %eax,%eax
test   $0x1,%al
jne    625c <check_add_float+0x514c>
jmp    6277 <check_add_float+0x5167>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x5d4(%rbp)
ff
movss  %xmm0,-0x5d0(%rbp)
ff
jmp    6297 <check_add_float+0x5187>
xorps  %xmm1,%xmm1
movss  0xd7e(%rip),%xmm0
movss  %xmm1,-0x5d4(%rbp)
ff
movss  %xmm0,-0x5d0(%rbp)
ff
jmp    6297 <check_add_float+0x5187>
movss  -0x5d4(%rbp),%xmm1
ff
movss  -0x5d0(%rbp),%xmm0
ff
movss  %xmm1,-0x5dc(%rbp)
ff
movss  %xmm0,-0x5d8(%rbp)
ff
jmp    632b <check_add_float+0x521b>
xor    %eax,%eax
test   $0x1,%al
jne    62cb <check_add_float+0x51bb>
jmp    62eb <check_add_float+0x51db>
movss  0xd2d(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x5e4(%rbp)
ff
movss  %xmm0,-0x5e0(%rbp)
ff
jmp    630b <check_add_float+0x51fb>
movss  0xd0d(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x5e4(%rbp)
ff
movss  %xmm0,-0x5e0(%rbp)
ff
jmp    630b <check_add_float+0x51fb>
movss  -0x5e4(%rbp),%xmm1
ff
movss  -0x5e0(%rbp),%xmm0
ff
movss  %xmm1,-0x5dc(%rbp)
ff
movss  %xmm0,-0x5d8(%rbp)
ff
movss  -0x5dc(%rbp),%xmm1
ff
movss  -0x5d8(%rbp),%xmm0
ff
movss  %xmm1,-0x2d8(%rbp)
ff
movss  %xmm0,-0x2d4(%rbp)
ff
movss  -0x2d8(%rbp),%xmm1
ff
movss  -0x2d4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    63fa <check_add_float+0x52ea>
movss  -0x2d8(%rbp),%xmm0
ff
movaps 0xc90(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0xc95(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc65(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    63fa <check_add_float+0x52ea>
jp     63fa <check_add_float+0x52ea>
movss  -0x2d4(%rbp),%xmm0
ff
movaps 0xc56(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0xc5b(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc2b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    63fa <check_add_float+0x52ea>
jp     63fa <check_add_float+0x52ea>
jmp    63ff <check_add_float+0x52ef>
call   1030 <abort@plt>
jmp    6404 <check_add_float+0x52f4>
movss  0xbf4(%rip),%xmm0
movss  %xmm0,-0x2e4(%rbp)
ff
movss  -0x2d8(%rbp),%xmm1
ff
movss  -0x2d4(%rbp),%xmm0
ff
addss  -0x2e4(%rbp),%xmm1
ff
movss  %xmm1,-0x2e0(%rbp)
ff
movss  %xmm0,-0x2dc(%rbp)
ff
movss  -0x2e0(%rbp),%xmm1
ff
movss  -0x2dc(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    64eb <check_add_float+0x53db>
movss  -0x2e0(%rbp),%xmm0
ff
movaps 0xb9f(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0xba4(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb74(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    64eb <check_add_float+0x53db>
jp     64eb <check_add_float+0x53db>
movss  -0x2dc(%rbp),%xmm0
ff
movaps 0xb65(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0xb6a(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb3a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    64eb <check_add_float+0x53db>
jp     64eb <check_add_float+0x53db>
jmp    64f0 <check_add_float+0x53e0>
call   1030 <abort@plt>
jmp    64f5 <check_add_float+0x53e5>
xor    %eax,%eax
test   $0x1,%al
jne    6504 <check_add_float+0x53f4>
jmp    6573 <check_add_float+0x5463>
xor    %eax,%eax
test   $0x1,%al
jne    6513 <check_add_float+0x5403>
jmp    652e <check_add_float+0x541e>
xorps  %xmm0,%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x5ec(%rbp)
ff
movss  %xmm0,-0x5e8(%rbp)
ff
jmp    654e <check_add_float+0x543e>
xorps  %xmm1,%xmm1
movss  0xac7(%rip),%xmm0
movss  %xmm1,-0x5ec(%rbp)
ff
movss  %xmm0,-0x5e8(%rbp)
ff
jmp    654e <check_add_float+0x543e>
movss  -0x5ec(%rbp),%xmm1
ff
movss  -0x5e8(%rbp),%xmm0
ff
movss  %xmm1,-0x5f4(%rbp)
ff
movss  %xmm0,-0x5f0(%rbp)
ff
jmp    65e2 <check_add_float+0x54d2>
xor    %eax,%eax
test   $0x1,%al
jne    6582 <check_add_float+0x5472>
jmp    65a2 <check_add_float+0x5492>
movss  0xa76(%rip),%xmm1
xorps  %xmm0,%xmm0
movss  %xmm1,-0x5fc(%rbp)
ff
movss  %xmm0,-0x5f8(%rbp)
ff
jmp    65c2 <check_add_float+0x54b2>
movss  0xa56(%rip),%xmm0
movaps %xmm0,%xmm1
movss  %xmm1,-0x5fc(%rbp)
ff
movss  %xmm0,-0x5f8(%rbp)
ff
jmp    65c2 <check_add_float+0x54b2>
movss  -0x5fc(%rbp),%xmm1
ff
movss  -0x5f8(%rbp),%xmm0
ff
movss  %xmm1,-0x5f4(%rbp)
ff
movss  %xmm0,-0x5f0(%rbp)
ff
movss  -0x5f4(%rbp),%xmm1
ff
movss  -0x5f0(%rbp),%xmm0
ff
movss  %xmm1,-0x2f0(%rbp)
ff
movss  %xmm0,-0x2ec(%rbp)
ff
movss  -0x2f0(%rbp),%xmm1
ff
movss  -0x2ec(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    66b1 <check_add_float+0x55a1>
movss  -0x2f0(%rbp),%xmm0
ff
movaps 0x9d9(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x9de(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9ae(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    66b1 <check_add_float+0x55a1>
jp     66b1 <check_add_float+0x55a1>
movss  -0x2ec(%rbp),%xmm0
ff
movaps 0x99f(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x9a4(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x974(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    66b1 <check_add_float+0x55a1>
jp     66b1 <check_add_float+0x55a1>
jmp    66b6 <check_add_float+0x55a6>
call   1030 <abort@plt>
jmp    66bb <check_add_float+0x55ab>
movss  0x93d(%rip),%xmm0
movss  %xmm0,-0x2fc(%rbp)
ff
movss  -0x2f0(%rbp),%xmm1
ff
movss  -0x2ec(%rbp),%xmm0
ff
movss  -0x2fc(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
movss  %xmm1,-0x2f8(%rbp)
ff
movss  %xmm0,-0x2f4(%rbp)
ff
movss  -0x2f8(%rbp),%xmm1
ff
movss  -0x2f4(%rbp),%xmm0
ff
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
setne  %al
setp   %cl
or     %cl,%al
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    67a6 <check_add_float+0x5696>
movss  -0x2f8(%rbp),%xmm0
ff
movaps 0x8e4(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x8e9(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x8b9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    67a6 <check_add_float+0x5696>
jp     67a6 <check_add_float+0x5696>
movss  -0x2f4(%rbp),%xmm0
ff
movaps 0x8aa(%rip),%xmm1
pand   %xmm1,%xmm0
movaps 0x8af(%rip),%xmm1
por    %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x87f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    67a6 <check_add_float+0x5696>
jp     67a6 <check_add_float+0x5696>
jmp    67ab <check_add_float+0x569b>
call   1030 <abort@plt>
jmp    67b0 <check_add_float+0x56a0>
jmp    67b5 <check_add_float+0x56a5>
jmp    67ba <check_add_float+0x56aa>
add    $0x600,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_add_float>:
sub    $0x18,%rsp
movl   $0x0,0x10(%rsp)
movl   $0x0,0x4(%rsp)
movl   $0x0,0x8(%rsp)
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x1e9a(%rip),%xmm0
orps   0x1ea3(%rip),%xmm0
ucomiss 0x1eac(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x1e73(%rip),%xmm0
orps   0x1e7c(%rip),%xmm0
ucomiss 0x1e85(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x14(%rsp)
movss  0xc(%rsp),%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x1e01(%rip),%xmm0
orps   0x1e0a(%rip),%xmm0
ucomiss 0x1e13(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x14(%rsp),%xmm0
andps  0x1dda(%rip),%xmm0
orps   0x1de3(%rip),%xmm0
ucomiss 0x1dec(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x10(%rsp)
movl   $0x0,0x4(%rsp)
movl   $0x80000000,0x8(%rsp)
80
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x1d6e(%rip),%xmm0
orps   0x1d77(%rip),%xmm0
ucomiss 0x1d80(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x1d47(%rip),%xmm0
orps   0x1d50(%rip),%xmm0
ucomiss 0x1d5d(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x14(%rsp)
movss  0xc(%rsp),%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x1cd5(%rip),%xmm0
orps   0x1cde(%rip),%xmm0
ucomiss 0x1ce7(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x14(%rsp),%xmm0
andps  0x1cae(%rip),%xmm0
orps   0x1cb7(%rip),%xmm0
ucomiss 0x1cc4(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x10(%rsp)
movl   $0x80000000,0x4(%rsp)
80
movl   $0x0,0x8(%rsp)
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x1c42(%rip),%xmm0
orps   0x1c4b(%rip),%xmm0
ucomiss 0x1c58(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x1c1b(%rip),%xmm0
orps   0x1c24(%rip),%xmm0
ucomiss 0x1c2d(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x14(%rsp)
movss  0xc(%rsp),%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x1ba9(%rip),%xmm0
orps   0x1bb2(%rip),%xmm0
ucomiss 0x1bbb(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x14(%rsp),%xmm0
andps  0x1b82(%rip),%xmm0
orps   0x1b8b(%rip),%xmm0
ucomiss 0x1b94(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x10(%rsp)
movl   $0x80000000,0x4(%rsp)
80
movl   $0x80000000,0x8(%rsp)
80
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x1b16(%rip),%xmm0
orps   0x1b1f(%rip),%xmm0
ucomiss 0x1b2c(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x1aef(%rip),%xmm0
orps   0x1af8(%rip),%xmm0
ucomiss 0x1b05(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x14(%rsp)
movss  0xc(%rsp),%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x1a7d(%rip),%xmm0
orps   0x1a86(%rip),%xmm0
ucomiss 0x1a8f(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x14(%rsp),%xmm0
andps  0x1a56(%rip),%xmm0
orps   0x1a5f(%rip),%xmm0
ucomiss 0x1a6c(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x10(%rsp)
80
movl   $0x0,0x4(%rsp)
movl   $0x0,0x8(%rsp)
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x19ea(%rip),%xmm0
orps   0x19f3(%rip),%xmm0
ucomiss 0x19fc(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x19c3(%rip),%xmm0
orps   0x19cc(%rip),%xmm0
ucomiss 0x19d5(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x14(%rsp)
movss  0xc(%rsp),%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x1951(%rip),%xmm0
orps   0x195a(%rip),%xmm0
ucomiss 0x1963(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x14(%rsp),%xmm0
andps  0x192a(%rip),%xmm0
orps   0x1933(%rip),%xmm0
ucomiss 0x193c(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x10(%rsp)
80
movl   $0x0,0x4(%rsp)
movl   $0x80000000,0x8(%rsp)
80
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x18be(%rip),%xmm0
orps   0x18c7(%rip),%xmm0
ucomiss 0x18d0(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x1897(%rip),%xmm0
orps   0x18a0(%rip),%xmm0
ucomiss 0x18ad(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x14(%rsp)
movss  0xc(%rsp),%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x1825(%rip),%xmm0
orps   0x182e(%rip),%xmm0
ucomiss 0x1837(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x14(%rsp),%xmm0
andps  0x17fe(%rip),%xmm0
orps   0x1807(%rip),%xmm0
ucomiss 0x1814(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x10(%rsp)
80
movl   $0x80000000,0x4(%rsp)
80
movl   $0x0,0x8(%rsp)
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x1792(%rip),%xmm0
orps   0x179b(%rip),%xmm0
ucomiss 0x17a8(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x176b(%rip),%xmm0
orps   0x1774(%rip),%xmm0
ucomiss 0x177d(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x14(%rsp)
movss  0xc(%rsp),%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x16f9(%rip),%xmm0
orps   0x1702(%rip),%xmm0
ucomiss 0x170f(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x14(%rsp),%xmm0
andps  0x16d2(%rip),%xmm0
orps   0x16db(%rip),%xmm0
ucomiss 0x16e4(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x10(%rsp)
80
movl   $0x80000000,0x4(%rsp)
80
movl   $0x80000000,0x8(%rsp)
80
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x1666(%rip),%xmm0
orps   0x166f(%rip),%xmm0
ucomiss 0x167c(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x163f(%rip),%xmm0
orps   0x1648(%rip),%xmm0
ucomiss 0x1655(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
movss  %xmm1,0x14(%rsp)
movss  0xc(%rsp),%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x15cd(%rip),%xmm0
orps   0x15d6(%rip),%xmm0
ucomiss 0x15e3(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x14(%rsp),%xmm0
andps  0x15a6(%rip),%xmm0
orps   0x15af(%rip),%xmm0
ucomiss 0x15bc(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x10(%rsp)
movl   $0x0,0x4(%rsp)
movss  0x10(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
andps  0x1542(%rip),%xmm0
orps   0x154b(%rip),%xmm0
ucomiss 0x1554(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x151b(%rip),%xmm0
orps   0x1524(%rip),%xmm0
ucomiss 0x152d(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x14(%rsp)
movss  0x10(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x14a1(%rip),%xmm0
orps   0x14aa(%rip),%xmm0
ucomiss 0x14b3(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x147a(%rip),%xmm0
orps   0x1483(%rip),%xmm0
ucomiss 0x148c(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x10(%rsp)
movl   $0x0,0x4(%rsp)
movss  0x10(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
andps  0x1416(%rip),%xmm0
orps   0x141f(%rip),%xmm0
ucomiss 0x1428(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x13ef(%rip),%xmm0
orps   0x13f8(%rip),%xmm0
ucomiss 0x1401(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x14(%rsp)
80
movss  0x10(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x1375(%rip),%xmm0
orps   0x137e(%rip),%xmm0
ucomiss 0x1387(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x134e(%rip),%xmm0
orps   0x1357(%rip),%xmm0
ucomiss 0x1360(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x10(%rsp)
movl   $0x80000000,0x4(%rsp)
80
movss  0x10(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
andps  0x12ea(%rip),%xmm0
orps   0x12f3(%rip),%xmm0
ucomiss 0x12fc(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x12c3(%rip),%xmm0
orps   0x12cc(%rip),%xmm0
ucomiss 0x12d9(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x14(%rsp)
movss  0x10(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x1249(%rip),%xmm0
orps   0x1252(%rip),%xmm0
ucomiss 0x125b(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x1222(%rip),%xmm0
orps   0x122b(%rip),%xmm0
ucomiss 0x1238(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x10(%rsp)
movl   $0x80000000,0x4(%rsp)
80
movss  0x10(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
andps  0x11be(%rip),%xmm0
orps   0x11c7(%rip),%xmm0
ucomiss 0x11d0(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x1197(%rip),%xmm0
orps   0x11a0(%rip),%xmm0
ucomiss 0x11ad(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x14(%rsp)
80
movss  0x10(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0x111d(%rip),%xmm0
orps   0x1126(%rip),%xmm0
ucomiss 0x112f(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0x10f6(%rip),%xmm0
orps   0x10ff(%rip),%xmm0
ucomiss 0x110c(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x10(%rsp)
80
movl   $0x0,0x4(%rsp)
movss  0x10(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
andps  0x1092(%rip),%xmm0
orps   0x109b(%rip),%xmm0
ucomiss 0x10a8(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0x106b(%rip),%xmm0
orps   0x1074(%rip),%xmm0
ucomiss 0x107d(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x14(%rsp)
movss  0x10(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0xff1(%rip),%xmm0
orps   0xffa(%rip),%xmm0
ucomiss 0x1003(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0xfca(%rip),%xmm0
orps   0xfd3(%rip),%xmm0
ucomiss 0xfdc(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x10(%rsp)
80
movl   $0x0,0x4(%rsp)
movss  0x10(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
andps  0xf66(%rip),%xmm0
orps   0xf6f(%rip),%xmm0
ucomiss 0xf7c(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0xf3f(%rip),%xmm0
orps   0xf48(%rip),%xmm0
ucomiss 0xf51(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x14(%rsp)
80
movss  0x10(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0xec5(%rip),%xmm0
orps   0xece(%rip),%xmm0
ucomiss 0xedb(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0xe9e(%rip),%xmm0
orps   0xea7(%rip),%xmm0
ucomiss 0xeb0(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x10(%rsp)
80
movl   $0x80000000,0x4(%rsp)
80
movss  0x10(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
andps  0xe3a(%rip),%xmm0
orps   0xe43(%rip),%xmm0
ucomiss 0xe50(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0xe13(%rip),%xmm0
orps   0xe1c(%rip),%xmm0
ucomiss 0xe29(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x0,0x14(%rsp)
movss  0x10(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0xd99(%rip),%xmm0
orps   0xda2(%rip),%xmm0
ucomiss 0xdab(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0xd72(%rip),%xmm0
orps   0xd7b(%rip),%xmm0
ucomiss 0xd88(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x10(%rsp)
80
movl   $0x80000000,0x4(%rsp)
80
movss  0x10(%rsp),%xmm2
movss  0x4(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x10(%rsp),%xmm0
andps  0xd0e(%rip),%xmm0
orps   0xd17(%rip),%xmm0
ucomiss 0xd24(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x4(%rsp),%xmm0
andps  0xce7(%rip),%xmm0
orps   0xcf0(%rip),%xmm0
ucomiss 0xcfd(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movl   $0x80000000,0x14(%rsp)
80
movss  0x10(%rsp),%xmm0
movss  0x4(%rsp),%xmm1
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
movss  %xmm1,0xc(%rsp)
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
ucomiss %xmm1,%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0x8(%rsp),%xmm0
andps  0xc7d(%rip),%xmm0
orps   0xc86(%rip),%xmm0
ucomiss 0xc93(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
movss  0xc(%rsp),%xmm0
andps  0xc5e(%rip),%xmm0
orps   0xc67(%rip),%xmm0
ucomiss 0xc74(%rip),%xmm0
jne    23b9 <check_add_float+0x12a9>
jp     23b9 <check_add_float+0x12a9>
add    $0x18,%rsp
ret
call   1030 <abort@plt>

LLVM IR (-O0):
define void @check_add_float() {
%1 = alloca float
%2 = alloca { float, float }
%3 = alloca { float, float }
%4 = alloca float
%5 = alloca { float, float }
%6 = alloca { float, float }
%7 = alloca float
%8 = alloca { float, float }
%9 = alloca { float, float }
%10 = alloca float
%11 = alloca { float, float }
%12 = alloca { float, float }
%13 = alloca float
%14 = alloca { float, float }
%15 = alloca { float, float }
%16 = alloca float
%17 = alloca { float, float }
%18 = alloca { float, float }
%19 = alloca float
%20 = alloca { float, float }
%21 = alloca { float, float }
%22 = alloca float
%23 = alloca { float, float }
%24 = alloca { float, float }
%25 = alloca float
%26 = alloca { float, float }
%27 = alloca { float, float }
%28 = alloca float
%29 = alloca { float, float }
%30 = alloca { float, float }
%31 = alloca float
%32 = alloca { float, float }
%33 = alloca { float, float }
%34 = alloca float
%35 = alloca { float, float }
%36 = alloca { float, float }
%37 = alloca float
%38 = alloca { float, float }
%39 = alloca { float, float }
%40 = alloca float
%41 = alloca { float, float }
%42 = alloca { float, float }
%43 = alloca float
%44 = alloca { float, float }
%45 = alloca { float, float }
%46 = alloca float
%47 = alloca { float, float }
%48 = alloca { float, float }
%49 = alloca { float, float }
%50 = alloca { float, float }
%51 = alloca float
%52 = alloca { float, float }
%53 = alloca { float, float }
%54 = alloca float
%55 = alloca { float, float }
%56 = alloca { float, float }
%57 = alloca float
%58 = alloca { float, float }
%59 = alloca { float, float }
%60 = alloca float
%61 = alloca { float, float }
%62 = alloca { float, float }
%63 = alloca float
%64 = alloca { float, float }
%65 = alloca { float, float }
%66 = alloca float
%67 = alloca { float, float }
%68 = alloca { float, float }
%69 = alloca float
%70 = alloca { float, float }
%71 = alloca { float, float }
%72 = alloca float
%73 = alloca { float, float }
%74 = alloca { float, float }
%75 = alloca float
%76 = alloca { float, float }
%77 = alloca { float, float }
%78 = alloca float
%79 = alloca { float, float }
%80 = alloca { float, float }
%81 = alloca float
%82 = alloca { float, float }
%83 = alloca { float, float }
%84 = alloca float
%85 = alloca { float, float }
%86 = alloca { float, float }
%87 = alloca float
%88 = alloca { float, float }
%89 = alloca { float, float }
%90 = alloca float
%91 = alloca { float, float }
%92 = alloca { float, float }
%93 = alloca float
%94 = alloca { float, float }
%95 = alloca { float, float }
%96 = alloca float
br label %97
97: ; preds = %0
br label %98
98: ; preds = %97
store float 0.000000e+00, float* %1
br i1 true, label %99, label %105
99: ; preds = %98
br i1 true, label %100, label %101
100: ; preds = %99
br label %102
101: ; preds = %99
br label %102
102: ; preds = %101, %100
%103 = phi float [ 0.000000e+00, %100 ], [ 0.000000e+00, %101 ]
%104 = phi float [ 0.000000e+00, %100 ], [ -0.000000e+00, %101 ]
br label %111
105: ; preds = %98
br i1 true, label %106, label %107
106: ; preds = %105
br label %108
107: ; preds = %105
br label %108
108: ; preds = %107, %106
%109 = phi float [ -0.000000e+00, %106 ], [ -0.000000e+00, %107 ]
%110 = phi float [ 0.000000e+00, %106 ], [ -0.000000e+00, %107 ]
br label %111
111: ; preds = %108, %102
%112 = phi float [ %103, %102 ], [ %109, %108 ]
%113 = phi float [ %104, %102 ], [ %110, %108 ]
%114 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 0
%115 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 1
store float %112, float* %114
store float %113, float* %115
br label %116
116: ; preds = %111
%117 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 0
%118 = load float, float* %117
%119 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 1
%120 = load float, float* %119
%121 = fcmp une float %118, 0.000000e+00
%122 = fcmp une float %120, 0.000000e+00
%123 = or i1 %121, %122
br i1 %123, label %136, label %124
124: ; preds = %116
%125 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 0
%126 = load float, float* %125
%127 = call float @llvm.copysign.f32(float 1.000000e+00, float %126)
%128 = fpext float %127 to double
%129 = fcmp une double %128, 1.000000e+00
br i1 %129, label %136, label %130
130: ; preds = %124
%131 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 1
%132 = load float, float* %131
%133 = call float @llvm.copysign.f32(float 1.000000e+00, float %132)
%134 = fpext float %133 to double
%135 = fcmp une double %134, 1.000000e+00
br i1 %135, label %136, label %137
136: ; preds = %130, %124, %116
unreachable
137: ; preds = %130
br label %138
138: ; preds = %137
%139 = load float, float* %1
%140 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 0
%141 = load float, float* %140
%142 = getelementptr inbounds { float, float }, { float, float }* %2, i32 0, i32 1
%143 = load float, float* %142
%144 = fadd float %139, %141
%145 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 0
%146 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 1
store float %144, float* %145
store float %143, float* %146
br label %147
147: ; preds = %138
%148 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 0
%149 = load float, float* %148
%150 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 1
%151 = load float, float* %150
%152 = fcmp une float %149, 0.000000e+00
%153 = fcmp une float %151, 0.000000e+00
%154 = or i1 %152, %153
br i1 %154, label %167, label %155
155: ; preds = %147
%156 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 0
%157 = load float, float* %156
%158 = call float @llvm.copysign.f32(float 1.000000e+00, float %157)
%159 = fpext float %158 to double
%160 = fcmp une double %159, 1.000000e+00
br i1 %160, label %167, label %161
161: ; preds = %155
%162 = getelementptr inbounds { float, float }, { float, float }* %3, i32 0, i32 1
%163 = load float, float* %162
%164 = call float @llvm.copysign.f32(float 1.000000e+00, float %163)
%165 = fpext float %164 to double
%166 = fcmp une double %165, 1.000000e+00
br i1 %166, label %167, label %168
167: ; preds = %161, %155, %147
unreachable
168: ; preds = %161
br label %169
169: ; preds = %168
store volatile float 0.000000e+00, float* %4
br i1 true, label %170, label %176
170: ; preds = %169
br i1 true, label %171, label %172
171: ; preds = %170
br label %173
172: ; preds = %170
br label %173
173: ; preds = %172, %171
%174 = phi float [ 0.000000e+00, %171 ], [ 0.000000e+00, %172 ]
%175 = phi float [ 0.000000e+00, %171 ], [ -0.000000e+00, %172 ]
br label %182
176: ; preds = %169
br i1 true, label %177, label %178
177: ; preds = %176
br label %179
178: ; preds = %176
br label %179
179: ; preds = %178, %177
%180 = phi float [ -0.000000e+00, %177 ], [ -0.000000e+00, %178 ]
%181 = phi float [ 0.000000e+00, %177 ], [ -0.000000e+00, %178 ]
br label %182
182: ; preds = %179, %173
%183 = phi float [ %174, %173 ], [ %180, %179 ]
%184 = phi float [ %175, %173 ], [ %181, %179 ]
%185 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 0
%186 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 1
store volatile float %183, float* %185
store volatile float %184, float* %186
br label %187
187: ; preds = %182
%188 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 0
%189 = load volatile float, float* %188
%190 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 1
%191 = load volatile float, float* %190
%192 = fcmp une float %189, 0.000000e+00
%193 = fcmp une float %191, 0.000000e+00
%194 = or i1 %192, %193
br i1 %194, label %207, label %195
195: ; preds = %187
%196 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 0
%197 = load volatile float, float* %196
%198 = call float @llvm.copysign.f32(float 1.000000e+00, float %197)
%199 = fpext float %198 to double
%200 = fcmp une double %199, 1.000000e+00
br i1 %200, label %207, label %201
201: ; preds = %195
%202 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 1
%203 = load volatile float, float* %202
%204 = call float @llvm.copysign.f32(float 1.000000e+00, float %203)
%205 = fpext float %204 to double
%206 = fcmp une double %205, 1.000000e+00
br i1 %206, label %207, label %208
207: ; preds = %201, %195, %187
unreachable
208: ; preds = %201
br label %209
209: ; preds = %208
%210 = load volatile float, float* %4
%211 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 0
%212 = load volatile float, float* %211
%213 = getelementptr inbounds { float, float }, { float, float }* %5, i32 0, i32 1
%214 = load volatile float, float* %213
%215 = fadd float %210, %212
%216 = getelementptr inbounds { float, float }, { float, float }* %6, i32 0, i32 0
%217 = getelementptr inbounds { float, float }, { float, float }* %6, i32 0, i32 1
store volatile float %215, float* %216
store volatile float %214, float* %217
br label %218
218: ; preds = %209
%219 = getelementptr inbounds { float, float }, { float, float }* %6, i32 0, i32 0
%220 = load volatile float, float* %219
%221 = getelementptr inbounds { float, float }, { float, float }* %6, i32 0, i32 1
%222 = load volatile float, float* %221
%223 = fcmp une float %220, 0.000000e+00
%224 = fcmp une float %222, 0.000000e+00
%225 = or i1 %223, %224
br i1 %225, label %238, label %226
226: ; preds = %218
%227 = getelementptr inbounds { float, float }, { float, float }* %6, i32 0, i32 0
%228 = load volatile float, float* %227
%229 = call float @llvm.copysign.f32(float 1.000000e+00, float %228)
%230 = fpext float %229 to double
%231 = fcmp une double %230, 1.000000e+00
br i1 %231, label %238, label %232
232: ; preds = %226
%233 = getelementptr inbounds { float, float }, { float, float }* %6, i32 0, i32 1
%234 = load volatile float, float* %233
%235 = call float @llvm.copysign.f32(float 1.000000e+00, float %234)
%236 = fpext float %235 to double
%237 = fcmp une double %236, 1.000000e+00
br i1 %237, label %238, label %239
238: ; preds = %232, %226, %218
unreachable
239: ; preds = %232
br label %240
240: ; preds = %239
br label %241
241: ; preds = %240
br label %242
242: ; preds = %241
store float 0.000000e+00, float* %7
br i1 true, label %243, label %249
243: ; preds = %242
br i1 false, label %244, label %245
244: ; preds = %243
br label %246
245: ; preds = %243
br label %246
246: ; preds = %245, %244
%247 = phi float [ 0.000000e+00, %244 ], [ 0.000000e+00, %245 ]
%248 = phi float [ 0.000000e+00, %244 ], [ -0.000000e+00, %245 ]
br label %255
249: ; preds = %242
br i1 false, label %250, label %251
250: ; preds = %249
br label %252
251: ; preds = %249
br label %252
252: ; preds = %251, %250
%253 = phi float [ -0.000000e+00, %250 ], [ -0.000000e+00, %251 ]
%254 = phi float [ 0.000000e+00, %250 ], [ -0.000000e+00, %251 ]
br label %255
255: ; preds = %252, %246
%256 = phi float [ %247, %246 ], [ %253, %252 ]
%257 = phi float [ %248, %246 ], [ %254, %252 ]
%258 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 0
%259 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 1
store float %256, float* %258
store float %257, float* %259
br label %260
260: ; preds = %255
%261 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 0
%262 = load float, float* %261
%263 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 1
%264 = load float, float* %263
%265 = fcmp une float %262, 0.000000e+00
%266 = fcmp une float %264, 0.000000e+00
%267 = or i1 %265, %266
br i1 %267, label %280, label %268
268: ; preds = %260
%269 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 0
%270 = load float, float* %269
%271 = call float @llvm.copysign.f32(float 1.000000e+00, float %270)
%272 = fpext float %271 to double
%273 = fcmp une double %272, 1.000000e+00
br i1 %273, label %280, label %274
274: ; preds = %268
%275 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 1
%276 = load float, float* %275
%277 = call float @llvm.copysign.f32(float 1.000000e+00, float %276)
%278 = fpext float %277 to double
%279 = fcmp une double %278, -1.000000e+00
br i1 %279, label %280, label %281
280: ; preds = %274, %268, %260
unreachable
281: ; preds = %274
br label %282
282: ; preds = %281
%283 = load float, float* %7
%284 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 0
%285 = load float, float* %284
%286 = getelementptr inbounds { float, float }, { float, float }* %8, i32 0, i32 1
%287 = load float, float* %286
%288 = fadd float %283, %285
%289 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 0
%290 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 1
store float %288, float* %289
store float %287, float* %290
br label %291
291: ; preds = %282
%292 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 0
%293 = load float, float* %292
%294 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 1
%295 = load float, float* %294
%296 = fcmp une float %293, 0.000000e+00
%297 = fcmp une float %295, 0.000000e+00
%298 = or i1 %296, %297
br i1 %298, label %311, label %299
299: ; preds = %291
%300 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 0
%301 = load float, float* %300
%302 = call float @llvm.copysign.f32(float 1.000000e+00, float %301)
%303 = fpext float %302 to double
%304 = fcmp une double %303, 1.000000e+00
br i1 %304, label %311, label %305
305: ; preds = %299
%306 = getelementptr inbounds { float, float }, { float, float }* %9, i32 0, i32 1
%307 = load float, float* %306
%308 = call float @llvm.copysign.f32(float 1.000000e+00, float %307)
%309 = fpext float %308 to double
%310 = fcmp une double %309, -1.000000e+00
br i1 %310, label %311, label %312
311: ; preds = %305, %299, %291
unreachable
312: ; preds = %305
br label %313
313: ; preds = %312
store volatile float 0.000000e+00, float* %10
br i1 true, label %314, label %320
314: ; preds = %313
br i1 false, label %315, label %316
315: ; preds = %314
br label %317
316: ; preds = %314
br label %317
317: ; preds = %316, %315
%318 = phi float [ 0.000000e+00, %315 ], [ 0.000000e+00, %316 ]
%319 = phi float [ 0.000000e+00, %315 ], [ -0.000000e+00, %316 ]
br label %326
320: ; preds = %313
br i1 false, label %321, label %322
321: ; preds = %320
br label %323
322: ; preds = %320
br label %323
323: ; preds = %322, %321
%324 = phi float [ -0.000000e+00, %321 ], [ -0.000000e+00, %322 ]
%325 = phi float [ 0.000000e+00, %321 ], [ -0.000000e+00, %322 ]
br label %326
326: ; preds = %323, %317
%327 = phi float [ %318, %317 ], [ %324, %323 ]
%328 = phi float [ %319, %317 ], [ %325, %323 ]
%329 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 0
%330 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 1
store volatile float %327, float* %329
store volatile float %328, float* %330
br label %331
331: ; preds = %326
%332 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 0
%333 = load volatile float, float* %332
%334 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 1
%335 = load volatile float, float* %334
%336 = fcmp une float %333, 0.000000e+00
%337 = fcmp une float %335, 0.000000e+00
%338 = or i1 %336, %337
br i1 %338, label %351, label %339
339: ; preds = %331
%340 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 0
%341 = load volatile float, float* %340
%342 = call float @llvm.copysign.f32(float 1.000000e+00, float %341)
%343 = fpext float %342 to double
%344 = fcmp une double %343, 1.000000e+00
br i1 %344, label %351, label %345
345: ; preds = %339
%346 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 1
%347 = load volatile float, float* %346
%348 = call float @llvm.copysign.f32(float 1.000000e+00, float %347)
%349 = fpext float %348 to double
%350 = fcmp une double %349, -1.000000e+00
br i1 %350, label %351, label %352
351: ; preds = %345, %339, %331
unreachable
352: ; preds = %345
br label %353
353: ; preds = %352
%354 = load volatile float, float* %10
%355 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 0
%356 = load volatile float, float* %355
%357 = getelementptr inbounds { float, float }, { float, float }* %11, i32 0, i32 1
%358 = load volatile float, float* %357
%359 = fadd float %354, %356
%360 = getelementptr inbounds { float, float }, { float, float }* %12, i32 0, i32 0
%361 = getelementptr inbounds { float, float }, { float, float }* %12, i32 0, i32 1
store volatile float %359, float* %360
store volatile float %358, float* %361
br label %362
362: ; preds = %353
%363 = getelementptr inbounds { float, float }, { float, float }* %12, i32 0, i32 0
%364 = load volatile float, float* %363
%365 = getelementptr inbounds { float, float }, { float, float }* %12, i32 0, i32 1
%366 = load volatile float, float* %365
%367 = fcmp une float %364, 0.000000e+00
%368 = fcmp une float %366, 0.000000e+00
%369 = or i1 %367, %368
br i1 %369, label %382, label %370
370: ; preds = %362
%371 = getelementptr inbounds { float, float }, { float, float }* %12, i32 0, i32 0
%372 = load volatile float, float* %371
%373 = call float @llvm.copysign.f32(float 1.000000e+00, float %372)
%374 = fpext float %373 to double
%375 = fcmp une double %374, 1.000000e+00
br i1 %375, label %382, label %376
376: ; preds = %370
%377 = getelementptr inbounds { float, float }, { float, float }* %12, i32 0, i32 1
%378 = load volatile float, float* %377
%379 = call float @llvm.copysign.f32(float 1.000000e+00, float %378)
%380 = fpext float %379 to double
%381 = fcmp une double %380, -1.000000e+00
br i1 %381, label %382, label %383
382: ; preds = %376, %370, %362
unreachable
383: ; preds = %376
br label %384
384: ; preds = %383
br label %385
385: ; preds = %384
br label %386
386: ; preds = %385
store float 0.000000e+00, float* %13
br i1 false, label %387, label %393
387: ; preds = %386
br i1 true, label %388, label %389
388: ; preds = %387
br label %390
389: ; preds = %387
br label %390
390: ; preds = %389, %388
%391 = phi float [ 0.000000e+00, %388 ], [ 0.000000e+00, %389 ]
%392 = phi float [ 0.000000e+00, %388 ], [ -0.000000e+00, %389 ]
br label %399
393: ; preds = %386
br i1 true, label %394, label %395
394: ; preds = %393
br label %396
395: ; preds = %393
br label %396
396: ; preds = %395, %394
%397 = phi float [ -0.000000e+00, %394 ], [ -0.000000e+00, %395 ]
%398 = phi float [ 0.000000e+00, %394 ], [ -0.000000e+00, %395 ]
br label %399
399: ; preds = %396, %390
%400 = phi float [ %391, %390 ], [ %397, %396 ]
%401 = phi float [ %392, %390 ], [ %398, %396 ]
%402 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 0
%403 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 1
store float %400, float* %402
store float %401, float* %403
br label %404
404: ; preds = %399
%405 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 0
%406 = load float, float* %405
%407 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 1
%408 = load float, float* %407
%409 = fcmp une float %406, 0.000000e+00
%410 = fcmp une float %408, 0.000000e+00
%411 = or i1 %409, %410
br i1 %411, label %424, label %412
412: ; preds = %404
%413 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 0
%414 = load float, float* %413
%415 = call float @llvm.copysign.f32(float 1.000000e+00, float %414)
%416 = fpext float %415 to double
%417 = fcmp une double %416, -1.000000e+00
br i1 %417, label %424, label %418
418: ; preds = %412
%419 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 1
%420 = load float, float* %419
%421 = call float @llvm.copysign.f32(float 1.000000e+00, float %420)
%422 = fpext float %421 to double
%423 = fcmp une double %422, 1.000000e+00
br i1 %423, label %424, label %425
424: ; preds = %418, %412, %404
unreachable
425: ; preds = %418
br label %426
426: ; preds = %425
%427 = load float, float* %13
%428 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 0
%429 = load float, float* %428
%430 = getelementptr inbounds { float, float }, { float, float }* %14, i32 0, i32 1
%431 = load float, float* %430
%432 = fadd float %427, %429
%433 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 0
%434 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 1
store float %432, float* %433
store float %431, float* %434
br label %435
435: ; preds = %426
%436 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 0
%437 = load float, float* %436
%438 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 1
%439 = load float, float* %438
%440 = fcmp une float %437, 0.000000e+00
%441 = fcmp une float %439, 0.000000e+00
%442 = or i1 %440, %441
br i1 %442, label %455, label %443
443: ; preds = %435
%444 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 0
%445 = load float, float* %444
%446 = call float @llvm.copysign.f32(float 1.000000e+00, float %445)
%447 = fpext float %446 to double
%448 = fcmp une double %447, 1.000000e+00
br i1 %448, label %455, label %449
449: ; preds = %443
%450 = getelementptr inbounds { float, float }, { float, float }* %15, i32 0, i32 1
%451 = load float, float* %450
%452 = call float @llvm.copysign.f32(float 1.000000e+00, float %451)
%453 = fpext float %452 to double
%454 = fcmp une double %453, 1.000000e+00
br i1 %454, label %455, label %456
455: ; preds = %449, %443, %435
unreachable
456: ; preds = %449
br label %457
457: ; preds = %456
store volatile float 0.000000e+00, float* %16
br i1 false, label %458, label %464
458: ; preds = %457
br i1 true, label %459, label %460
459: ; preds = %458
br label %461
460: ; preds = %458
br label %461
461: ; preds = %460, %459
%462 = phi float [ 0.000000e+00, %459 ], [ 0.000000e+00, %460 ]
%463 = phi float [ 0.000000e+00, %459 ], [ -0.000000e+00, %460 ]
br label %470
464: ; preds = %457
br i1 true, label %465, label %466
465: ; preds = %464
br label %467
466: ; preds = %464
br label %467
467: ; preds = %466, %465
%468 = phi float [ -0.000000e+00, %465 ], [ -0.000000e+00, %466 ]
%469 = phi float [ 0.000000e+00, %465 ], [ -0.000000e+00, %466 ]
br label %470
470: ; preds = %467, %461
%471 = phi float [ %462, %461 ], [ %468, %467 ]
%472 = phi float [ %463, %461 ], [ %469, %467 ]
%473 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 0
%474 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 1
store volatile float %471, float* %473
store volatile float %472, float* %474
br label %475
475: ; preds = %470
%476 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 0
%477 = load volatile float, float* %476
%478 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 1
%479 = load volatile float, float* %478
%480 = fcmp une float %477, 0.000000e+00
%481 = fcmp une float %479, 0.000000e+00
%482 = or i1 %480, %481
br i1 %482, label %495, label %483
483: ; preds = %475
%484 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 0
%485 = load volatile float, float* %484
%486 = call float @llvm.copysign.f32(float 1.000000e+00, float %485)
%487 = fpext float %486 to double
%488 = fcmp une double %487, -1.000000e+00
br i1 %488, label %495, label %489
489: ; preds = %483
%490 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 1
%491 = load volatile float, float* %490
%492 = call float @llvm.copysign.f32(float 1.000000e+00, float %491)
%493 = fpext float %492 to double
%494 = fcmp une double %493, 1.000000e+00
br i1 %494, label %495, label %496
495: ; preds = %489, %483, %475
unreachable
496: ; preds = %489
br label %497
497: ; preds = %496
%498 = load volatile float, float* %16
%499 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 0
%500 = load volatile float, float* %499
%501 = getelementptr inbounds { float, float }, { float, float }* %17, i32 0, i32 1
%502 = load volatile float, float* %501
%503 = fadd float %498, %500
%504 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 0
%505 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 1
store volatile float %503, float* %504
store volatile float %502, float* %505
br label %506
506: ; preds = %497
%507 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 0
%508 = load volatile float, float* %507
%509 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 1
%510 = load volatile float, float* %509
%511 = fcmp une float %508, 0.000000e+00
%512 = fcmp une float %510, 0.000000e+00
%513 = or i1 %511, %512
br i1 %513, label %526, label %514
514: ; preds = %506
%515 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 0
%516 = load volatile float, float* %515
%517 = call float @llvm.copysign.f32(float 1.000000e+00, float %516)
%518 = fpext float %517 to double
%519 = fcmp une double %518, 1.000000e+00
br i1 %519, label %526, label %520
520: ; preds = %514
%521 = getelementptr inbounds { float, float }, { float, float }* %18, i32 0, i32 1
%522 = load volatile float, float* %521
%523 = call float @llvm.copysign.f32(float 1.000000e+00, float %522)
%524 = fpext float %523 to double
%525 = fcmp une double %524, 1.000000e+00
br i1 %525, label %526, label %527
526: ; preds = %520, %514, %506
unreachable
527: ; preds = %520
br label %528
528: ; preds = %527
br label %529
529: ; preds = %528
br label %530
530: ; preds = %529
store float 0.000000e+00, float* %19
br i1 false, label %531, label %537
531: ; preds = %530
br i1 false, label %532, label %533
532: ; preds = %531
br label %534
533: ; preds = %531
br label %534
534: ; preds = %533, %532
%535 = phi float [ 0.000000e+00, %532 ], [ 0.000000e+00, %533 ]
%536 = phi float [ 0.000000e+00, %532 ], [ -0.000000e+00, %533 ]
br label %543
537: ; preds = %530
br i1 false, label %538, label %539
538: ; preds = %537
br label %540
539: ; preds = %537
br label %540
540: ; preds = %539, %538
%541 = phi float [ -0.000000e+00, %538 ], [ -0.000000e+00, %539 ]
%542 = phi float [ 0.000000e+00, %538 ], [ -0.000000e+00, %539 ]
br label %543
543: ; preds = %540, %534
%544 = phi float [ %535, %534 ], [ %541, %540 ]
%545 = phi float [ %536, %534 ], [ %542, %540 ]
%546 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 0
%547 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 1
store float %544, float* %546
store float %545, float* %547
br label %548
548: ; preds = %543
%549 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 0
%550 = load float, float* %549
%551 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 1
%552 = load float, float* %551
%553 = fcmp une float %550, 0.000000e+00
%554 = fcmp une float %552, 0.000000e+00
%555 = or i1 %553, %554
br i1 %555, label %568, label %556
556: ; preds = %548
%557 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 0
%558 = load float, float* %557
%559 = call float @llvm.copysign.f32(float 1.000000e+00, float %558)
%560 = fpext float %559 to double
%561 = fcmp une double %560, -1.000000e+00
br i1 %561, label %568, label %562
562: ; preds = %556
%563 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 1
%564 = load float, float* %563
%565 = call float @llvm.copysign.f32(float 1.000000e+00, float %564)
%566 = fpext float %565 to double
%567 = fcmp une double %566, -1.000000e+00
br i1 %567, label %568, label %569
568: ; preds = %562, %556, %548
unreachable
569: ; preds = %562
br label %570
570: ; preds = %569
%571 = load float, float* %19
%572 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 0
%573 = load float, float* %572
%574 = getelementptr inbounds { float, float }, { float, float }* %20, i32 0, i32 1
%575 = load float, float* %574
%576 = fadd float %571, %573
%577 = getelementptr inbounds { float, float }, { float, float }* %21, i32 0, i32 0
%578 = getelementptr inbounds { float, float }, { float, float }* %21, i32 0, i32 1
store float %576, float* %577
store float %575, float* %578
br label %579
579: ; preds = %570
%580 = getelementptr inbounds { float, float }, { float, float }* %21, i32 0, i32 0
%581 = load float, float* %580
%582 = getelementptr inbounds { float, float }, { float, float }* %21, i32 0, i32 1
%583 = load float, float* %582
%584 = fcmp une float %581, 0.000000e+00
%585 = fcmp une float %583, 0.000000e+00
%586 = or i1 %584, %585
br i1 %586, label %599, label %587
587: ; preds = %579
%588 = getelementptr inbounds { float, float }, { float, float }* %21, i32 0, i32 0
%589 = load float, float* %588
%590 = call float @llvm.copysign.f32(float 1.000000e+00, float %589)
%591 = fpext float %590 to double
%592 = fcmp une double %591, 1.000000e+00
br i1 %592, label %599, label %593
593: ; preds = %587
%594 = getelementptr inbounds { float, float }, { float, float }* %21, i32 0, i32 1
%595 = load float, float* %594
%596 = call float @llvm.copysign.f32(float 1.000000e+00, float %595)
%597 = fpext float %596 to double
%598 = fcmp une double %597, -1.000000e+00
br i1 %598, label %599, label %600
599: ; preds = %593, %587, %579
unreachable
600: ; preds = %593
br label %601
601: ; preds = %600
store volatile float 0.000000e+00, float* %22
br i1 false, label %602, label %608
602: ; preds = %601
br i1 false, label %603, label %604
603: ; preds = %602
br label %605
604: ; preds = %602
br label %605
605: ; preds = %604, %603
%606 = phi float [ 0.000000e+00, %603 ], [ 0.000000e+00, %604 ]
%607 = phi float [ 0.000000e+00, %603 ], [ -0.000000e+00, %604 ]
br label %614
608: ; preds = %601
br i1 false, label %609, label %610
609: ; preds = %608
br label %611
610: ; preds = %608
br label %611
611: ; preds = %610, %609
%612 = phi float [ -0.000000e+00, %609 ], [ -0.000000e+00, %610 ]
%613 = phi float [ 0.000000e+00, %609 ], [ -0.000000e+00, %610 ]
br label %614
614: ; preds = %611, %605
%615 = phi float [ %606, %605 ], [ %612, %611 ]
%616 = phi float [ %607, %605 ], [ %613, %611 ]
%617 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 0
%618 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 1
store volatile float %615, float* %617
store volatile float %616, float* %618
br label %619
619: ; preds = %614
%620 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 0
%621 = load volatile float, float* %620
%622 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 1
%623 = load volatile float, float* %622
%624 = fcmp une float %621, 0.000000e+00
%625 = fcmp une float %623, 0.000000e+00
%626 = or i1 %624, %625
br i1 %626, label %639, label %627
627: ; preds = %619
%628 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 0
%629 = load volatile float, float* %628
%630 = call float @llvm.copysign.f32(float 1.000000e+00, float %629)
%631 = fpext float %630 to double
%632 = fcmp une double %631, -1.000000e+00
br i1 %632, label %639, label %633
633: ; preds = %627
%634 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 1
%635 = load volatile float, float* %634
%636 = call float @llvm.copysign.f32(float 1.000000e+00, float %635)
%637 = fpext float %636 to double
%638 = fcmp une double %637, -1.000000e+00
br i1 %638, label %639, label %640
639: ; preds = %633, %627, %619
unreachable
640: ; preds = %633
br label %641
641: ; preds = %640
%642 = load volatile float, float* %22
%643 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 0
%644 = load volatile float, float* %643
%645 = getelementptr inbounds { float, float }, { float, float }* %23, i32 0, i32 1
%646 = load volatile float, float* %645
%647 = fadd float %642, %644
%648 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 0
%649 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 1
store volatile float %647, float* %648
store volatile float %646, float* %649
br label %650
650: ; preds = %641
%651 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 0
%652 = load volatile float, float* %651
%653 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 1
%654 = load volatile float, float* %653
%655 = fcmp une float %652, 0.000000e+00
%656 = fcmp une float %654, 0.000000e+00
%657 = or i1 %655, %656
br i1 %657, label %670, label %658
658: ; preds = %650
%659 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 0
%660 = load volatile float, float* %659
%661 = call float @llvm.copysign.f32(float 1.000000e+00, float %660)
%662 = fpext float %661 to double
%663 = fcmp une double %662, 1.000000e+00
br i1 %663, label %670, label %664
664: ; preds = %658
%665 = getelementptr inbounds { float, float }, { float, float }* %24, i32 0, i32 1
%666 = load volatile float, float* %665
%667 = call float @llvm.copysign.f32(float 1.000000e+00, float %666)
%668 = fpext float %667 to double
%669 = fcmp une double %668, -1.000000e+00
br i1 %669, label %670, label %671
670: ; preds = %664, %658, %650
unreachable
671: ; preds = %664
br label %672
672: ; preds = %671
br label %673
673: ; preds = %672
br label %674
674: ; preds = %673
store float -0.000000e+00, float* %25
br i1 true, label %675, label %681
675: ; preds = %674
br i1 true, label %676, label %677
676: ; preds = %675
br label %678
677: ; preds = %675
br label %678
678: ; preds = %677, %676
%679 = phi float [ 0.000000e+00, %676 ], [ 0.000000e+00, %677 ]
%680 = phi float [ 0.000000e+00, %676 ], [ -0.000000e+00, %677 ]
br label %687
681: ; preds = %674
br i1 true, label %682, label %683
682: ; preds = %681
br label %684
683: ; preds = %681
br label %684
684: ; preds = %683, %682
%685 = phi float [ -0.000000e+00, %682 ], [ -0.000000e+00, %683 ]
%686 = phi float [ 0.000000e+00, %682 ], [ -0.000000e+00, %683 ]
br label %687
687: ; preds = %684, %678
%688 = phi float [ %679, %678 ], [ %685, %684 ]
%689 = phi float [ %680, %678 ], [ %686, %684 ]
%690 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 0
%691 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 1
store float %688, float* %690
store float %689, float* %691
br label %692
692: ; preds = %687
%693 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 0
%694 = load float, float* %693
%695 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 1
%696 = load float, float* %695
%697 = fcmp une float %694, 0.000000e+00
%698 = fcmp une float %696, 0.000000e+00
%699 = or i1 %697, %698
br i1 %699, label %712, label %700
700: ; preds = %692
%701 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 0
%702 = load float, float* %701
%703 = call float @llvm.copysign.f32(float 1.000000e+00, float %702)
%704 = fpext float %703 to double
%705 = fcmp une double %704, 1.000000e+00
br i1 %705, label %712, label %706
706: ; preds = %700
%707 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 1
%708 = load float, float* %707
%709 = call float @llvm.copysign.f32(float 1.000000e+00, float %708)
%710 = fpext float %709 to double
%711 = fcmp une double %710, 1.000000e+00
br i1 %711, label %712, label %713
712: ; preds = %706, %700, %692
unreachable
713: ; preds = %706
br label %714
714: ; preds = %713
%715 = load float, float* %25
%716 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 0
%717 = load float, float* %716
%718 = getelementptr inbounds { float, float }, { float, float }* %26, i32 0, i32 1
%719 = load float, float* %718
%720 = fadd float %715, %717
%721 = getelementptr inbounds { float, float }, { float, float }* %27, i32 0, i32 0
%722 = getelementptr inbounds { float, float }, { float, float }* %27, i32 0, i32 1
store float %720, float* %721
store float %719, float* %722
br label %723
723: ; preds = %714
%724 = getelementptr inbounds { float, float }, { float, float }* %27, i32 0, i32 0
%725 = load float, float* %724
%726 = getelementptr inbounds { float, float }, { float, float }* %27, i32 0, i32 1
%727 = load float, float* %726
%728 = fcmp une float %725, 0.000000e+00
%729 = fcmp une float %727, 0.000000e+00
%730 = or i1 %728, %729
br i1 %730, label %743, label %731
731: ; preds = %723
%732 = getelementptr inbounds { float, float }, { float, float }* %27, i32 0, i32 0
%733 = load float, float* %732
%734 = call float @llvm.copysign.f32(float 1.000000e+00, float %733)
%735 = fpext float %734 to double
%736 = fcmp une double %735, 1.000000e+00
br i1 %736, label %743, label %737
737: ; preds = %731
%738 = getelementptr inbounds { float, float }, { float, float }* %27, i32 0, i32 1
%739 = load float, float* %738
%740 = call float @llvm.copysign.f32(float 1.000000e+00, float %739)
%741 = fpext float %740 to double
%742 = fcmp une double %741, 1.000000e+00
br i1 %742, label %743, label %744
743: ; preds = %737, %731, %723
unreachable
744: ; preds = %737
br label %745
745: ; preds = %744
store volatile float -0.000000e+00, float* %28
br i1 true, label %746, label %752
746: ; preds = %745
br i1 true, label %747, label %748
747: ; preds = %746
br label %749
748: ; preds = %746
br label %749
749: ; preds = %748, %747
%750 = phi float [ 0.000000e+00, %747 ], [ 0.000000e+00, %748 ]
%751 = phi float [ 0.000000e+00, %747 ], [ -0.000000e+00, %748 ]
br label %758
752: ; preds = %745
br i1 true, label %753, label %754
753: ; preds = %752
br label %755
754: ; preds = %752
br label %755
755: ; preds = %754, %753
%756 = phi float [ -0.000000e+00, %753 ], [ -0.000000e+00, %754 ]
%757 = phi float [ 0.000000e+00, %753 ], [ -0.000000e+00, %754 ]
br label %758
758: ; preds = %755, %749
%759 = phi float [ %750, %749 ], [ %756, %755 ]
%760 = phi float [ %751, %749 ], [ %757, %755 ]
%761 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 0
%762 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 1
store volatile float %759, float* %761
store volatile float %760, float* %762
br label %763
763: ; preds = %758
%764 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 0
%765 = load volatile float, float* %764
%766 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 1
%767 = load volatile float, float* %766
%768 = fcmp une float %765, 0.000000e+00
%769 = fcmp une float %767, 0.000000e+00
%770 = or i1 %768, %769
br i1 %770, label %783, label %771
771: ; preds = %763
%772 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 0
%773 = load volatile float, float* %772
%774 = call float @llvm.copysign.f32(float 1.000000e+00, float %773)
%775 = fpext float %774 to double
%776 = fcmp une double %775, 1.000000e+00
br i1 %776, label %783, label %777
777: ; preds = %771
%778 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 1
%779 = load volatile float, float* %778
%780 = call float @llvm.copysign.f32(float 1.000000e+00, float %779)
%781 = fpext float %780 to double
%782 = fcmp une double %781, 1.000000e+00
br i1 %782, label %783, label %784
783: ; preds = %777, %771, %763
unreachable
784: ; preds = %777
br label %785
785: ; preds = %784
%786 = load volatile float, float* %28
%787 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 0
%788 = load volatile float, float* %787
%789 = getelementptr inbounds { float, float }, { float, float }* %29, i32 0, i32 1
%790 = load volatile float, float* %789
%791 = fadd float %786, %788
%792 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 0
%793 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 1
store volatile float %791, float* %792
store volatile float %790, float* %793
br label %794
794: ; preds = %785
%795 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 0
%796 = load volatile float, float* %795
%797 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 1
%798 = load volatile float, float* %797
%799 = fcmp une float %796, 0.000000e+00
%800 = fcmp une float %798, 0.000000e+00
%801 = or i1 %799, %800
br i1 %801, label %814, label %802
802: ; preds = %794
%803 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 0
%804 = load volatile float, float* %803
%805 = call float @llvm.copysign.f32(float 1.000000e+00, float %804)
%806 = fpext float %805 to double
%807 = fcmp une double %806, 1.000000e+00
br i1 %807, label %814, label %808
808: ; preds = %802
%809 = getelementptr inbounds { float, float }, { float, float }* %30, i32 0, i32 1
%810 = load volatile float, float* %809
%811 = call float @llvm.copysign.f32(float 1.000000e+00, float %810)
%812 = fpext float %811 to double
%813 = fcmp une double %812, 1.000000e+00
br i1 %813, label %814, label %815
814: ; preds = %808, %802, %794
unreachable
815: ; preds = %808
br label %816
816: ; preds = %815
br label %817
817: ; preds = %816
br label %818
818: ; preds = %817
store float -0.000000e+00, float* %31
br i1 true, label %819, label %825
819: ; preds = %818
br i1 false, label %820, label %821
820: ; preds = %819
br label %822
821: ; preds = %819
br label %822
822: ; preds = %821, %820
%823 = phi float [ 0.000000e+00, %820 ], [ 0.000000e+00, %821 ]
%824 = phi float [ 0.000000e+00, %820 ], [ -0.000000e+00, %821 ]
br label %831
825: ; preds = %818
br i1 false, label %826, label %827
826: ; preds = %825
br label %828
827: ; preds = %825
br label %828
828: ; preds = %827, %826
%829 = phi float [ -0.000000e+00, %826 ], [ -0.000000e+00, %827 ]
%830 = phi float [ 0.000000e+00, %826 ], [ -0.000000e+00, %827 ]
br label %831
831: ; preds = %828, %822
%832 = phi float [ %823, %822 ], [ %829, %828 ]
%833 = phi float [ %824, %822 ], [ %830, %828 ]
%834 = getelementptr inbounds { float, float }, { float, float }* %32, i32 0, i32 0
%835 = getelementptr inbounds { float, float }, { float, float }* %32, i32 0, i32 1
store float %832, float* %834
store float %833, float* %835
br label %836
836: ; preds = %831
%837 = getelementptr inbounds { float, float }, { float, float }* %32, i32 0, i32 0
%838 = load float, float* %837
%839 = getelementptr inbounds { float, float }, { float, float }* %32, i32 0, i32 1
%840 = load float, float* %839
%841 = fcmp une float %838, 0.000000e+00
%842 = fcmp une float %840, 0.000000e+00
%843 = or i1 %841, %842
br i1 %843, label %856, label %844
844: ; preds = %836
%845 = getelementptr inbounds { float, float }, { float, float }* %32, i32 0, i32 0
%846 = load float, float* %845
%847 = call float @llvm.copysign.f32(float 1.000000e+00, float %846)
%848 = fpext float %847 to double
%849 = fcmp une double %848, 1.000000e+00
br i1 %849, label %856, label %850
850: ; preds = %844
%851 = getelementptr inbounds { float, float }, { float, float }* %32, i32 0, i32 1
%852 = load float, float* %851
%853 = call float @llvm.copysign.f32(float 1.000000e+00, float %852)
%854 = fpext float %853 to double
%855 = fcmp une double %854, -1.000000e+00
br i1 %855, label %856, label %857
856: ; preds = %850, %844, %836
unreachable
857: ; preds = %850
br label %858
858: ; preds = %857
%859 = load float, float* %31
%860 = getelementptr inbounds { float, float }, { float, float }* %32, i32 0, i32 0
%861 = load float, float* %860
%862 = getelementptr inbounds { float, float }, { float, float }* %32, i32 0, i32 1
%863 = load float, float* %862
%864 = fadd float %859, %861
%865 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 0
%866 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 1
store float %864, float* %865
store float %863, float* %866
br label %867
867: ; preds = %858
%868 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 0
%869 = load float, float* %868
%870 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 1
%871 = load float, float* %870
%872 = fcmp une float %869, 0.000000e+00
%873 = fcmp une float %871, 0.000000e+00
%874 = or i1 %872, %873
br i1 %874, label %887, label %875
875: ; preds = %867
%876 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 0
%877 = load float, float* %876
%878 = call float @llvm.copysign.f32(float 1.000000e+00, float %877)
%879 = fpext float %878 to double
%880 = fcmp une double %879, 1.000000e+00
br i1 %880, label %887, label %881
881: ; preds = %875
%882 = getelementptr inbounds { float, float }, { float, float }* %33, i32 0, i32 1
%883 = load float, float* %882
%884 = call float @llvm.copysign.f32(float 1.000000e+00, float %883)
%885 = fpext float %884 to double
%886 = fcmp une double %885, -1.000000e+00
br i1 %886, label %887, label %888
887: ; preds = %881, %875, %867
unreachable
888: ; preds = %881
br label %889
889: ; preds = %888
store volatile float -0.000000e+00, float* %34
br i1 true, label %890, label %896
890: ; preds = %889
br i1 false, label %891, label %892
891: ; preds = %890
br label %893
892: ; preds = %890
br label %893
893: ; preds = %892, %891
%894 = phi float [ 0.000000e+00, %891 ], [ 0.000000e+00, %892 ]
%895 = phi float [ 0.000000e+00, %891 ], [ -0.000000e+00, %892 ]
br label %902
896: ; preds = %889
br i1 false, label %897, label %898
897: ; preds = %896
br label %899
898: ; preds = %896
br label %899
899: ; preds = %898, %897
%900 = phi float [ -0.000000e+00, %897 ], [ -0.000000e+00, %898 ]
%901 = phi float [ 0.000000e+00, %897 ], [ -0.000000e+00, %898 ]
br label %902
902: ; preds = %899, %893
%903 = phi float [ %894, %893 ], [ %900, %899 ]
%904 = phi float [ %895, %893 ], [ %901, %899 ]
%905 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 0
%906 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 1
store volatile float %903, float* %905
store volatile float %904, float* %906
br label %907
907: ; preds = %902
%908 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 0
%909 = load volatile float, float* %908
%910 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 1
%911 = load volatile float, float* %910
%912 = fcmp une float %909, 0.000000e+00
%913 = fcmp une float %911, 0.000000e+00
%914 = or i1 %912, %913
br i1 %914, label %927, label %915
915: ; preds = %907
%916 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 0
%917 = load volatile float, float* %916
%918 = call float @llvm.copysign.f32(float 1.000000e+00, float %917)
%919 = fpext float %918 to double
%920 = fcmp une double %919, 1.000000e+00
br i1 %920, label %927, label %921
921: ; preds = %915
%922 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 1
%923 = load volatile float, float* %922
%924 = call float @llvm.copysign.f32(float 1.000000e+00, float %923)
%925 = fpext float %924 to double
%926 = fcmp une double %925, -1.000000e+00
br i1 %926, label %927, label %928
927: ; preds = %921, %915, %907
unreachable
928: ; preds = %921
br label %929
929: ; preds = %928
%930 = load volatile float, float* %34
%931 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 0
%932 = load volatile float, float* %931
%933 = getelementptr inbounds { float, float }, { float, float }* %35, i32 0, i32 1
%934 = load volatile float, float* %933
%935 = fadd float %930, %932
%936 = getelementptr inbounds { float, float }, { float, float }* %36, i32 0, i32 0
%937 = getelementptr inbounds { float, float }, { float, float }* %36, i32 0, i32 1
store volatile float %935, float* %936
store volatile float %934, float* %937
br label %938
938: ; preds = %929
%939 = getelementptr inbounds { float, float }, { float, float }* %36, i32 0, i32 0
%940 = load volatile float, float* %939
%941 = getelementptr inbounds { float, float }, { float, float }* %36, i32 0, i32 1
%942 = load volatile float, float* %941
%943 = fcmp une float %940, 0.000000e+00
%944 = fcmp une float %942, 0.000000e+00
%945 = or i1 %943, %944
br i1 %945, label %958, label %946
946: ; preds = %938
%947 = getelementptr inbounds { float, float }, { float, float }* %36, i32 0, i32 0
%948 = load volatile float, float* %947
%949 = call float @llvm.copysign.f32(float 1.000000e+00, float %948)
%950 = fpext float %949 to double
%951 = fcmp une double %950, 1.000000e+00
br i1 %951, label %958, label %952
952: ; preds = %946
%953 = getelementptr inbounds { float, float }, { float, float }* %36, i32 0, i32 1
%954 = load volatile float, float* %953
%955 = call float @llvm.copysign.f32(float 1.000000e+00, float %954)
%956 = fpext float %955 to double
%957 = fcmp une double %956, -1.000000e+00
br i1 %957, label %958, label %959
958: ; preds = %952, %946, %938
unreachable
959: ; preds = %952
br label %960
960: ; preds = %959
br label %961
961: ; preds = %960
br label %962
962: ; preds = %961
store float -0.000000e+00, float* %37
br i1 false, label %963, label %969
963: ; preds = %962
br i1 true, label %964, label %965
964: ; preds = %963
br label %966
965: ; preds = %963
br label %966
966: ; preds = %965, %964
%967 = phi float [ 0.000000e+00, %964 ], [ 0.000000e+00, %965 ]
%968 = phi float [ 0.000000e+00, %964 ], [ -0.000000e+00, %965 ]
br label %975
969: ; preds = %962
br i1 true, label %970, label %971
970: ; preds = %969
br label %972
971: ; preds = %969
br label %972
972: ; preds = %971, %970
%973 = phi float [ -0.000000e+00, %970 ], [ -0.000000e+00, %971 ]
%974 = phi float [ 0.000000e+00, %970 ], [ -0.000000e+00, %971 ]
br label %975
975: ; preds = %972, %966
%976 = phi float [ %967, %966 ], [ %973, %972 ]
%977 = phi float [ %968, %966 ], [ %974, %972 ]
%978 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 0
%979 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 1
store float %976, float* %978
store float %977, float* %979
br label %980
980: ; preds = %975
%981 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 0
%982 = load float, float* %981
%983 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 1
%984 = load float, float* %983
%985 = fcmp une float %982, 0.000000e+00
%986 = fcmp une float %984, 0.000000e+00
%987 = or i1 %985, %986
br i1 %987, label %1000, label %988
988: ; preds = %980
%989 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 0
%990 = load float, float* %989
%991 = call float @llvm.copysign.f32(float 1.000000e+00, float %990)
%992 = fpext float %991 to double
%993 = fcmp une double %992, -1.000000e+00
br i1 %993, label %1000, label %994
994: ; preds = %988
%995 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 1
%996 = load float, float* %995
%997 = call float @llvm.copysign.f32(float 1.000000e+00, float %996)
%998 = fpext float %997 to double
%999 = fcmp une double %998, 1.000000e+00
br i1 %999, label %1000, label %1001
1000: ; preds = %994, %988, %980
unreachable
1001: ; preds = %994
br label %1002
1002: ; preds = %1001
%1003 = load float, float* %37
%1004 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 0
%1005 = load float, float* %1004
%1006 = getelementptr inbounds { float, float }, { float, float }* %38, i32 0, i32 1
%1007 = load float, float* %1006
%1008 = fadd float %1003, %1005
%1009 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 0
%1010 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 1
store float %1008, float* %1009
store float %1007, float* %1010
br label %1011
1011: ; preds = %1002
%1012 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 0
%1013 = load float, float* %1012
%1014 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 1
%1015 = load float, float* %1014
%1016 = fcmp une float %1013, 0.000000e+00
%1017 = fcmp une float %1015, 0.000000e+00
%1018 = or i1 %1016, %1017
br i1 %1018, label %1031, label %1019
1019: ; preds = %1011
%1020 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 0
%1021 = load float, float* %1020
%1022 = call float @llvm.copysign.f32(float 1.000000e+00, float %1021)
%1023 = fpext float %1022 to double
%1024 = fcmp une double %1023, -1.000000e+00
br i1 %1024, label %1031, label %1025
1025: ; preds = %1019
%1026 = getelementptr inbounds { float, float }, { float, float }* %39, i32 0, i32 1
%1027 = load float, float* %1026
%1028 = call float @llvm.copysign.f32(float 1.000000e+00, float %1027)
%1029 = fpext float %1028 to double
%1030 = fcmp une double %1029, 1.000000e+00
br i1 %1030, label %1031, label %1032
1031: ; preds = %1025, %1019, %1011
unreachable
1032: ; preds = %1025
br label %1033
1033: ; preds = %1032
store volatile float -0.000000e+00, float* %40
br i1 false, label %1034, label %1040
1034: ; preds = %1033
br i1 true, label %1035, label %1036
1035: ; preds = %1034
br label %1037
1036: ; preds = %1034
br label %1037
1037: ; preds = %1036, %1035
%1038 = phi float [ 0.000000e+00, %1035 ], [ 0.000000e+00, %1036 ]
%1039 = phi float [ 0.000000e+00, %1035 ], [ -0.000000e+00, %1036 ]
br label %1046
1040: ; preds = %1033
br i1 true, label %1041, label %1042
1041: ; preds = %1040
br label %1043
1042: ; preds = %1040
br label %1043
1043: ; preds = %1042, %1041
%1044 = phi float [ -0.000000e+00, %1041 ], [ -0.000000e+00, %1042 ]
%1045 = phi float [ 0.000000e+00, %1041 ], [ -0.000000e+00, %1042 ]
br label %1046
1046: ; preds = %1043, %1037
%1047 = phi float [ %1038, %1037 ], [ %1044, %1043 ]
%1048 = phi float [ %1039, %1037 ], [ %1045, %1043 ]
%1049 = getelementptr inbounds { float, float }, { float, float }* %41, i32 0, i32 0
%1050 = getelementptr inbounds { float, float }, { float, float }* %41, i32 0, i32 1
store volatile float %1047, float* %1049
store volatile float %1048, float* %1050
br label %1051
1051: ; preds = %1046
%1052 = getelementptr inbounds { float, float }, { float, float }* %41, i32 0, i32 0
%1053 = load volatile float, float* %1052
%1054 = getelementptr inbounds { float, float }, { float, float }* %41, i32 0, i32 1
%1055 = load volatile float, float* %1054
%1056 = fcmp une float %1053, 0.000000e+00
%1057 = fcmp une float %1055, 0.000000e+00
%1058 = or i1 %1056, %1057
br i1 %1058, label %1071, label %1059
1059: ; preds = %1051
%1060 = getelementptr inbounds { float, float }, { float, float }* %41, i32 0, i32 0
%1061 = load volatile float, float* %1060
%1062 = call float @llvm.copysign.f32(float 1.000000e+00, float %1061)
%1063 = fpext float %1062 to double
%1064 = fcmp une double %1063, -1.000000e+00
br i1 %1064, label %1071, label %1065
1065: ; preds = %1059
%1066 = getelementptr inbounds { float, float }, { float, float }* %41, i32 0, i32 1
%1067 = load volatile float, float* %1066
%1068 = call float @llvm.copysign.f32(float 1.000000e+00, float %1067)
%1069 = fpext float %1068 to double
%1070 = fcmp une double %1069, 1.000000e+00
br i1 %1070, label %1071, label %1072
1071: ; preds = %1065, %1059, %1051
unreachable
1072: ; preds = %1065
br label %1073
1073: ; preds = %1072
%1074 = load volatile float, float* %40
%1075 = getelementptr inbounds { float, float }, { float, float }* %41, i32 0, i32 0
%1076 = load volatile float, float* %1075
%1077 = getelementptr inbounds { float, float }, { float, float }* %41, i32 0, i32 1
%1078 = load volatile float, float* %1077
%1079 = fadd float %1074, %1076
%1080 = getelementptr inbounds { float, float }, { float, float }* %42, i32 0, i32 0
%1081 = getelementptr inbounds { float, float }, { float, float }* %42, i32 0, i32 1
store volatile float %1079, float* %1080
store volatile float %1078, float* %1081
br label %1082
1082: ; preds = %1073
%1083 = getelementptr inbounds { float, float }, { float, float }* %42, i32 0, i32 0
%1084 = load volatile float, float* %1083
%1085 = getelementptr inbounds { float, float }, { float, float }* %42, i32 0, i32 1
%1086 = load volatile float, float* %1085
%1087 = fcmp une float %1084, 0.000000e+00
%1088 = fcmp une float %1086, 0.000000e+00
%1089 = or i1 %1087, %1088
br i1 %1089, label %1102, label %1090
1090: ; preds = %1082
%1091 = getelementptr inbounds { float, float }, { float, float }* %42, i32 0, i32 0
%1092 = load volatile float, float* %1091
%1093 = call float @llvm.copysign.f32(float 1.000000e+00, float %1092)
%1094 = fpext float %1093 to double
%1095 = fcmp une double %1094, -1.000000e+00
br i1 %1095, label %1102, label %1096
1096: ; preds = %1090
%1097 = getelementptr inbounds { float, float }, { float, float }* %42, i32 0, i32 1
%1098 = load volatile float, float* %1097
%1099 = call float @llvm.copysign.f32(float 1.000000e+00, float %1098)
%1100 = fpext float %1099 to double
%1101 = fcmp une double %1100, 1.000000e+00
br i1 %1101, label %1102, label %1103
1102: ; preds = %1096, %1090, %1082
unreachable
1103: ; preds = %1096
br label %1104
1104: ; preds = %1103
br label %1105
1105: ; preds = %1104
br label %1106
1106: ; preds = %1105
store float -0.000000e+00, float* %43
br i1 false, label %1107, label %1113
1107: ; preds = %1106
br i1 false, label %1108, label %1109
1108: ; preds = %1107
br label %1110
1109: ; preds = %1107
br label %1110
1110: ; preds = %1109, %1108
%1111 = phi float [ 0.000000e+00, %1108 ], [ 0.000000e+00, %1109 ]
%1112 = phi float [ 0.000000e+00, %1108 ], [ -0.000000e+00, %1109 ]
br label %1119
1113: ; preds = %1106
br i1 false, label %1114, label %1115
1114: ; preds = %1113
br label %1116
1115: ; preds = %1113
br label %1116
1116: ; preds = %1115, %1114
%1117 = phi float [ -0.000000e+00, %1114 ], [ -0.000000e+00, %1115 ]
%1118 = phi float [ 0.000000e+00, %1114 ], [ -0.000000e+00, %1115 ]
br label %1119
1119: ; preds = %1116, %1110
%1120 = phi float [ %1111, %1110 ], [ %1117, %1116 ]
%1121 = phi float [ %1112, %1110 ], [ %1118, %1116 ]
%1122 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 0
%1123 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 1
store float %1120, float* %1122
store float %1121, float* %1123
br label %1124
1124: ; preds = %1119
%1125 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 0
%1126 = load float, float* %1125
%1127 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 1
%1128 = load float, float* %1127
%1129 = fcmp une float %1126, 0.000000e+00
%1130 = fcmp une float %1128, 0.000000e+00
%1131 = or i1 %1129, %1130
br i1 %1131, label %1144, label %1132
1132: ; preds = %1124
%1133 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 0
%1134 = load float, float* %1133
%1135 = call float @llvm.copysign.f32(float 1.000000e+00, float %1134)
%1136 = fpext float %1135 to double
%1137 = fcmp une double %1136, -1.000000e+00
br i1 %1137, label %1144, label %1138
1138: ; preds = %1132
%1139 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 1
%1140 = load float, float* %1139
%1141 = call float @llvm.copysign.f32(float 1.000000e+00, float %1140)
%1142 = fpext float %1141 to double
%1143 = fcmp une double %1142, -1.000000e+00
br i1 %1143, label %1144, label %1145
1144: ; preds = %1138, %1132, %1124
unreachable
1145: ; preds = %1138
br label %1146
1146: ; preds = %1145
%1147 = load float, float* %43
%1148 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 0
%1149 = load float, float* %1148
%1150 = getelementptr inbounds { float, float }, { float, float }* %44, i32 0, i32 1
%1151 = load float, float* %1150
%1152 = fadd float %1147, %1149
%1153 = getelementptr inbounds { float, float }, { float, float }* %45, i32 0, i32 0
%1154 = getelementptr inbounds { float, float }, { float, float }* %45, i32 0, i32 1
store float %1152, float* %1153
store float %1151, float* %1154
br label %1155
1155: ; preds = %1146
%1156 = getelementptr inbounds { float, float }, { float, float }* %45, i32 0, i32 0
%1157 = load float, float* %1156
%1158 = getelementptr inbounds { float, float }, { float, float }* %45, i32 0, i32 1
%1159 = load float, float* %1158
%1160 = fcmp une float %1157, 0.000000e+00
%1161 = fcmp une float %1159, 0.000000e+00
%1162 = or i1 %1160, %1161
br i1 %1162, label %1175, label %1163
1163: ; preds = %1155
%1164 = getelementptr inbounds { float, float }, { float, float }* %45, i32 0, i32 0
%1165 = load float, float* %1164
%1166 = call float @llvm.copysign.f32(float 1.000000e+00, float %1165)
%1167 = fpext float %1166 to double
%1168 = fcmp une double %1167, -1.000000e+00
br i1 %1168, label %1175, label %1169
1169: ; preds = %1163
%1170 = getelementptr inbounds { float, float }, { float, float }* %45, i32 0, i32 1
%1171 = load float, float* %1170
%1172 = call float @llvm.copysign.f32(float 1.000000e+00, float %1171)
%1173 = fpext float %1172 to double
%1174 = fcmp une double %1173, -1.000000e+00
br i1 %1174, label %1175, label %1176
1175: ; preds = %1169, %1163, %1155
unreachable
1176: ; preds = %1169
br label %1177
1177: ; preds = %1176
store volatile float -0.000000e+00, float* %46
br i1 false, label %1178, label %1184
1178: ; preds = %1177
br i1 false, label %1179, label %1180
1179: ; preds = %1178
br label %1181
1180: ; preds = %1178
br label %1181
1181: ; preds = %1180, %1179
%1182 = phi float [ 0.000000e+00, %1179 ], [ 0.000000e+00, %1180 ]
%1183 = phi float [ 0.000000e+00, %1179 ], [ -0.000000e+00, %1180 ]
br label %1190
1184: ; preds = %1177
br i1 false, label %1185, label %1186
1185: ; preds = %1184
br label %1187
1186: ; preds = %1184
br label %1187
1187: ; preds = %1186, %1185
%1188 = phi float [ -0.000000e+00, %1185 ], [ -0.000000e+00, %1186 ]
%1189 = phi float [ 0.000000e+00, %1185 ], [ -0.000000e+00, %1186 ]
br label %1190
1190: ; preds = %1187, %1181
%1191 = phi float [ %1182, %1181 ], [ %1188, %1187 ]
%1192 = phi float [ %1183, %1181 ], [ %1189, %1187 ]
%1193 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 0
%1194 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 1
store volatile float %1191, float* %1193
store volatile float %1192, float* %1194
br label %1195
1195: ; preds = %1190
%1196 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 0
%1197 = load volatile float, float* %1196
%1198 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 1
%1199 = load volatile float, float* %1198
%1200 = fcmp une float %1197, 0.000000e+00
%1201 = fcmp une float %1199, 0.000000e+00
%1202 = or i1 %1200, %1201
br i1 %1202, label %1215, label %1203
1203: ; preds = %1195
%1204 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 0
%1205 = load volatile float, float* %1204
%1206 = call float @llvm.copysign.f32(float 1.000000e+00, float %1205)
%1207 = fpext float %1206 to double
%1208 = fcmp une double %1207, -1.000000e+00
br i1 %1208, label %1215, label %1209
1209: ; preds = %1203
%1210 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 1
%1211 = load volatile float, float* %1210
%1212 = call float @llvm.copysign.f32(float 1.000000e+00, float %1211)
%1213 = fpext float %1212 to double
%1214 = fcmp une double %1213, -1.000000e+00
br i1 %1214, label %1215, label %1216
1215: ; preds = %1209, %1203, %1195
unreachable
1216: ; preds = %1209
br label %1217
1217: ; preds = %1216
%1218 = load volatile float, float* %46
%1219 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 0
%1220 = load volatile float, float* %1219
%1221 = getelementptr inbounds { float, float }, { float, float }* %47, i32 0, i32 1
%1222 = load volatile float, float* %1221
%1223 = fadd float %1218, %1220
%1224 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 0
%1225 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 1
store volatile float %1223, float* %1224
store volatile float %1222, float* %1225
br label %1226
1226: ; preds = %1217
%1227 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 0
%1228 = load volatile float, float* %1227
%1229 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 1
%1230 = load volatile float, float* %1229
%1231 = fcmp une float %1228, 0.000000e+00
%1232 = fcmp une float %1230, 0.000000e+00
%1233 = or i1 %1231, %1232
br i1 %1233, label %1246, label %1234
1234: ; preds = %1226
%1235 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 0
%1236 = load volatile float, float* %1235
%1237 = call float @llvm.copysign.f32(float 1.000000e+00, float %1236)
%1238 = fpext float %1237 to double
%1239 = fcmp une double %1238, -1.000000e+00
br i1 %1239, label %1246, label %1240
1240: ; preds = %1234
%1241 = getelementptr inbounds { float, float }, { float, float }* %48, i32 0, i32 1
%1242 = load volatile float, float* %1241
%1243 = call float @llvm.copysign.f32(float 1.000000e+00, float %1242)
%1244 = fpext float %1243 to double
%1245 = fcmp une double %1244, -1.000000e+00
br i1 %1245, label %1246, label %1247
1246: ; preds = %1240, %1234, %1226
unreachable
1247: ; preds = %1240
br label %1248
1248: ; preds = %1247
br label %1249
1249: ; preds = %1248
br label %1250
1250: ; preds = %1249
br i1 true, label %1251, label %1257
1251: ; preds = %1250
br i1 true, label %1252, label %1253
1252: ; preds = %1251
br label %1254
1253: ; preds = %1251
br label %1254
1254: ; preds = %1253, %1252
%1255 = phi float [ 0.000000e+00, %1252 ], [ 0.000000e+00, %1253 ]
%1256 = phi float [ 0.000000e+00, %1252 ], [ -0.000000e+00, %1253 ]
br label %1263
1257: ; preds = %1250
br i1 true, label %1258, label %1259
1258: ; preds = %1257
br label %1260
1259: ; preds = %1257
br label %1260
1260: ; preds = %1259, %1258
%1261 = phi float [ -0.000000e+00, %1258 ], [ -0.000000e+00, %1259 ]
%1262 = phi float [ 0.000000e+00, %1258 ], [ -0.000000e+00, %1259 ]
br label %1263
1263: ; preds = %1260, %1254
%1264 = phi float [ %1255, %1254 ], [ %1261, %1260 ]
%1265 = phi float [ %1256, %1254 ], [ %1262, %1260 ]
%1266 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 0
%1267 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 1
store float %1264, float* %1266
store float %1265, float* %1267
br label %1268
1268: ; preds = %1263
%1269 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 0
%1270 = load float, float* %1269
%1271 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 1
%1272 = load float, float* %1271
%1273 = fcmp une float %1270, 0.000000e+00
%1274 = fcmp une float %1272, 0.000000e+00
%1275 = or i1 %1273, %1274
br i1 %1275, label %1288, label %1276
1276: ; preds = %1268
%1277 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 0
%1278 = load float, float* %1277
%1279 = call float @llvm.copysign.f32(float 1.000000e+00, float %1278)
%1280 = fpext float %1279 to double
%1281 = fcmp une double %1280, 1.000000e+00
br i1 %1281, label %1288, label %1282
1282: ; preds = %1276
%1283 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 1
%1284 = load float, float* %1283
%1285 = call float @llvm.copysign.f32(float 1.000000e+00, float %1284)
%1286 = fpext float %1285 to double
%1287 = fcmp une double %1286, 1.000000e+00
br i1 %1287, label %1288, label %1289
1288: ; preds = %1282, %1276, %1268
unreachable
1289: ; preds = %1282
br label %1290
1290: ; preds = %1289
store float 0.000000e+00, float* %51
%1291 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 0
%1292 = load float, float* %1291
%1293 = getelementptr inbounds { float, float }, { float, float }* %49, i32 0, i32 1
%1294 = load float, float* %1293
%1295 = load float, float* %51
%1296 = fadd float %1292, %1295
%1297 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 0
%1298 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 1
store float %1296, float* %1297
store float %1294, float* %1298
br label %1299
1299: ; preds = %1290
%1300 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 0
%1301 = load float, float* %1300
%1302 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 1
%1303 = load float, float* %1302
%1304 = fcmp une float %1301, 0.000000e+00
%1305 = fcmp une float %1303, 0.000000e+00
%1306 = or i1 %1304, %1305
br i1 %1306, label %1319, label %1307
1307: ; preds = %1299
%1308 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 0
%1309 = load float, float* %1308
%1310 = call float @llvm.copysign.f32(float 1.000000e+00, float %1309)
%1311 = fpext float %1310 to double
%1312 = fcmp une double %1311, 1.000000e+00
br i1 %1312, label %1319, label %1313
1313: ; preds = %1307
%1314 = getelementptr inbounds { float, float }, { float, float }* %50, i32 0, i32 1
%1315 = load float, float* %1314
%1316 = call float @llvm.copysign.f32(float 1.000000e+00, float %1315)
%1317 = fpext float %1316 to double
%1318 = fcmp une double %1317, 1.000000e+00
br i1 %1318, label %1319, label %1320
1319: ; preds = %1313, %1307, %1299
unreachable
1320: ; preds = %1313
br label %1321
1321: ; preds = %1320
br i1 true, label %1322, label %1328
1322: ; preds = %1321
br i1 true, label %1323, label %1324
1323: ; preds = %1322
br label %1325
1324: ; preds = %1322
br label %1325
1325: ; preds = %1324, %1323
%1326 = phi float [ 0.000000e+00, %1323 ], [ 0.000000e+00, %1324 ]
%1327 = phi float [ 0.000000e+00, %1323 ], [ -0.000000e+00, %1324 ]
br label %1334
1328: ; preds = %1321
br i1 true, label %1329, label %1330
1329: ; preds = %1328
br label %1331
1330: ; preds = %1328
br label %1331
1331: ; preds = %1330, %1329
%1332 = phi float [ -0.000000e+00, %1329 ], [ -0.000000e+00, %1330 ]
%1333 = phi float [ 0.000000e+00, %1329 ], [ -0.000000e+00, %1330 ]
br label %1334
1334: ; preds = %1331, %1325
%1335 = phi float [ %1326, %1325 ], [ %1332, %1331 ]
%1336 = phi float [ %1327, %1325 ], [ %1333, %1331 ]
%1337 = getelementptr inbounds { float, float }, { float, float }* %52, i32 0, i32 0
%1338 = getelementptr inbounds { float, float }, { float, float }* %52, i32 0, i32 1
store volatile float %1335, float* %1337
store volatile float %1336, float* %1338
br label %1339
1339: ; preds = %1334
%1340 = getelementptr inbounds { float, float }, { float, float }* %52, i32 0, i32 0
%1341 = load volatile float, float* %1340
%1342 = getelementptr inbounds { float, float }, { float, float }* %52, i32 0, i32 1
%1343 = load volatile float, float* %1342
%1344 = fcmp une float %1341, 0.000000e+00
%1345 = fcmp une float %1343, 0.000000e+00
%1346 = or i1 %1344, %1345
br i1 %1346, label %1359, label %1347
1347: ; preds = %1339
%1348 = getelementptr inbounds { float, float }, { float, float }* %52, i32 0, i32 0
%1349 = load volatile float, float* %1348
%1350 = call float @llvm.copysign.f32(float 1.000000e+00, float %1349)
%1351 = fpext float %1350 to double
%1352 = fcmp une double %1351, 1.000000e+00
br i1 %1352, label %1359, label %1353
1353: ; preds = %1347
%1354 = getelementptr inbounds { float, float }, { float, float }* %52, i32 0, i32 1
%1355 = load volatile float, float* %1354
%1356 = call float @llvm.copysign.f32(float 1.000000e+00, float %1355)
%1357 = fpext float %1356 to double
%1358 = fcmp une double %1357, 1.000000e+00
br i1 %1358, label %1359, label %1360
1359: ; preds = %1353, %1347, %1339
unreachable
1360: ; preds = %1353
br label %1361
1361: ; preds = %1360
store volatile float 0.000000e+00, float* %54
%1362 = getelementptr inbounds { float, float }, { float, float }* %52, i32 0, i32 0
%1363 = load volatile float, float* %1362
%1364 = getelementptr inbounds { float, float }, { float, float }* %52, i32 0, i32 1
%1365 = load volatile float, float* %1364
%1366 = load volatile float, float* %54
%1367 = fadd float %1363, %1366
%1368 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 0
%1369 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 1
store volatile float %1367, float* %1368
store volatile float %1365, float* %1369
br label %1370
1370: ; preds = %1361
%1371 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 0
%1372 = load volatile float, float* %1371
%1373 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 1
%1374 = load volatile float, float* %1373
%1375 = fcmp une float %1372, 0.000000e+00
%1376 = fcmp une float %1374, 0.000000e+00
%1377 = or i1 %1375, %1376
br i1 %1377, label %1390, label %1378
1378: ; preds = %1370
%1379 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 0
%1380 = load volatile float, float* %1379
%1381 = call float @llvm.copysign.f32(float 1.000000e+00, float %1380)
%1382 = fpext float %1381 to double
%1383 = fcmp une double %1382, 1.000000e+00
br i1 %1383, label %1390, label %1384
1384: ; preds = %1378
%1385 = getelementptr inbounds { float, float }, { float, float }* %53, i32 0, i32 1
%1386 = load volatile float, float* %1385
%1387 = call float @llvm.copysign.f32(float 1.000000e+00, float %1386)
%1388 = fpext float %1387 to double
%1389 = fcmp une double %1388, 1.000000e+00
br i1 %1389, label %1390, label %1391
1390: ; preds = %1384, %1378, %1370
unreachable
1391: ; preds = %1384
br label %1392
1392: ; preds = %1391
br label %1393
1393: ; preds = %1392
br label %1394
1394: ; preds = %1393
br i1 true, label %1395, label %1401
1395: ; preds = %1394
br i1 true, label %1396, label %1397
1396: ; preds = %1395
br label %1398
1397: ; preds = %1395
br label %1398
1398: ; preds = %1397, %1396
%1399 = phi float [ 0.000000e+00, %1396 ], [ 0.000000e+00, %1397 ]
%1400 = phi float [ 0.000000e+00, %1396 ], [ -0.000000e+00, %1397 ]
br label %1407
1401: ; preds = %1394
br i1 true, label %1402, label %1403
1402: ; preds = %1401
br label %1404
1403: ; preds = %1401
br label %1404
1404: ; preds = %1403, %1402
%1405 = phi float [ -0.000000e+00, %1402 ], [ -0.000000e+00, %1403 ]
%1406 = phi float [ 0.000000e+00, %1402 ], [ -0.000000e+00, %1403 ]
br label %1407
1407: ; preds = %1404, %1398
%1408 = phi float [ %1399, %1398 ], [ %1405, %1404 ]
%1409 = phi float [ %1400, %1398 ], [ %1406, %1404 ]
%1410 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 0
%1411 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 1
store float %1408, float* %1410
store float %1409, float* %1411
br label %1412
1412: ; preds = %1407
%1413 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 0
%1414 = load float, float* %1413
%1415 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 1
%1416 = load float, float* %1415
%1417 = fcmp une float %1414, 0.000000e+00
%1418 = fcmp une float %1416, 0.000000e+00
%1419 = or i1 %1417, %1418
br i1 %1419, label %1432, label %1420
1420: ; preds = %1412
%1421 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 0
%1422 = load float, float* %1421
%1423 = call float @llvm.copysign.f32(float 1.000000e+00, float %1422)
%1424 = fpext float %1423 to double
%1425 = fcmp une double %1424, 1.000000e+00
br i1 %1425, label %1432, label %1426
1426: ; preds = %1420
%1427 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 1
%1428 = load float, float* %1427
%1429 = call float @llvm.copysign.f32(float 1.000000e+00, float %1428)
%1430 = fpext float %1429 to double
%1431 = fcmp une double %1430, 1.000000e+00
br i1 %1431, label %1432, label %1433
1432: ; preds = %1426, %1420, %1412
unreachable
1433: ; preds = %1426
br label %1434
1434: ; preds = %1433
store float -0.000000e+00, float* %57
%1435 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 0
%1436 = load float, float* %1435
%1437 = getelementptr inbounds { float, float }, { float, float }* %55, i32 0, i32 1
%1438 = load float, float* %1437
%1439 = load float, float* %57
%1440 = fadd float %1436, %1439
%1441 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 0
%1442 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 1
store float %1440, float* %1441
store float %1438, float* %1442
br label %1443
1443: ; preds = %1434
%1444 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 0
%1445 = load float, float* %1444
%1446 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 1
%1447 = load float, float* %1446
%1448 = fcmp une float %1445, 0.000000e+00
%1449 = fcmp une float %1447, 0.000000e+00
%1450 = or i1 %1448, %1449
br i1 %1450, label %1463, label %1451
1451: ; preds = %1443
%1452 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 0
%1453 = load float, float* %1452
%1454 = call float @llvm.copysign.f32(float 1.000000e+00, float %1453)
%1455 = fpext float %1454 to double
%1456 = fcmp une double %1455, 1.000000e+00
br i1 %1456, label %1463, label %1457
1457: ; preds = %1451
%1458 = getelementptr inbounds { float, float }, { float, float }* %56, i32 0, i32 1
%1459 = load float, float* %1458
%1460 = call float @llvm.copysign.f32(float 1.000000e+00, float %1459)
%1461 = fpext float %1460 to double
%1462 = fcmp une double %1461, 1.000000e+00
br i1 %1462, label %1463, label %1464
1463: ; preds = %1457, %1451, %1443
unreachable
1464: ; preds = %1457
br label %1465
1465: ; preds = %1464
br i1 true, label %1466, label %1472
1466: ; preds = %1465
br i1 true, label %1467, label %1468
1467: ; preds = %1466
br label %1469
1468: ; preds = %1466
br label %1469
1469: ; preds = %1468, %1467
%1470 = phi float [ 0.000000e+00, %1467 ], [ 0.000000e+00, %1468 ]
%1471 = phi float [ 0.000000e+00, %1467 ], [ -0.000000e+00, %1468 ]
br label %1478
1472: ; preds = %1465
br i1 true, label %1473, label %1474
1473: ; preds = %1472
br label %1475
1474: ; preds = %1472
br label %1475
1475: ; preds = %1474, %1473
%1476 = phi float [ -0.000000e+00, %1473 ], [ -0.000000e+00, %1474 ]
%1477 = phi float [ 0.000000e+00, %1473 ], [ -0.000000e+00, %1474 ]
br label %1478
1478: ; preds = %1475, %1469
%1479 = phi float [ %1470, %1469 ], [ %1476, %1475 ]
%1480 = phi float [ %1471, %1469 ], [ %1477, %1475 ]
%1481 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 0
%1482 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 1
store volatile float %1479, float* %1481
store volatile float %1480, float* %1482
br label %1483
1483: ; preds = %1478
%1484 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 0
%1485 = load volatile float, float* %1484
%1486 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 1
%1487 = load volatile float, float* %1486
%1488 = fcmp une float %1485, 0.000000e+00
%1489 = fcmp une float %1487, 0.000000e+00
%1490 = or i1 %1488, %1489
br i1 %1490, label %1503, label %1491
1491: ; preds = %1483
%1492 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 0
%1493 = load volatile float, float* %1492
%1494 = call float @llvm.copysign.f32(float 1.000000e+00, float %1493)
%1495 = fpext float %1494 to double
%1496 = fcmp une double %1495, 1.000000e+00
br i1 %1496, label %1503, label %1497
1497: ; preds = %1491
%1498 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 1
%1499 = load volatile float, float* %1498
%1500 = call float @llvm.copysign.f32(float 1.000000e+00, float %1499)
%1501 = fpext float %1500 to double
%1502 = fcmp une double %1501, 1.000000e+00
br i1 %1502, label %1503, label %1504
1503: ; preds = %1497, %1491, %1483
unreachable
1504: ; preds = %1497
br label %1505
1505: ; preds = %1504
store volatile float -0.000000e+00, float* %60
%1506 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 0
%1507 = load volatile float, float* %1506
%1508 = getelementptr inbounds { float, float }, { float, float }* %58, i32 0, i32 1
%1509 = load volatile float, float* %1508
%1510 = load volatile float, float* %60
%1511 = fadd float %1507, %1510
%1512 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 0
%1513 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 1
store volatile float %1511, float* %1512
store volatile float %1509, float* %1513
br label %1514
1514: ; preds = %1505
%1515 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 0
%1516 = load volatile float, float* %1515
%1517 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 1
%1518 = load volatile float, float* %1517
%1519 = fcmp une float %1516, 0.000000e+00
%1520 = fcmp une float %1518, 0.000000e+00
%1521 = or i1 %1519, %1520
br i1 %1521, label %1534, label %1522
1522: ; preds = %1514
%1523 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 0
%1524 = load volatile float, float* %1523
%1525 = call float @llvm.copysign.f32(float 1.000000e+00, float %1524)
%1526 = fpext float %1525 to double
%1527 = fcmp une double %1526, 1.000000e+00
br i1 %1527, label %1534, label %1528
1528: ; preds = %1522
%1529 = getelementptr inbounds { float, float }, { float, float }* %59, i32 0, i32 1
%1530 = load volatile float, float* %1529
%1531 = call float @llvm.copysign.f32(float 1.000000e+00, float %1530)
%1532 = fpext float %1531 to double
%1533 = fcmp une double %1532, 1.000000e+00
br i1 %1533, label %1534, label %1535
1534: ; preds = %1528, %1522, %1514
unreachable
1535: ; preds = %1528
br label %1536
1536: ; preds = %1535
br label %1537
1537: ; preds = %1536
br label %1538
1538: ; preds = %1537
br i1 true, label %1539, label %1545
1539: ; preds = %1538
br i1 false, label %1540, label %1541
1540: ; preds = %1539
br label %1542
1541: ; preds = %1539
br label %1542
1542: ; preds = %1541, %1540
%1543 = phi float [ 0.000000e+00, %1540 ], [ 0.000000e+00, %1541 ]
%1544 = phi float [ 0.000000e+00, %1540 ], [ -0.000000e+00, %1541 ]
br label %1551
1545: ; preds = %1538
br i1 false, label %1546, label %1547
1546: ; preds = %1545
br label %1548
1547: ; preds = %1545
br label %1548
1548: ; preds = %1547, %1546
%1549 = phi float [ -0.000000e+00, %1546 ], [ -0.000000e+00, %1547 ]
%1550 = phi float [ 0.000000e+00, %1546 ], [ -0.000000e+00, %1547 ]
br label %1551
1551: ; preds = %1548, %1542
%1552 = phi float [ %1543, %1542 ], [ %1549, %1548 ]
%1553 = phi float [ %1544, %1542 ], [ %1550, %1548 ]
%1554 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 0
%1555 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 1
store float %1552, float* %1554
store float %1553, float* %1555
br label %1556
1556: ; preds = %1551
%1557 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 0
%1558 = load float, float* %1557
%1559 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 1
%1560 = load float, float* %1559
%1561 = fcmp une float %1558, 0.000000e+00
%1562 = fcmp une float %1560, 0.000000e+00
%1563 = or i1 %1561, %1562
br i1 %1563, label %1576, label %1564
1564: ; preds = %1556
%1565 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 0
%1566 = load float, float* %1565
%1567 = call float @llvm.copysign.f32(float 1.000000e+00, float %1566)
%1568 = fpext float %1567 to double
%1569 = fcmp une double %1568, 1.000000e+00
br i1 %1569, label %1576, label %1570
1570: ; preds = %1564
%1571 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 1
%1572 = load float, float* %1571
%1573 = call float @llvm.copysign.f32(float 1.000000e+00, float %1572)
%1574 = fpext float %1573 to double
%1575 = fcmp une double %1574, -1.000000e+00
br i1 %1575, label %1576, label %1577
1576: ; preds = %1570, %1564, %1556
unreachable
1577: ; preds = %1570
br label %1578
1578: ; preds = %1577
store float 0.000000e+00, float* %63
%1579 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 0
%1580 = load float, float* %1579
%1581 = getelementptr inbounds { float, float }, { float, float }* %61, i32 0, i32 1
%1582 = load float, float* %1581
%1583 = load float, float* %63
%1584 = fadd float %1580, %1583
%1585 = getelementptr inbounds { float, float }, { float, float }* %62, i32 0, i32 0
%1586 = getelementptr inbounds { float, float }, { float, float }* %62, i32 0, i32 1
store float %1584, float* %1585
store float %1582, float* %1586
br label %1587
1587: ; preds = %1578
%1588 = getelementptr inbounds { float, float }, { float, float }* %62, i32 0, i32 0
%1589 = load float, float* %1588
%1590 = getelementptr inbounds { float, float }, { float, float }* %62, i32 0, i32 1
%1591 = load float, float* %1590
%1592 = fcmp une float %1589, 0.000000e+00
%1593 = fcmp une float %1591, 0.000000e+00
%1594 = or i1 %1592, %1593
br i1 %1594, label %1607, label %1595
1595: ; preds = %1587
%1596 = getelementptr inbounds { float, float }, { float, float }* %62, i32 0, i32 0
%1597 = load float, float* %1596
%1598 = call float @llvm.copysign.f32(float 1.000000e+00, float %1597)
%1599 = fpext float %1598 to double
%1600 = fcmp une double %1599, 1.000000e+00
br i1 %1600, label %1607, label %1601
1601: ; preds = %1595
%1602 = getelementptr inbounds { float, float }, { float, float }* %62, i32 0, i32 1
%1603 = load float, float* %1602
%1604 = call float @llvm.copysign.f32(float 1.000000e+00, float %1603)
%1605 = fpext float %1604 to double
%1606 = fcmp une double %1605, -1.000000e+00
br i1 %1606, label %1607, label %1608
1607: ; preds = %1601, %1595, %1587
unreachable
1608: ; preds = %1601
br label %1609
1609: ; preds = %1608
br i1 true, label %1610, label %1616
1610: ; preds = %1609
br i1 false, label %1611, label %1612
1611: ; preds = %1610
br label %1613
1612: ; preds = %1610
br label %1613
1613: ; preds = %1612, %1611
%1614 = phi float [ 0.000000e+00, %1611 ], [ 0.000000e+00, %1612 ]
%1615 = phi float [ 0.000000e+00, %1611 ], [ -0.000000e+00, %1612 ]
br label %1622
1616: ; preds = %1609
br i1 false, label %1617, label %1618
1617: ; preds = %1616
br label %1619
1618: ; preds = %1616
br label %1619
1619: ; preds = %1618, %1617
%1620 = phi float [ -0.000000e+00, %1617 ], [ -0.000000e+00, %1618 ]
%1621 = phi float [ 0.000000e+00, %1617 ], [ -0.000000e+00, %1618 ]
br label %1622
1622: ; preds = %1619, %1613
%1623 = phi float [ %1614, %1613 ], [ %1620, %1619 ]
%1624 = phi float [ %1615, %1613 ], [ %1621, %1619 ]
%1625 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 0
%1626 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 1
store volatile float %1623, float* %1625
store volatile float %1624, float* %1626
br label %1627
1627: ; preds = %1622
%1628 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 0
%1629 = load volatile float, float* %1628
%1630 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 1
%1631 = load volatile float, float* %1630
%1632 = fcmp une float %1629, 0.000000e+00
%1633 = fcmp une float %1631, 0.000000e+00
%1634 = or i1 %1632, %1633
br i1 %1634, label %1647, label %1635
1635: ; preds = %1627
%1636 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 0
%1637 = load volatile float, float* %1636
%1638 = call float @llvm.copysign.f32(float 1.000000e+00, float %1637)
%1639 = fpext float %1638 to double
%1640 = fcmp une double %1639, 1.000000e+00
br i1 %1640, label %1647, label %1641
1641: ; preds = %1635
%1642 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 1
%1643 = load volatile float, float* %1642
%1644 = call float @llvm.copysign.f32(float 1.000000e+00, float %1643)
%1645 = fpext float %1644 to double
%1646 = fcmp une double %1645, -1.000000e+00
br i1 %1646, label %1647, label %1648
1647: ; preds = %1641, %1635, %1627
unreachable
1648: ; preds = %1641
br label %1649
1649: ; preds = %1648
store volatile float 0.000000e+00, float* %66
%1650 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 0
%1651 = load volatile float, float* %1650
%1652 = getelementptr inbounds { float, float }, { float, float }* %64, i32 0, i32 1
%1653 = load volatile float, float* %1652
%1654 = load volatile float, float* %66
%1655 = fadd float %1651, %1654
%1656 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 0
%1657 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 1
store volatile float %1655, float* %1656
store volatile float %1653, float* %1657
br label %1658
1658: ; preds = %1649
%1659 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 0
%1660 = load volatile float, float* %1659
%1661 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 1
%1662 = load volatile float, float* %1661
%1663 = fcmp une float %1660, 0.000000e+00
%1664 = fcmp une float %1662, 0.000000e+00
%1665 = or i1 %1663, %1664
br i1 %1665, label %1678, label %1666
1666: ; preds = %1658
%1667 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 0
%1668 = load volatile float, float* %1667
%1669 = call float @llvm.copysign.f32(float 1.000000e+00, float %1668)
%1670 = fpext float %1669 to double
%1671 = fcmp une double %1670, 1.000000e+00
br i1 %1671, label %1678, label %1672
1672: ; preds = %1666
%1673 = getelementptr inbounds { float, float }, { float, float }* %65, i32 0, i32 1
%1674 = load volatile float, float* %1673
%1675 = call float @llvm.copysign.f32(float 1.000000e+00, float %1674)
%1676 = fpext float %1675 to double
%1677 = fcmp une double %1676, -1.000000e+00
br i1 %1677, label %1678, label %1679
1678: ; preds = %1672, %1666, %1658
unreachable
1679: ; preds = %1672
br label %1680
1680: ; preds = %1679
br label %1681
1681: ; preds = %1680
br label %1682
1682: ; preds = %1681
br i1 true, label %1683, label %1689
1683: ; preds = %1682
br i1 false, label %1684, label %1685
1684: ; preds = %1683
br label %1686
1685: ; preds = %1683
br label %1686
1686: ; preds = %1685, %1684
%1687 = phi float [ 0.000000e+00, %1684 ], [ 0.000000e+00, %1685 ]
%1688 = phi float [ 0.000000e+00, %1684 ], [ -0.000000e+00, %1685 ]
br label %1695
1689: ; preds = %1682
br i1 false, label %1690, label %1691
1690: ; preds = %1689
br label %1692
1691: ; preds = %1689
br label %1692
1692: ; preds = %1691, %1690
%1693 = phi float [ -0.000000e+00, %1690 ], [ -0.000000e+00, %1691 ]
%1694 = phi float [ 0.000000e+00, %1690 ], [ -0.000000e+00, %1691 ]
br label %1695
1695: ; preds = %1692, %1686
%1696 = phi float [ %1687, %1686 ], [ %1693, %1692 ]
%1697 = phi float [ %1688, %1686 ], [ %1694, %1692 ]
%1698 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 0
%1699 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 1
store float %1696, float* %1698
store float %1697, float* %1699
br label %1700
1700: ; preds = %1695
%1701 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 0
%1702 = load float, float* %1701
%1703 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 1
%1704 = load float, float* %1703
%1705 = fcmp une float %1702, 0.000000e+00
%1706 = fcmp une float %1704, 0.000000e+00
%1707 = or i1 %1705, %1706
br i1 %1707, label %1720, label %1708
1708: ; preds = %1700
%1709 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 0
%1710 = load float, float* %1709
%1711 = call float @llvm.copysign.f32(float 1.000000e+00, float %1710)
%1712 = fpext float %1711 to double
%1713 = fcmp une double %1712, 1.000000e+00
br i1 %1713, label %1720, label %1714
1714: ; preds = %1708
%1715 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 1
%1716 = load float, float* %1715
%1717 = call float @llvm.copysign.f32(float 1.000000e+00, float %1716)
%1718 = fpext float %1717 to double
%1719 = fcmp une double %1718, -1.000000e+00
br i1 %1719, label %1720, label %1721
1720: ; preds = %1714, %1708, %1700
unreachable
1721: ; preds = %1714
br label %1722
1722: ; preds = %1721
store float -0.000000e+00, float* %69
%1723 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 0
%1724 = load float, float* %1723
%1725 = getelementptr inbounds { float, float }, { float, float }* %67, i32 0, i32 1
%1726 = load float, float* %1725
%1727 = load float, float* %69
%1728 = fadd float %1724, %1727
%1729 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 0
%1730 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 1
store float %1728, float* %1729
store float %1726, float* %1730
br label %1731
1731: ; preds = %1722
%1732 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 0
%1733 = load float, float* %1732
%1734 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 1
%1735 = load float, float* %1734
%1736 = fcmp une float %1733, 0.000000e+00
%1737 = fcmp une float %1735, 0.000000e+00
%1738 = or i1 %1736, %1737
br i1 %1738, label %1751, label %1739
1739: ; preds = %1731
%1740 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 0
%1741 = load float, float* %1740
%1742 = call float @llvm.copysign.f32(float 1.000000e+00, float %1741)
%1743 = fpext float %1742 to double
%1744 = fcmp une double %1743, 1.000000e+00
br i1 %1744, label %1751, label %1745
1745: ; preds = %1739
%1746 = getelementptr inbounds { float, float }, { float, float }* %68, i32 0, i32 1
%1747 = load float, float* %1746
%1748 = call float @llvm.copysign.f32(float 1.000000e+00, float %1747)
%1749 = fpext float %1748 to double
%1750 = fcmp une double %1749, -1.000000e+00
br i1 %1750, label %1751, label %1752
1751: ; preds = %1745, %1739, %1731
unreachable
1752: ; preds = %1745
br label %1753
1753: ; preds = %1752
br i1 true, label %1754, label %1760
1754: ; preds = %1753
br i1 false, label %1755, label %1756
1755: ; preds = %1754
br label %1757
1756: ; preds = %1754
br label %1757
1757: ; preds = %1756, %1755
%1758 = phi float [ 0.000000e+00, %1755 ], [ 0.000000e+00, %1756 ]
%1759 = phi float [ 0.000000e+00, %1755 ], [ -0.000000e+00, %1756 ]
br label %1766
1760: ; preds = %1753
br i1 false, label %1761, label %1762
1761: ; preds = %1760
br label %1763
1762: ; preds = %1760
br label %1763
1763: ; preds = %1762, %1761
%1764 = phi float [ -0.000000e+00, %1761 ], [ -0.000000e+00, %1762 ]
%1765 = phi float [ 0.000000e+00, %1761 ], [ -0.000000e+00, %1762 ]
br label %1766
1766: ; preds = %1763, %1757
%1767 = phi float [ %1758, %1757 ], [ %1764, %1763 ]
%1768 = phi float [ %1759, %1757 ], [ %1765, %1763 ]
%1769 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 0
%1770 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 1
store volatile float %1767, float* %1769
store volatile float %1768, float* %1770
br label %1771
1771: ; preds = %1766
%1772 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 0
%1773 = load volatile float, float* %1772
%1774 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 1
%1775 = load volatile float, float* %1774
%1776 = fcmp une float %1773, 0.000000e+00
%1777 = fcmp une float %1775, 0.000000e+00
%1778 = or i1 %1776, %1777
br i1 %1778, label %1791, label %1779
1779: ; preds = %1771
%1780 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 0
%1781 = load volatile float, float* %1780
%1782 = call float @llvm.copysign.f32(float 1.000000e+00, float %1781)
%1783 = fpext float %1782 to double
%1784 = fcmp une double %1783, 1.000000e+00
br i1 %1784, label %1791, label %1785
1785: ; preds = %1779
%1786 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 1
%1787 = load volatile float, float* %1786
%1788 = call float @llvm.copysign.f32(float 1.000000e+00, float %1787)
%1789 = fpext float %1788 to double
%1790 = fcmp une double %1789, -1.000000e+00
br i1 %1790, label %1791, label %1792
1791: ; preds = %1785, %1779, %1771
unreachable
1792: ; preds = %1785
br label %1793
1793: ; preds = %1792
store volatile float -0.000000e+00, float* %72
%1794 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 0
%1795 = load volatile float, float* %1794
%1796 = getelementptr inbounds { float, float }, { float, float }* %70, i32 0, i32 1
%1797 = load volatile float, float* %1796
%1798 = load volatile float, float* %72
%1799 = fadd float %1795, %1798
%1800 = getelementptr inbounds { float, float }, { float, float }* %71, i32 0, i32 0
%1801 = getelementptr inbounds { float, float }, { float, float }* %71, i32 0, i32 1
store volatile float %1799, float* %1800
store volatile float %1797, float* %1801
br label %1802
1802: ; preds = %1793
%1803 = getelementptr inbounds { float, float }, { float, float }* %71, i32 0, i32 0
%1804 = load volatile float, float* %1803
%1805 = getelementptr inbounds { float, float }, { float, float }* %71, i32 0, i32 1
%1806 = load volatile float, float* %1805
%1807 = fcmp une float %1804, 0.000000e+00
%1808 = fcmp une float %1806, 0.000000e+00
%1809 = or i1 %1807, %1808
br i1 %1809, label %1822, label %1810
1810: ; preds = %1802
%1811 = getelementptr inbounds { float, float }, { float, float }* %71, i32 0, i32 0
%1812 = load volatile float, float* %1811
%1813 = call float @llvm.copysign.f32(float 1.000000e+00, float %1812)
%1814 = fpext float %1813 to double
%1815 = fcmp une double %1814, 1.000000e+00
br i1 %1815, label %1822, label %1816
1816: ; preds = %1810
%1817 = getelementptr inbounds { float, float }, { float, float }* %71, i32 0, i32 1
%1818 = load volatile float, float* %1817
%1819 = call float @llvm.copysign.f32(float 1.000000e+00, float %1818)
%1820 = fpext float %1819 to double
%1821 = fcmp une double %1820, -1.000000e+00
br i1 %1821, label %1822, label %1823
1822: ; preds = %1816, %1810, %1802
unreachable
1823: ; preds = %1816
br label %1824
1824: ; preds = %1823
br label %1825
1825: ; preds = %1824
br label %1826
1826: ; preds = %1825
br i1 false, label %1827, label %1833
1827: ; preds = %1826
br i1 true, label %1828, label %1829
1828: ; preds = %1827
br label %1830
1829: ; preds = %1827
br label %1830
1830: ; preds = %1829, %1828
%1831 = phi float [ 0.000000e+00, %1828 ], [ 0.000000e+00, %1829 ]
%1832 = phi float [ 0.000000e+00, %1828 ], [ -0.000000e+00, %1829 ]
br label %1839
1833: ; preds = %1826
br i1 true, label %1834, label %1835
1834: ; preds = %1833
br label %1836
1835: ; preds = %1833
br label %1836
1836: ; preds = %1835, %1834
%1837 = phi float [ -0.000000e+00, %1834 ], [ -0.000000e+00, %1835 ]
%1838 = phi float [ 0.000000e+00, %1834 ], [ -0.000000e+00, %1835 ]
br label %1839
1839: ; preds = %1836, %1830
%1840 = phi float [ %1831, %1830 ], [ %1837, %1836 ]
%1841 = phi float [ %1832, %1830 ], [ %1838, %1836 ]
%1842 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 0
%1843 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 1
store float %1840, float* %1842
store float %1841, float* %1843
br label %1844
1844: ; preds = %1839
%1845 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 0
%1846 = load float, float* %1845
%1847 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 1
%1848 = load float, float* %1847
%1849 = fcmp une float %1846, 0.000000e+00
%1850 = fcmp une float %1848, 0.000000e+00
%1851 = or i1 %1849, %1850
br i1 %1851, label %1864, label %1852
1852: ; preds = %1844
%1853 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 0
%1854 = load float, float* %1853
%1855 = call float @llvm.copysign.f32(float 1.000000e+00, float %1854)
%1856 = fpext float %1855 to double
%1857 = fcmp une double %1856, -1.000000e+00
br i1 %1857, label %1864, label %1858
1858: ; preds = %1852
%1859 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 1
%1860 = load float, float* %1859
%1861 = call float @llvm.copysign.f32(float 1.000000e+00, float %1860)
%1862 = fpext float %1861 to double
%1863 = fcmp une double %1862, 1.000000e+00
br i1 %1863, label %1864, label %1865
1864: ; preds = %1858, %1852, %1844
unreachable
1865: ; preds = %1858
br label %1866
1866: ; preds = %1865
store float 0.000000e+00, float* %75
%1867 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 0
%1868 = load float, float* %1867
%1869 = getelementptr inbounds { float, float }, { float, float }* %73, i32 0, i32 1
%1870 = load float, float* %1869
%1871 = load float, float* %75
%1872 = fadd float %1868, %1871
%1873 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 0
%1874 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 1
store float %1872, float* %1873
store float %1870, float* %1874
br label %1875
1875: ; preds = %1866
%1876 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 0
%1877 = load float, float* %1876
%1878 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 1
%1879 = load float, float* %1878
%1880 = fcmp une float %1877, 0.000000e+00
%1881 = fcmp une float %1879, 0.000000e+00
%1882 = or i1 %1880, %1881
br i1 %1882, label %1895, label %1883
1883: ; preds = %1875
%1884 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 0
%1885 = load float, float* %1884
%1886 = call float @llvm.copysign.f32(float 1.000000e+00, float %1885)
%1887 = fpext float %1886 to double
%1888 = fcmp une double %1887, 1.000000e+00
br i1 %1888, label %1895, label %1889
1889: ; preds = %1883
%1890 = getelementptr inbounds { float, float }, { float, float }* %74, i32 0, i32 1
%1891 = load float, float* %1890
%1892 = call float @llvm.copysign.f32(float 1.000000e+00, float %1891)
%1893 = fpext float %1892 to double
%1894 = fcmp une double %1893, 1.000000e+00
br i1 %1894, label %1895, label %1896
1895: ; preds = %1889, %1883, %1875
unreachable
1896: ; preds = %1889
br label %1897
1897: ; preds = %1896
br i1 false, label %1898, label %1904
1898: ; preds = %1897
br i1 true, label %1899, label %1900
1899: ; preds = %1898
br label %1901
1900: ; preds = %1898
br label %1901
1901: ; preds = %1900, %1899
%1902 = phi float [ 0.000000e+00, %1899 ], [ 0.000000e+00, %1900 ]
%1903 = phi float [ 0.000000e+00, %1899 ], [ -0.000000e+00, %1900 ]
br label %1910
1904: ; preds = %1897
br i1 true, label %1905, label %1906
1905: ; preds = %1904
br label %1907
1906: ; preds = %1904
br label %1907
1907: ; preds = %1906, %1905
%1908 = phi float [ -0.000000e+00, %1905 ], [ -0.000000e+00, %1906 ]
%1909 = phi float [ 0.000000e+00, %1905 ], [ -0.000000e+00, %1906 ]
br label %1910
1910: ; preds = %1907, %1901
%1911 = phi float [ %1902, %1901 ], [ %1908, %1907 ]
%1912 = phi float [ %1903, %1901 ], [ %1909, %1907 ]
%1913 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 0
%1914 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 1
store volatile float %1911, float* %1913
store volatile float %1912, float* %1914
br label %1915
1915: ; preds = %1910
%1916 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 0
%1917 = load volatile float, float* %1916
%1918 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 1
%1919 = load volatile float, float* %1918
%1920 = fcmp une float %1917, 0.000000e+00
%1921 = fcmp une float %1919, 0.000000e+00
%1922 = or i1 %1920, %1921
br i1 %1922, label %1935, label %1923
1923: ; preds = %1915
%1924 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 0
%1925 = load volatile float, float* %1924
%1926 = call float @llvm.copysign.f32(float 1.000000e+00, float %1925)
%1927 = fpext float %1926 to double
%1928 = fcmp une double %1927, -1.000000e+00
br i1 %1928, label %1935, label %1929
1929: ; preds = %1923
%1930 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 1
%1931 = load volatile float, float* %1930
%1932 = call float @llvm.copysign.f32(float 1.000000e+00, float %1931)
%1933 = fpext float %1932 to double
%1934 = fcmp une double %1933, 1.000000e+00
br i1 %1934, label %1935, label %1936
1935: ; preds = %1929, %1923, %1915
unreachable
1936: ; preds = %1929
br label %1937
1937: ; preds = %1936
store volatile float 0.000000e+00, float* %78
%1938 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 0
%1939 = load volatile float, float* %1938
%1940 = getelementptr inbounds { float, float }, { float, float }* %76, i32 0, i32 1
%1941 = load volatile float, float* %1940
%1942 = load volatile float, float* %78
%1943 = fadd float %1939, %1942
%1944 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 0
%1945 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 1
store volatile float %1943, float* %1944
store volatile float %1941, float* %1945
br label %1946
1946: ; preds = %1937
%1947 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 0
%1948 = load volatile float, float* %1947
%1949 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 1
%1950 = load volatile float, float* %1949
%1951 = fcmp une float %1948, 0.000000e+00
%1952 = fcmp une float %1950, 0.000000e+00
%1953 = or i1 %1951, %1952
br i1 %1953, label %1966, label %1954
1954: ; preds = %1946
%1955 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 0
%1956 = load volatile float, float* %1955
%1957 = call float @llvm.copysign.f32(float 1.000000e+00, float %1956)
%1958 = fpext float %1957 to double
%1959 = fcmp une double %1958, 1.000000e+00
br i1 %1959, label %1966, label %1960
1960: ; preds = %1954
%1961 = getelementptr inbounds { float, float }, { float, float }* %77, i32 0, i32 1
%1962 = load volatile float, float* %1961
%1963 = call float @llvm.copysign.f32(float 1.000000e+00, float %1962)
%1964 = fpext float %1963 to double
%1965 = fcmp une double %1964, 1.000000e+00
br i1 %1965, label %1966, label %1967
1966: ; preds = %1960, %1954, %1946
unreachable
1967: ; preds = %1960
br label %1968
1968: ; preds = %1967
br label %1969
1969: ; preds = %1968
br label %1970
1970: ; preds = %1969
br i1 false, label %1971, label %1977
1971: ; preds = %1970
br i1 true, label %1972, label %1973
1972: ; preds = %1971
br label %1974
1973: ; preds = %1971
br label %1974
1974: ; preds = %1973, %1972
%1975 = phi float [ 0.000000e+00, %1972 ], [ 0.000000e+00, %1973 ]
%1976 = phi float [ 0.000000e+00, %1972 ], [ -0.000000e+00, %1973 ]
br label %1983
1977: ; preds = %1970
br i1 true, label %1978, label %1979
1978: ; preds = %1977
br label %1980
1979: ; preds = %1977
br label %1980
1980: ; preds = %1979, %1978
%1981 = phi float [ -0.000000e+00, %1978 ], [ -0.000000e+00, %1979 ]
%1982 = phi float [ 0.000000e+00, %1978 ], [ -0.000000e+00, %1979 ]
br label %1983
1983: ; preds = %1980, %1974
%1984 = phi float [ %1975, %1974 ], [ %1981, %1980 ]
%1985 = phi float [ %1976, %1974 ], [ %1982, %1980 ]
%1986 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 0
%1987 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 1
store float %1984, float* %1986
store float %1985, float* %1987
br label %1988
1988: ; preds = %1983
%1989 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 0
%1990 = load float, float* %1989
%1991 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 1
%1992 = load float, float* %1991
%1993 = fcmp une float %1990, 0.000000e+00
%1994 = fcmp une float %1992, 0.000000e+00
%1995 = or i1 %1993, %1994
br i1 %1995, label %2008, label %1996
1996: ; preds = %1988
%1997 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 0
%1998 = load float, float* %1997
%1999 = call float @llvm.copysign.f32(float 1.000000e+00, float %1998)
%2000 = fpext float %1999 to double
%2001 = fcmp une double %2000, -1.000000e+00
br i1 %2001, label %2008, label %2002
2002: ; preds = %1996
%2003 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 1
%2004 = load float, float* %2003
%2005 = call float @llvm.copysign.f32(float 1.000000e+00, float %2004)
%2006 = fpext float %2005 to double
%2007 = fcmp une double %2006, 1.000000e+00
br i1 %2007, label %2008, label %2009
2008: ; preds = %2002, %1996, %1988
unreachable
2009: ; preds = %2002
br label %2010
2010: ; preds = %2009
store float -0.000000e+00, float* %81
%2011 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 0
%2012 = load float, float* %2011
%2013 = getelementptr inbounds { float, float }, { float, float }* %79, i32 0, i32 1
%2014 = load float, float* %2013
%2015 = load float, float* %81
%2016 = fadd float %2012, %2015
%2017 = getelementptr inbounds { float, float }, { float, float }* %80, i32 0, i32 0
%2018 = getelementptr inbounds { float, float }, { float, float }* %80, i32 0, i32 1
store float %2016, float* %2017
store float %2014, float* %2018
br label %2019
2019: ; preds = %2010
%2020 = getelementptr inbounds { float, float }, { float, float }* %80, i32 0, i32 0
%2021 = load float, float* %2020
%2022 = getelementptr inbounds { float, float }, { float, float }* %80, i32 0, i32 1
%2023 = load float, float* %2022
%2024 = fcmp une float %2021, 0.000000e+00
%2025 = fcmp une float %2023, 0.000000e+00
%2026 = or i1 %2024, %2025
br i1 %2026, label %2039, label %2027
2027: ; preds = %2019
%2028 = getelementptr inbounds { float, float }, { float, float }* %80, i32 0, i32 0
%2029 = load float, float* %2028
%2030 = call float @llvm.copysign.f32(float 1.000000e+00, float %2029)
%2031 = fpext float %2030 to double
%2032 = fcmp une double %2031, -1.000000e+00
br i1 %2032, label %2039, label %2033
2033: ; preds = %2027
%2034 = getelementptr inbounds { float, float }, { float, float }* %80, i32 0, i32 1
%2035 = load float, float* %2034
%2036 = call float @llvm.copysign.f32(float 1.000000e+00, float %2035)
%2037 = fpext float %2036 to double
%2038 = fcmp une double %2037, 1.000000e+00
br i1 %2038, label %2039, label %2040
2039: ; preds = %2033, %2027, %2019
unreachable
2040: ; preds = %2033
br label %2041
2041: ; preds = %2040
br i1 false, label %2042, label %2048
2042: ; preds = %2041
br i1 true, label %2043, label %2044
2043: ; preds = %2042
br label %2045
2044: ; preds = %2042
br label %2045
2045: ; preds = %2044, %2043
%2046 = phi float [ 0.000000e+00, %2043 ], [ 0.000000e+00, %2044 ]
%2047 = phi float [ 0.000000e+00, %2043 ], [ -0.000000e+00, %2044 ]
br label %2054
2048: ; preds = %2041
br i1 true, label %2049, label %2050
2049: ; preds = %2048
br label %2051
2050: ; preds = %2048
br label %2051
2051: ; preds = %2050, %2049
%2052 = phi float [ -0.000000e+00, %2049 ], [ -0.000000e+00, %2050 ]
%2053 = phi float [ 0.000000e+00, %2049 ], [ -0.000000e+00, %2050 ]
br label %2054
2054: ; preds = %2051, %2045
%2055 = phi float [ %2046, %2045 ], [ %2052, %2051 ]
%2056 = phi float [ %2047, %2045 ], [ %2053, %2051 ]
%2057 = getelementptr inbounds { float, float }, { float, float }* %82, i32 0, i32 0
%2058 = getelementptr inbounds { float, float }, { float, float }* %82, i32 0, i32 1
store volatile float %2055, float* %2057
store volatile float %2056, float* %2058
br label %2059
2059: ; preds = %2054
%2060 = getelementptr inbounds { float, float }, { float, float }* %82, i32 0, i32 0
%2061 = load volatile float, float* %2060
%2062 = getelementptr inbounds { float, float }, { float, float }* %82, i32 0, i32 1
%2063 = load volatile float, float* %2062
%2064 = fcmp une float %2061, 0.000000e+00
%2065 = fcmp une float %2063, 0.000000e+00
%2066 = or i1 %2064, %2065
br i1 %2066, label %2079, label %2067
2067: ; preds = %2059
%2068 = getelementptr inbounds { float, float }, { float, float }* %82, i32 0, i32 0
%2069 = load volatile float, float* %2068
%2070 = call float @llvm.copysign.f32(float 1.000000e+00, float %2069)
%2071 = fpext float %2070 to double
%2072 = fcmp une double %2071, -1.000000e+00
br i1 %2072, label %2079, label %2073
2073: ; preds = %2067
%2074 = getelementptr inbounds { float, float }, { float, float }* %82, i32 0, i32 1
%2075 = load volatile float, float* %2074
%2076 = call float @llvm.copysign.f32(float 1.000000e+00, float %2075)
%2077 = fpext float %2076 to double
%2078 = fcmp une double %2077, 1.000000e+00
br i1 %2078, label %2079, label %2080
2079: ; preds = %2073, %2067, %2059
unreachable
2080: ; preds = %2073
br label %2081
2081: ; preds = %2080
store volatile float -0.000000e+00, float* %84
%2082 = getelementptr inbounds { float, float }, { float, float }* %82, i32 0, i32 0
%2083 = load volatile float, float* %2082
%2084 = getelementptr inbounds { float, float }, { float, float }* %82, i32 0, i32 1
%2085 = load volatile float, float* %2084
%2086 = load volatile float, float* %84
%2087 = fadd float %2083, %2086
%2088 = getelementptr inbounds { float, float }, { float, float }* %83, i32 0, i32 0
%2089 = getelementptr inbounds { float, float }, { float, float }* %83, i32 0, i32 1
store volatile float %2087, float* %2088
store volatile float %2085, float* %2089
br label %2090
2090: ; preds = %2081
%2091 = getelementptr inbounds { float, float }, { float, float }* %83, i32 0, i32 0
%2092 = load volatile float, float* %2091
%2093 = getelementptr inbounds { float, float }, { float, float }* %83, i32 0, i32 1
%2094 = load volatile float, float* %2093
%2095 = fcmp une float %2092, 0.000000e+00
%2096 = fcmp une float %2094, 0.000000e+00
%2097 = or i1 %2095, %2096
br i1 %2097, label %2110, label %2098
2098: ; preds = %2090
%2099 = getelementptr inbounds { float, float }, { float, float }* %83, i32 0, i32 0
%2100 = load volatile float, float* %2099
%2101 = call float @llvm.copysign.f32(float 1.000000e+00, float %2100)
%2102 = fpext float %2101 to double
%2103 = fcmp une double %2102, -1.000000e+00
br i1 %2103, label %2110, label %2104
2104: ; preds = %2098
%2105 = getelementptr inbounds { float, float }, { float, float }* %83, i32 0, i32 1
%2106 = load volatile float, float* %2105
%2107 = call float @llvm.copysign.f32(float 1.000000e+00, float %2106)
%2108 = fpext float %2107 to double
%2109 = fcmp une double %2108, 1.000000e+00
br i1 %2109, label %2110, label %2111
2110: ; preds = %2104, %2098, %2090
unreachable
2111: ; preds = %2104
br label %2112
2112: ; preds = %2111
br label %2113
2113: ; preds = %2112
br label %2114
2114: ; preds = %2113
br i1 false, label %2115, label %2121
2115: ; preds = %2114
br i1 false, label %2116, label %2117
2116: ; preds = %2115
br label %2118
2117: ; preds = %2115
br label %2118
2118: ; preds = %2117, %2116
%2119 = phi float [ 0.000000e+00, %2116 ], [ 0.000000e+00, %2117 ]
%2120 = phi float [ 0.000000e+00, %2116 ], [ -0.000000e+00, %2117 ]
br label %2127
2121: ; preds = %2114
br i1 false, label %2122, label %2123
2122: ; preds = %2121
br label %2124
2123: ; preds = %2121
br label %2124
2124: ; preds = %2123, %2122
%2125 = phi float [ -0.000000e+00, %2122 ], [ -0.000000e+00, %2123 ]
%2126 = phi float [ 0.000000e+00, %2122 ], [ -0.000000e+00, %2123 ]
br label %2127
2127: ; preds = %2124, %2118
%2128 = phi float [ %2119, %2118 ], [ %2125, %2124 ]
%2129 = phi float [ %2120, %2118 ], [ %2126, %2124 ]
%2130 = getelementptr inbounds { float, float }, { float, float }* %85, i32 0, i32 0
%2131 = getelementptr inbounds { float, float }, { float, float }* %85, i32 0, i32 1
store float %2128, float* %2130
store float %2129, float* %2131
br label %2132
2132: ; preds = %2127
%2133 = getelementptr inbounds { float, float }, { float, float }* %85, i32 0, i32 0
%2134 = load float, float* %2133
%2135 = getelementptr inbounds { float, float }, { float, float }* %85, i32 0, i32 1
%2136 = load float, float* %2135
%2137 = fcmp une float %2134, 0.000000e+00
%2138 = fcmp une float %2136, 0.000000e+00
%2139 = or i1 %2137, %2138
br i1 %2139, label %2152, label %2140
2140: ; preds = %2132
%2141 = getelementptr inbounds { float, float }, { float, float }* %85, i32 0, i32 0
%2142 = load float, float* %2141
%2143 = call float @llvm.copysign.f32(float 1.000000e+00, float %2142)
%2144 = fpext float %2143 to double
%2145 = fcmp une double %2144, -1.000000e+00
br i1 %2145, label %2152, label %2146
2146: ; preds = %2140
%2147 = getelementptr inbounds { float, float }, { float, float }* %85, i32 0, i32 1
%2148 = load float, float* %2147
%2149 = call float @llvm.copysign.f32(float 1.000000e+00, float %2148)
%2150 = fpext float %2149 to double
%2151 = fcmp une double %2150, -1.000000e+00
br i1 %2151, label %2152, label %2153
2152: ; preds = %2146, %2140, %2132
unreachable
2153: ; preds = %2146
br label %2154
2154: ; preds = %2153
store float 0.000000e+00, float* %87
%2155 = getelementptr inbounds { float, float }, { float, float }* %85, i32 0, i32 0
%2156 = load float, float* %2155
%2157 = getelementptr inbounds { float, float }, { float, float }* %85, i32 0, i32 1
%2158 = load float, float* %2157
%2159 = load float, float* %87
%2160 = fadd float %2156, %2159
%2161 = getelementptr inbounds { float, float }, { float, float }* %86, i32 0, i32 0
%2162 = getelementptr inbounds { float, float }, { float, float }* %86, i32 0, i32 1
store float %2160, float* %2161
store float %2158, float* %2162
br label %2163
2163: ; preds = %2154
%2164 = getelementptr inbounds { float, float }, { float, float }* %86, i32 0, i32 0
%2165 = load float, float* %2164
%2166 = getelementptr inbounds { float, float }, { float, float }* %86, i32 0, i32 1
%2167 = load float, float* %2166
%2168 = fcmp une float %2165, 0.000000e+00
%2169 = fcmp une float %2167, 0.000000e+00
%2170 = or i1 %2168, %2169
br i1 %2170, label %2183, label %2171
2171: ; preds = %2163
%2172 = getelementptr inbounds { float, float }, { float, float }* %86, i32 0, i32 0
%2173 = load float, float* %2172
%2174 = call float @llvm.copysign.f32(float 1.000000e+00, float %2173)
%2175 = fpext float %2174 to double
%2176 = fcmp une double %2175, 1.000000e+00
br i1 %2176, label %2183, label %2177
2177: ; preds = %2171
%2178 = getelementptr inbounds { float, float }, { float, float }* %86, i32 0, i32 1
%2179 = load float, float* %2178
%2180 = call float @llvm.copysign.f32(float 1.000000e+00, float %2179)
%2181 = fpext float %2180 to double
%2182 = fcmp une double %2181, -1.000000e+00
br i1 %2182, label %2183, label %2184
2183: ; preds = %2177, %2171, %2163
unreachable
2184: ; preds = %2177
br label %2185
2185: ; preds = %2184
br i1 false, label %2186, label %2192
2186: ; preds = %2185
br i1 false, label %2187, label %2188
2187: ; preds = %2186
br label %2189
2188: ; preds = %2186
br label %2189
2189: ; preds = %2188, %2187
%2190 = phi float [ 0.000000e+00, %2187 ], [ 0.000000e+00, %2188 ]
%2191 = phi float [ 0.000000e+00, %2187 ], [ -0.000000e+00, %2188 ]
br label %2198
2192: ; preds = %2185
br i1 false, label %2193, label %2194
2193: ; preds = %2192
br label %2195
2194: ; preds = %2192
br label %2195
2195: ; preds = %2194, %2193
%2196 = phi float [ -0.000000e+00, %2193 ], [ -0.000000e+00, %2194 ]
%2197 = phi float [ 0.000000e+00, %2193 ], [ -0.000000e+00, %2194 ]
br label %2198
2198: ; preds = %2195, %2189
%2199 = phi float [ %2190, %2189 ], [ %2196, %2195 ]
%2200 = phi float [ %2191, %2189 ], [ %2197, %2195 ]
%2201 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 0
%2202 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 1
store volatile float %2199, float* %2201
store volatile float %2200, float* %2202
br label %2203
2203: ; preds = %2198
%2204 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 0
%2205 = load volatile float, float* %2204
%2206 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 1
%2207 = load volatile float, float* %2206
%2208 = fcmp une float %2205, 0.000000e+00
%2209 = fcmp une float %2207, 0.000000e+00
%2210 = or i1 %2208, %2209
br i1 %2210, label %2223, label %2211
2211: ; preds = %2203
%2212 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 0
%2213 = load volatile float, float* %2212
%2214 = call float @llvm.copysign.f32(float 1.000000e+00, float %2213)
%2215 = fpext float %2214 to double
%2216 = fcmp une double %2215, -1.000000e+00
br i1 %2216, label %2223, label %2217
2217: ; preds = %2211
%2218 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 1
%2219 = load volatile float, float* %2218
%2220 = call float @llvm.copysign.f32(float 1.000000e+00, float %2219)
%2221 = fpext float %2220 to double
%2222 = fcmp une double %2221, -1.000000e+00
br i1 %2222, label %2223, label %2224
2223: ; preds = %2217, %2211, %2203
unreachable
2224: ; preds = %2217
br label %2225
2225: ; preds = %2224
store volatile float 0.000000e+00, float* %90
%2226 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 0
%2227 = load volatile float, float* %2226
%2228 = getelementptr inbounds { float, float }, { float, float }* %88, i32 0, i32 1
%2229 = load volatile float, float* %2228
%2230 = load volatile float, float* %90
%2231 = fadd float %2227, %2230
%2232 = getelementptr inbounds { float, float }, { float, float }* %89, i32 0, i32 0
%2233 = getelementptr inbounds { float, float }, { float, float }* %89, i32 0, i32 1
store volatile float %2231, float* %2232
store volatile float %2229, float* %2233
br label %2234
2234: ; preds = %2225
%2235 = getelementptr inbounds { float, float }, { float, float }* %89, i32 0, i32 0
%2236 = load volatile float, float* %2235
%2237 = getelementptr inbounds { float, float }, { float, float }* %89, i32 0, i32 1
%2238 = load volatile float, float* %2237
%2239 = fcmp une float %2236, 0.000000e+00
%2240 = fcmp une float %2238, 0.000000e+00
%2241 = or i1 %2239, %2240
br i1 %2241, label %2254, label %2242
2242: ; preds = %2234
%2243 = getelementptr inbounds { float, float }, { float, float }* %89, i32 0, i32 0
%2244 = load volatile float, float* %2243
%2245 = call float @llvm.copysign.f32(float 1.000000e+00, float %2244)
%2246 = fpext float %2245 to double
%2247 = fcmp une double %2246, 1.000000e+00
br i1 %2247, label %2254, label %2248
2248: ; preds = %2242
%2249 = getelementptr inbounds { float, float }, { float, float }* %89, i32 0, i32 1
%2250 = load volatile float, float* %2249
%2251 = call float @llvm.copysign.f32(float 1.000000e+00, float %2250)
%2252 = fpext float %2251 to double
%2253 = fcmp une double %2252, -1.000000e+00
br i1 %2253, label %2254, label %2255
2254: ; preds = %2248, %2242, %2234
unreachable
2255: ; preds = %2248
br label %2256
2256: ; preds = %2255
br label %2257
2257: ; preds = %2256
br label %2258
2258: ; preds = %2257
br i1 false, label %2259, label %2265
2259: ; preds = %2258
br i1 false, label %2260, label %2261
2260: ; preds = %2259
br label %2262
2261: ; preds = %2259
br label %2262
2262: ; preds = %2261, %2260
%2263 = phi float [ 0.000000e+00, %2260 ], [ 0.000000e+00, %2261 ]
%2264 = phi float [ 0.000000e+00, %2260 ], [ -0.000000e+00, %2261 ]
br label %2271
2265: ; preds = %2258
br i1 false, label %2266, label %2267
2266: ; preds = %2265
br label %2268
2267: ; preds = %2265
br label %2268
2268: ; preds = %2267, %2266
%2269 = phi float [ -0.000000e+00, %2266 ], [ -0.000000e+00, %2267 ]
%2270 = phi float [ 0.000000e+00, %2266 ], [ -0.000000e+00, %2267 ]
br label %2271
2271: ; preds = %2268, %2262
%2272 = phi float [ %2263, %2262 ], [ %2269, %2268 ]
%2273 = phi float [ %2264, %2262 ], [ %2270, %2268 ]
%2274 = getelementptr inbounds { float, float }, { float, float }* %91, i32 0, i32 0
%2275 = getelementptr inbounds { float, float }, { float, float }* %91, i32 0, i32 1
store float %2272, float* %2274
store float %2273, float* %2275
br label %2276
2276: ; preds = %2271
%2277 = getelementptr inbounds { float, float }, { float, float }* %91, i32 0, i32 0
%2278 = load float, float* %2277
%2279 = getelementptr inbounds { float, float }, { float, float }* %91, i32 0, i32 1
%2280 = load float, float* %2279
%2281 = fcmp une float %2278, 0.000000e+00
%2282 = fcmp une float %2280, 0.000000e+00
%2283 = or i1 %2281, %2282
br i1 %2283, label %2296, label %2284
2284: ; preds = %2276
%2285 = getelementptr inbounds { float, float }, { float, float }* %91, i32 0, i32 0
%2286 = load float, float* %2285
%2287 = call float @llvm.copysign.f32(float 1.000000e+00, float %2286)
%2288 = fpext float %2287 to double
%2289 = fcmp une double %2288, -1.000000e+00
br i1 %2289, label %2296, label %2290
2290: ; preds = %2284
%2291 = getelementptr inbounds { float, float }, { float, float }* %91, i32 0, i32 1
%2292 = load float, float* %2291
%2293 = call float @llvm.copysign.f32(float 1.000000e+00, float %2292)
%2294 = fpext float %2293 to double
%2295 = fcmp une double %2294, -1.000000e+00
br i1 %2295, label %2296, label %2297
2296: ; preds = %2290, %2284, %2276
unreachable
2297: ; preds = %2290
br label %2298
2298: ; preds = %2297
store float -0.000000e+00, float* %93
%2299 = getelementptr inbounds { float, float }, { float, float }* %91, i32 0, i32 0
%2300 = load float, float* %2299
%2301 = getelementptr inbounds { float, float }, { float, float }* %91, i32 0, i32 1
%2302 = load float, float* %2301
%2303 = load float, float* %93
%2304 = fadd float %2300, %2303
%2305 = getelementptr inbounds { float, float }, { float, float }* %92, i32 0, i32 0
%2306 = getelementptr inbounds { float, float }, { float, float }* %92, i32 0, i32 1
store float %2304, float* %2305
store float %2302, float* %2306
br label %2307
2307: ; preds = %2298
%2308 = getelementptr inbounds { float, float }, { float, float }* %92, i32 0, i32 0
%2309 = load float, float* %2308
%2310 = getelementptr inbounds { float, float }, { float, float }* %92, i32 0, i32 1
%2311 = load float, float* %2310
%2312 = fcmp une float %2309, 0.000000e+00
%2313 = fcmp une float %2311, 0.000000e+00
%2314 = or i1 %2312, %2313
br i1 %2314, label %2327, label %2315
2315: ; preds = %2307
%2316 = getelementptr inbounds { float, float }, { float, float }* %92, i32 0, i32 0
%2317 = load float, float* %2316
%2318 = call float @llvm.copysign.f32(float 1.000000e+00, float %2317)
%2319 = fpext float %2318 to double
%2320 = fcmp une double %2319, -1.000000e+00
br i1 %2320, label %2327, label %2321
2321: ; preds = %2315
%2322 = getelementptr inbounds { float, float }, { float, float }* %92, i32 0, i32 1
%2323 = load float, float* %2322
%2324 = call float @llvm.copysign.f32(float 1.000000e+00, float %2323)
%2325 = fpext float %2324 to double
%2326 = fcmp une double %2325, -1.000000e+00
br i1 %2326, label %2327, label %2328
2327: ; preds = %2321, %2315, %2307
unreachable
2328: ; preds = %2321
br label %2329
2329: ; preds = %2328
br i1 false, label %2330, label %2336
2330: ; preds = %2329
br i1 false, label %2331, label %2332
2331: ; preds = %2330
br label %2333
2332: ; preds = %2330
br label %2333
2333: ; preds = %2332, %2331
%2334 = phi float [ 0.000000e+00, %2331 ], [ 0.000000e+00, %2332 ]
%2335 = phi float [ 0.000000e+00, %2331 ], [ -0.000000e+00, %2332 ]
br label %2342
2336: ; preds = %2329
br i1 false, label %2337, label %2338
2337: ; preds = %2336
br label %2339
2338: ; preds = %2336
br label %2339
2339: ; preds = %2338, %2337
%2340 = phi float [ -0.000000e+00, %2337 ], [ -0.000000e+00, %2338 ]
%2341 = phi float [ 0.000000e+00, %2337 ], [ -0.000000e+00, %2338 ]
br label %2342
2342: ; preds = %2339, %2333
%2343 = phi float [ %2334, %2333 ], [ %2340, %2339 ]
%2344 = phi float [ %2335, %2333 ], [ %2341, %2339 ]
%2345 = getelementptr inbounds { float, float }, { float, float }* %94, i32 0, i32 0
%2346 = getelementptr inbounds { float, float }, { float, float }* %94, i32 0, i32 1
store volatile float %2343, float* %2345
store volatile float %2344, float* %2346
br label %2347
2347: ; preds = %2342
%2348 = getelementptr inbounds { float, float }, { float, float }* %94, i32 0, i32 0
%2349 = load volatile float, float* %2348
%2350 = getelementptr inbounds { float, float }, { float, float }* %94, i32 0, i32 1
%2351 = load volatile float, float* %2350
%2352 = fcmp une float %2349, 0.000000e+00
%2353 = fcmp une float %2351, 0.000000e+00
%2354 = or i1 %2352, %2353
br i1 %2354, label %2367, label %2355
2355: ; preds = %2347
%2356 = getelementptr inbounds { float, float }, { float, float }* %94, i32 0, i32 0
%2357 = load volatile float, float* %2356
%2358 = call float @llvm.copysign.f32(float 1.000000e+00, float %2357)
%2359 = fpext float %2358 to double
%2360 = fcmp une double %2359, -1.000000e+00
br i1 %2360, label %2367, label %2361
2361: ; preds = %2355
%2362 = getelementptr inbounds { float, float }, { float, float }* %94, i32 0, i32 1
%2363 = load volatile float, float* %2362
%2364 = call float @llvm.copysign.f32(float 1.000000e+00, float %2363)
%2365 = fpext float %2364 to double
%2366 = fcmp une double %2365, -1.000000e+00
br i1 %2366, label %2367, label %2368
2367: ; preds = %2361, %2355, %2347
unreachable
2368: ; preds = %2361
br label %2369
2369: ; preds = %2368
store volatile float -0.000000e+00, float* %96
%2370 = getelementptr inbounds { float, float }, { float, float }* %94, i32 0, i32 0
%2371 = load volatile float, float* %2370
%2372 = getelementptr inbounds { float, float }, { float, float }* %94, i32 0, i32 1
%2373 = load volatile float, float* %2372
%2374 = load volatile float, float* %96
%2375 = fadd float %2371, %2374
%2376 = getelementptr inbounds { float, float }, { float, float }* %95, i32 0, i32 0
%2377 = getelementptr inbounds { float, float }, { float, float }* %95, i32 0, i32 1
store volatile float %2375, float* %2376
store volatile float %2373, float* %2377
br label %2378
2378: ; preds = %2369
%2379 = getelementptr inbounds { float, float }, { float, float }* %95, i32 0, i32 0
%2380 = load volatile float, float* %2379
%2381 = getelementptr inbounds { float, float }, { float, float }* %95, i32 0, i32 1
%2382 = load volatile float, float* %2381
%2383 = fcmp une float %2380, 0.000000e+00
%2384 = fcmp une float %2382, 0.000000e+00
%2385 = or i1 %2383, %2384
br i1 %2385, label %2398, label %2386
2386: ; preds = %2378
%2387 = getelementptr inbounds { float, float }, { float, float }* %95, i32 0, i32 0
%2388 = load volatile float, float* %2387
%2389 = call float @llvm.copysign.f32(float 1.000000e+00, float %2388)
%2390 = fpext float %2389 to double
%2391 = fcmp une double %2390, -1.000000e+00
br i1 %2391, label %2398, label %2392
2392: ; preds = %2386
%2393 = getelementptr inbounds { float, float }, { float, float }* %95, i32 0, i32 1
%2394 = load volatile float, float* %2393
%2395 = call float @llvm.copysign.f32(float 1.000000e+00, float %2394)
%2396 = fpext float %2395 to double
%2397 = fcmp une double %2396, -1.000000e+00
br i1 %2397, label %2398, label %2399
2398: ; preds = %2392, %2386, %2378
unreachable
2399: ; preds = %2392
br label %2400
2400: ; preds = %2399
br label %2401
2401: ; preds = %2400
br label %2402
2402: ; preds = %2401
ret void
}

LLVM IR (-O2):
define void @check_add_float() {
%1 = alloca float
%2 = alloca float
%3 = alloca float
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = alloca float
%50 = alloca float
%51 = alloca float
%52 = alloca float
%53 = alloca float
%54 = alloca float
%55 = alloca float
%56 = alloca float
%57 = alloca float
%58 = alloca float
%59 = alloca float
%60 = alloca float
%61 = alloca float
%62 = alloca float
%63 = alloca float
%64 = alloca float
%65 = alloca float
%66 = alloca float
%67 = alloca float
%68 = alloca float
%69 = alloca float
%70 = alloca float
%71 = alloca float
%72 = alloca float
%73 = alloca float
%74 = alloca float
%75 = alloca float
%76 = alloca float
%77 = alloca float
%78 = alloca float
%79 = alloca float
%80 = alloca float
%81 = bitcast float* %1 to i8*
%82 = bitcast float* %2 to i8*
%83 = bitcast float* %3 to i8*
%84 = bitcast float* %4 to i8*
%85 = bitcast float* %5 to i8*
store volatile float 0.000000e+00, float* %1
store volatile float 0.000000e+00, float* %2
store volatile float 0.000000e+00, float* %3
%86 = load volatile float, float* %2
%87 = load volatile float, float* %3
%88 = fcmp une float %86, 0.000000e+00
%89 = fcmp une float %87, 0.000000e+00
%90 = or i1 %88, %89
br i1 %90, label %99, label %91
91: ; preds = %0
%92 = load volatile float, float* %2
%93 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %92)
%94 = fcmp une float %93, 1.000000e+00
br i1 %94, label %99, label %95
95: ; preds = %91
%96 = load volatile float, float* %3
%97 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %96)
%98 = fcmp une float %97, 1.000000e+00
br i1 %98, label %99, label %100
99: ; preds = %95, %91, %0
tail call void @abort()
unreachable
100: ; preds = %95
%101 = load volatile float, float* %1
%102 = load volatile float, float* %2
%103 = load volatile float, float* %3
%104 = fadd float %101, %102
store volatile float %104, float* %4
store volatile float %103, float* %5
%105 = load volatile float, float* %4
%106 = load volatile float, float* %5
%107 = fcmp une float %105, 0.000000e+00
%108 = fcmp une float %106, 0.000000e+00
%109 = or i1 %107, %108
br i1 %109, label %118, label %110
110: ; preds = %100
%111 = load volatile float, float* %4
%112 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %111)
%113 = fcmp une float %112, 1.000000e+00
br i1 %113, label %118, label %114
114: ; preds = %110
%115 = load volatile float, float* %5
%116 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %115)
%117 = fcmp une float %116, 1.000000e+00
br i1 %117, label %118, label %119
118: ; preds = %114, %110, %100
tail call void @abort()
unreachable
119: ; preds = %114
%120 = bitcast float* %6 to i8*
%121 = bitcast float* %7 to i8*
%122 = bitcast float* %8 to i8*
%123 = bitcast float* %9 to i8*
%124 = bitcast float* %10 to i8*
store volatile float 0.000000e+00, float* %6
store volatile float 0.000000e+00, float* %7
store volatile float -0.000000e+00, float* %8
%125 = load volatile float, float* %7
%126 = load volatile float, float* %8
%127 = fcmp une float %125, 0.000000e+00
%128 = fcmp une float %126, 0.000000e+00
%129 = or i1 %127, %128
br i1 %129, label %138, label %130
130: ; preds = %119
%131 = load volatile float, float* %7
%132 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %131)
%133 = fcmp une float %132, 1.000000e+00
br i1 %133, label %138, label %134
134: ; preds = %130
%135 = load volatile float, float* %8
%136 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %135)
%137 = fcmp une float %136, -1.000000e+00
br i1 %137, label %138, label %139
138: ; preds = %134, %130, %119
tail call void @abort()
unreachable
139: ; preds = %134
%140 = load volatile float, float* %6
%141 = load volatile float, float* %7
%142 = load volatile float, float* %8
%143 = fadd float %140, %141
store volatile float %143, float* %9
store volatile float %142, float* %10
%144 = load volatile float, float* %9
%145 = load volatile float, float* %10
%146 = fcmp une float %144, 0.000000e+00
%147 = fcmp une float %145, 0.000000e+00
%148 = or i1 %146, %147
br i1 %148, label %157, label %149
149: ; preds = %139
%150 = load volatile float, float* %9
%151 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %150)
%152 = fcmp une float %151, 1.000000e+00
br i1 %152, label %157, label %153
153: ; preds = %149
%154 = load volatile float, float* %10
%155 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %154)
%156 = fcmp une float %155, -1.000000e+00
br i1 %156, label %157, label %158
157: ; preds = %153, %149, %139
tail call void @abort()
unreachable
158: ; preds = %153
%159 = bitcast float* %11 to i8*
%160 = bitcast float* %12 to i8*
%161 = bitcast float* %13 to i8*
%162 = bitcast float* %14 to i8*
%163 = bitcast float* %15 to i8*
store volatile float 0.000000e+00, float* %11
store volatile float -0.000000e+00, float* %12
store volatile float 0.000000e+00, float* %13
%164 = load volatile float, float* %12
%165 = load volatile float, float* %13
%166 = fcmp une float %164, 0.000000e+00
%167 = fcmp une float %165, 0.000000e+00
%168 = or i1 %166, %167
br i1 %168, label %177, label %169
169: ; preds = %158
%170 = load volatile float, float* %12
%171 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %170)
%172 = fcmp une float %171, -1.000000e+00
br i1 %172, label %177, label %173
173: ; preds = %169
%174 = load volatile float, float* %13
%175 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %174)
%176 = fcmp une float %175, 1.000000e+00
br i1 %176, label %177, label %178
177: ; preds = %173, %169, %158
tail call void @abort()
unreachable
178: ; preds = %173
%179 = load volatile float, float* %11
%180 = load volatile float, float* %12
%181 = load volatile float, float* %13
%182 = fadd float %179, %180
store volatile float %182, float* %14
store volatile float %181, float* %15
%183 = load volatile float, float* %14
%184 = load volatile float, float* %15
%185 = fcmp une float %183, 0.000000e+00
%186 = fcmp une float %184, 0.000000e+00
%187 = or i1 %185, %186
br i1 %187, label %196, label %188
188: ; preds = %178
%189 = load volatile float, float* %14
%190 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %189)
%191 = fcmp une float %190, 1.000000e+00
br i1 %191, label %196, label %192
192: ; preds = %188
%193 = load volatile float, float* %15
%194 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %193)
%195 = fcmp une float %194, 1.000000e+00
br i1 %195, label %196, label %197
196: ; preds = %192, %188, %178
tail call void @abort()
unreachable
197: ; preds = %192
%198 = bitcast float* %16 to i8*
%199 = bitcast float* %17 to i8*
%200 = bitcast float* %18 to i8*
%201 = bitcast float* %19 to i8*
%202 = bitcast float* %20 to i8*
store volatile float 0.000000e+00, float* %16
store volatile float -0.000000e+00, float* %17
store volatile float -0.000000e+00, float* %18
%203 = load volatile float, float* %17
%204 = load volatile float, float* %18
%205 = fcmp une float %203, 0.000000e+00
%206 = fcmp une float %204, 0.000000e+00
%207 = or i1 %205, %206
br i1 %207, label %216, label %208
208: ; preds = %197
%209 = load volatile float, float* %17
%210 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %209)
%211 = fcmp une float %210, -1.000000e+00
br i1 %211, label %216, label %212
212: ; preds = %208
%213 = load volatile float, float* %18
%214 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %213)
%215 = fcmp une float %214, -1.000000e+00
br i1 %215, label %216, label %217
216: ; preds = %212, %208, %197
tail call void @abort()
unreachable
217: ; preds = %212
%218 = load volatile float, float* %16
%219 = load volatile float, float* %17
%220 = load volatile float, float* %18
%221 = fadd float %218, %219
store volatile float %221, float* %19
store volatile float %220, float* %20
%222 = load volatile float, float* %19
%223 = load volatile float, float* %20
%224 = fcmp une float %222, 0.000000e+00
%225 = fcmp une float %223, 0.000000e+00
%226 = or i1 %224, %225
br i1 %226, label %235, label %227
227: ; preds = %217
%228 = load volatile float, float* %19
%229 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %228)
%230 = fcmp une float %229, 1.000000e+00
br i1 %230, label %235, label %231
231: ; preds = %227
%232 = load volatile float, float* %20
%233 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %232)
%234 = fcmp une float %233, -1.000000e+00
br i1 %234, label %235, label %236
235: ; preds = %231, %227, %217
tail call void @abort()
unreachable
236: ; preds = %231
%237 = bitcast float* %21 to i8*
%238 = bitcast float* %22 to i8*
%239 = bitcast float* %23 to i8*
%240 = bitcast float* %24 to i8*
%241 = bitcast float* %25 to i8*
store volatile float -0.000000e+00, float* %21
store volatile float 0.000000e+00, float* %22
store volatile float 0.000000e+00, float* %23
%242 = load volatile float, float* %22
%243 = load volatile float, float* %23
%244 = fcmp une float %242, 0.000000e+00
%245 = fcmp une float %243, 0.000000e+00
%246 = or i1 %244, %245
br i1 %246, label %255, label %247
247: ; preds = %236
%248 = load volatile float, float* %22
%249 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %248)
%250 = fcmp une float %249, 1.000000e+00
br i1 %250, label %255, label %251
251: ; preds = %247
%252 = load volatile float, float* %23
%253 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %252)
%254 = fcmp une float %253, 1.000000e+00
br i1 %254, label %255, label %256
255: ; preds = %251, %247, %236
tail call void @abort()
unreachable
256: ; preds = %251
%257 = load volatile float, float* %21
%258 = load volatile float, float* %22
%259 = load volatile float, float* %23
%260 = fadd float %257, %258
store volatile float %260, float* %24
store volatile float %259, float* %25
%261 = load volatile float, float* %24
%262 = load volatile float, float* %25
%263 = fcmp une float %261, 0.000000e+00
%264 = fcmp une float %262, 0.000000e+00
%265 = or i1 %263, %264
br i1 %265, label %274, label %266
266: ; preds = %256
%267 = load volatile float, float* %24
%268 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %267)
%269 = fcmp une float %268, 1.000000e+00
br i1 %269, label %274, label %270
270: ; preds = %266
%271 = load volatile float, float* %25
%272 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %271)
%273 = fcmp une float %272, 1.000000e+00
br i1 %273, label %274, label %275
274: ; preds = %270, %266, %256
tail call void @abort()
unreachable
275: ; preds = %270
%276 = bitcast float* %26 to i8*
%277 = bitcast float* %27 to i8*
%278 = bitcast float* %28 to i8*
%279 = bitcast float* %29 to i8*
%280 = bitcast float* %30 to i8*
store volatile float -0.000000e+00, float* %26
store volatile float 0.000000e+00, float* %27
store volatile float -0.000000e+00, float* %28
%281 = load volatile float, float* %27
%282 = load volatile float, float* %28
%283 = fcmp une float %281, 0.000000e+00
%284 = fcmp une float %282, 0.000000e+00
%285 = or i1 %283, %284
br i1 %285, label %294, label %286
286: ; preds = %275
%287 = load volatile float, float* %27
%288 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %287)
%289 = fcmp une float %288, 1.000000e+00
br i1 %289, label %294, label %290
290: ; preds = %286
%291 = load volatile float, float* %28
%292 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %291)
%293 = fcmp une float %292, -1.000000e+00
br i1 %293, label %294, label %295
294: ; preds = %290, %286, %275
tail call void @abort()
unreachable
295: ; preds = %290
%296 = load volatile float, float* %26
%297 = load volatile float, float* %27
%298 = load volatile float, float* %28
%299 = fadd float %296, %297
store volatile float %299, float* %29
store volatile float %298, float* %30
%300 = load volatile float, float* %29
%301 = load volatile float, float* %30
%302 = fcmp une float %300, 0.000000e+00
%303 = fcmp une float %301, 0.000000e+00
%304 = or i1 %302, %303
br i1 %304, label %313, label %305
305: ; preds = %295
%306 = load volatile float, float* %29
%307 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %306)
%308 = fcmp une float %307, 1.000000e+00
br i1 %308, label %313, label %309
309: ; preds = %305
%310 = load volatile float, float* %30
%311 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %310)
%312 = fcmp une float %311, -1.000000e+00
br i1 %312, label %313, label %314
313: ; preds = %309, %305, %295
tail call void @abort()
unreachable
314: ; preds = %309
%315 = bitcast float* %31 to i8*
%316 = bitcast float* %32 to i8*
%317 = bitcast float* %33 to i8*
%318 = bitcast float* %34 to i8*
%319 = bitcast float* %35 to i8*
store volatile float -0.000000e+00, float* %31
store volatile float -0.000000e+00, float* %32
store volatile float 0.000000e+00, float* %33
%320 = load volatile float, float* %32
%321 = load volatile float, float* %33
%322 = fcmp une float %320, 0.000000e+00
%323 = fcmp une float %321, 0.000000e+00
%324 = or i1 %322, %323
br i1 %324, label %333, label %325
325: ; preds = %314
%326 = load volatile float, float* %32
%327 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %326)
%328 = fcmp une float %327, -1.000000e+00
br i1 %328, label %333, label %329
329: ; preds = %325
%330 = load volatile float, float* %33
%331 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %330)
%332 = fcmp une float %331, 1.000000e+00
br i1 %332, label %333, label %334
333: ; preds = %329, %325, %314
tail call void @abort()
unreachable
334: ; preds = %329
%335 = load volatile float, float* %31
%336 = load volatile float, float* %32
%337 = load volatile float, float* %33
%338 = fadd float %335, %336
store volatile float %338, float* %34
store volatile float %337, float* %35
%339 = load volatile float, float* %34
%340 = load volatile float, float* %35
%341 = fcmp une float %339, 0.000000e+00
%342 = fcmp une float %340, 0.000000e+00
%343 = or i1 %341, %342
br i1 %343, label %352, label %344
344: ; preds = %334
%345 = load volatile float, float* %34
%346 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %345)
%347 = fcmp une float %346, -1.000000e+00
br i1 %347, label %352, label %348
348: ; preds = %344
%349 = load volatile float, float* %35
%350 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %349)
%351 = fcmp une float %350, 1.000000e+00
br i1 %351, label %352, label %353
352: ; preds = %348, %344, %334
tail call void @abort()
unreachable
353: ; preds = %348
%354 = bitcast float* %36 to i8*
%355 = bitcast float* %37 to i8*
%356 = bitcast float* %38 to i8*
%357 = bitcast float* %39 to i8*
%358 = bitcast float* %40 to i8*
store volatile float -0.000000e+00, float* %36
store volatile float -0.000000e+00, float* %37
store volatile float -0.000000e+00, float* %38
%359 = load volatile float, float* %37
%360 = load volatile float, float* %38
%361 = fcmp une float %359, 0.000000e+00
%362 = fcmp une float %360, 0.000000e+00
%363 = or i1 %361, %362
br i1 %363, label %372, label %364
364: ; preds = %353
%365 = load volatile float, float* %37
%366 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %365)
%367 = fcmp une float %366, -1.000000e+00
br i1 %367, label %372, label %368
368: ; preds = %364
%369 = load volatile float, float* %38
%370 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %369)
%371 = fcmp une float %370, -1.000000e+00
br i1 %371, label %372, label %373
372: ; preds = %368, %364, %353
tail call void @abort()
unreachable
373: ; preds = %368
%374 = load volatile float, float* %36
%375 = load volatile float, float* %37
%376 = load volatile float, float* %38
%377 = fadd float %374, %375
store volatile float %377, float* %39
store volatile float %376, float* %40
%378 = load volatile float, float* %39
%379 = load volatile float, float* %40
%380 = fcmp une float %378, 0.000000e+00
%381 = fcmp une float %379, 0.000000e+00
%382 = or i1 %380, %381
br i1 %382, label %391, label %383
383: ; preds = %373
%384 = load volatile float, float* %39
%385 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %384)
%386 = fcmp une float %385, -1.000000e+00
br i1 %386, label %391, label %387
387: ; preds = %383
%388 = load volatile float, float* %40
%389 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %388)
%390 = fcmp une float %389, -1.000000e+00
br i1 %390, label %391, label %392
391: ; preds = %387, %383, %373
tail call void @abort()
unreachable
392: ; preds = %387
%393 = bitcast float* %41 to i8*
%394 = bitcast float* %42 to i8*
%395 = bitcast float* %43 to i8*
%396 = bitcast float* %44 to i8*
%397 = bitcast float* %45 to i8*
store volatile float 0.000000e+00, float* %41
store volatile float 0.000000e+00, float* %42
%398 = load volatile float, float* %41
%399 = load volatile float, float* %42
%400 = fcmp une float %398, 0.000000e+00
%401 = fcmp une float %399, 0.000000e+00
%402 = or i1 %400, %401
br i1 %402, label %411, label %403
403: ; preds = %392
%404 = load volatile float, float* %41
%405 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %404)
%406 = fcmp une float %405, 1.000000e+00
br i1 %406, label %411, label %407
407: ; preds = %403
%408 = load volatile float, float* %42
%409 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %408)
%410 = fcmp une float %409, 1.000000e+00
br i1 %410, label %411, label %412
411: ; preds = %407, %403, %392
tail call void @abort()
unreachable
412: ; preds = %407
store volatile float 0.000000e+00, float* %45
%413 = load volatile float, float* %41
%414 = load volatile float, float* %42
%415 = load volatile float, float* %45
%416 = fadd float %413, %415
store volatile float %416, float* %43
store volatile float %414, float* %44
%417 = load volatile float, float* %43
%418 = load volatile float, float* %44
%419 = fcmp une float %417, 0.000000e+00
%420 = fcmp une float %418, 0.000000e+00
%421 = or i1 %419, %420
br i1 %421, label %430, label %422
422: ; preds = %412
%423 = load volatile float, float* %43
%424 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %423)
%425 = fcmp une float %424, 1.000000e+00
br i1 %425, label %430, label %426
426: ; preds = %422
%427 = load volatile float, float* %44
%428 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %427)
%429 = fcmp une float %428, 1.000000e+00
br i1 %429, label %430, label %431
430: ; preds = %426, %422, %412
tail call void @abort()
unreachable
431: ; preds = %426
%432 = bitcast float* %46 to i8*
%433 = bitcast float* %47 to i8*
%434 = bitcast float* %48 to i8*
%435 = bitcast float* %49 to i8*
%436 = bitcast float* %50 to i8*
store volatile float 0.000000e+00, float* %46
store volatile float 0.000000e+00, float* %47
%437 = load volatile float, float* %46
%438 = load volatile float, float* %47
%439 = fcmp une float %437, 0.000000e+00
%440 = fcmp une float %438, 0.000000e+00
%441 = or i1 %439, %440
br i1 %441, label %450, label %442
442: ; preds = %431
%443 = load volatile float, float* %46
%444 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %443)
%445 = fcmp une float %444, 1.000000e+00
br i1 %445, label %450, label %446
446: ; preds = %442
%447 = load volatile float, float* %47
%448 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %447)
%449 = fcmp une float %448, 1.000000e+00
br i1 %449, label %450, label %451
450: ; preds = %446, %442, %431
tail call void @abort()
unreachable
451: ; preds = %446
store volatile float -0.000000e+00, float* %50
%452 = load volatile float, float* %46
%453 = load volatile float, float* %47
%454 = load volatile float, float* %50
%455 = fadd float %452, %454
store volatile float %455, float* %48
store volatile float %453, float* %49
%456 = load volatile float, float* %48
%457 = load volatile float, float* %49
%458 = fcmp une float %456, 0.000000e+00
%459 = fcmp une float %457, 0.000000e+00
%460 = or i1 %458, %459
br i1 %460, label %469, label %461
461: ; preds = %451
%462 = load volatile float, float* %48
%463 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %462)
%464 = fcmp une float %463, 1.000000e+00
br i1 %464, label %469, label %465
465: ; preds = %461
%466 = load volatile float, float* %49
%467 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %466)
%468 = fcmp une float %467, 1.000000e+00
br i1 %468, label %469, label %470
469: ; preds = %465, %461, %451
tail call void @abort()
unreachable
470: ; preds = %465
%471 = bitcast float* %51 to i8*
%472 = bitcast float* %52 to i8*
%473 = bitcast float* %53 to i8*
%474 = bitcast float* %54 to i8*
%475 = bitcast float* %55 to i8*
store volatile float 0.000000e+00, float* %51
store volatile float -0.000000e+00, float* %52
%476 = load volatile float, float* %51
%477 = load volatile float, float* %52
%478 = fcmp une float %476, 0.000000e+00
%479 = fcmp une float %477, 0.000000e+00
%480 = or i1 %478, %479
br i1 %480, label %489, label %481
481: ; preds = %470
%482 = load volatile float, float* %51
%483 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %482)
%484 = fcmp une float %483, 1.000000e+00
br i1 %484, label %489, label %485
485: ; preds = %481
%486 = load volatile float, float* %52
%487 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %486)
%488 = fcmp une float %487, -1.000000e+00
br i1 %488, label %489, label %490
489: ; preds = %485, %481, %470
tail call void @abort()
unreachable
490: ; preds = %485
store volatile float 0.000000e+00, float* %55
%491 = load volatile float, float* %51
%492 = load volatile float, float* %52
%493 = load volatile float, float* %55
%494 = fadd float %491, %493
store volatile float %494, float* %53
store volatile float %492, float* %54
%495 = load volatile float, float* %53
%496 = load volatile float, float* %54
%497 = fcmp une float %495, 0.000000e+00
%498 = fcmp une float %496, 0.000000e+00
%499 = or i1 %497, %498
br i1 %499, label %508, label %500
500: ; preds = %490
%501 = load volatile float, float* %53
%502 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %501)
%503 = fcmp une float %502, 1.000000e+00
br i1 %503, label %508, label %504
504: ; preds = %500
%505 = load volatile float, float* %54
%506 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %505)
%507 = fcmp une float %506, -1.000000e+00
br i1 %507, label %508, label %509
508: ; preds = %504, %500, %490
tail call void @abort()
unreachable
509: ; preds = %504
%510 = bitcast float* %56 to i8*
%511 = bitcast float* %57 to i8*
%512 = bitcast float* %58 to i8*
%513 = bitcast float* %59 to i8*
%514 = bitcast float* %60 to i8*
store volatile float 0.000000e+00, float* %56
store volatile float -0.000000e+00, float* %57
%515 = load volatile float, float* %56
%516 = load volatile float, float* %57
%517 = fcmp une float %515, 0.000000e+00
%518 = fcmp une float %516, 0.000000e+00
%519 = or i1 %517, %518
br i1 %519, label %528, label %520
520: ; preds = %509
%521 = load volatile float, float* %56
%522 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %521)
%523 = fcmp une float %522, 1.000000e+00
br i1 %523, label %528, label %524
524: ; preds = %520
%525 = load volatile float, float* %57
%526 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %525)
%527 = fcmp une float %526, -1.000000e+00
br i1 %527, label %528, label %529
528: ; preds = %524, %520, %509
tail call void @abort()
unreachable
529: ; preds = %524
store volatile float -0.000000e+00, float* %60
%530 = load volatile float, float* %56
%531 = load volatile float, float* %57
%532 = load volatile float, float* %60
%533 = fadd float %530, %532
store volatile float %533, float* %58
store volatile float %531, float* %59
%534 = load volatile float, float* %58
%535 = load volatile float, float* %59
%536 = fcmp une float %534, 0.000000e+00
%537 = fcmp une float %535, 0.000000e+00
%538 = or i1 %536, %537
br i1 %538, label %547, label %539
539: ; preds = %529
%540 = load volatile float, float* %58
%541 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %540)
%542 = fcmp une float %541, 1.000000e+00
br i1 %542, label %547, label %543
543: ; preds = %539
%544 = load volatile float, float* %59
%545 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %544)
%546 = fcmp une float %545, -1.000000e+00
br i1 %546, label %547, label %548
547: ; preds = %543, %539, %529
tail call void @abort()
unreachable
548: ; preds = %543
%549 = bitcast float* %61 to i8*
%550 = bitcast float* %62 to i8*
%551 = bitcast float* %63 to i8*
%552 = bitcast float* %64 to i8*
%553 = bitcast float* %65 to i8*
store volatile float -0.000000e+00, float* %61
store volatile float 0.000000e+00, float* %62
%554 = load volatile float, float* %61
%555 = load volatile float, float* %62
%556 = fcmp une float %554, 0.000000e+00
%557 = fcmp une float %555, 0.000000e+00
%558 = or i1 %556, %557
br i1 %558, label %567, label %559
559: ; preds = %548
%560 = load volatile float, float* %61
%561 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %560)
%562 = fcmp une float %561, -1.000000e+00
br i1 %562, label %567, label %563
563: ; preds = %559
%564 = load volatile float, float* %62
%565 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %564)
%566 = fcmp une float %565, 1.000000e+00
br i1 %566, label %567, label %568
567: ; preds = %563, %559, %548
tail call void @abort()
unreachable
568: ; preds = %563
store volatile float 0.000000e+00, float* %65
%569 = load volatile float, float* %61
%570 = load volatile float, float* %62
%571 = load volatile float, float* %65
%572 = fadd float %569, %571
store volatile float %572, float* %63
store volatile float %570, float* %64
%573 = load volatile float, float* %63
%574 = load volatile float, float* %64
%575 = fcmp une float %573, 0.000000e+00
%576 = fcmp une float %574, 0.000000e+00
%577 = or i1 %575, %576
br i1 %577, label %586, label %578
578: ; preds = %568
%579 = load volatile float, float* %63
%580 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %579)
%581 = fcmp une float %580, 1.000000e+00
br i1 %581, label %586, label %582
582: ; preds = %578
%583 = load volatile float, float* %64
%584 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %583)
%585 = fcmp une float %584, 1.000000e+00
br i1 %585, label %586, label %587
586: ; preds = %582, %578, %568
tail call void @abort()
unreachable
587: ; preds = %582
%588 = bitcast float* %66 to i8*
%589 = bitcast float* %67 to i8*
%590 = bitcast float* %68 to i8*
%591 = bitcast float* %69 to i8*
%592 = bitcast float* %70 to i8*
store volatile float -0.000000e+00, float* %66
store volatile float 0.000000e+00, float* %67
%593 = load volatile float, float* %66
%594 = load volatile float, float* %67
%595 = fcmp une float %593, 0.000000e+00
%596 = fcmp une float %594, 0.000000e+00
%597 = or i1 %595, %596
br i1 %597, label %606, label %598
598: ; preds = %587
%599 = load volatile float, float* %66
%600 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %599)
%601 = fcmp une float %600, -1.000000e+00
br i1 %601, label %606, label %602
602: ; preds = %598
%603 = load volatile float, float* %67
%604 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %603)
%605 = fcmp une float %604, 1.000000e+00
br i1 %605, label %606, label %607
606: ; preds = %602, %598, %587
tail call void @abort()
unreachable
607: ; preds = %602
store volatile float -0.000000e+00, float* %70
%608 = load volatile float, float* %66
%609 = load volatile float, float* %67
%610 = load volatile float, float* %70
%611 = fadd float %608, %610
store volatile float %611, float* %68
store volatile float %609, float* %69
%612 = load volatile float, float* %68
%613 = load volatile float, float* %69
%614 = fcmp une float %612, 0.000000e+00
%615 = fcmp une float %613, 0.000000e+00
%616 = or i1 %614, %615
br i1 %616, label %625, label %617
617: ; preds = %607
%618 = load volatile float, float* %68
%619 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %618)
%620 = fcmp une float %619, -1.000000e+00
br i1 %620, label %625, label %621
621: ; preds = %617
%622 = load volatile float, float* %69
%623 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %622)
%624 = fcmp une float %623, 1.000000e+00
br i1 %624, label %625, label %626
625: ; preds = %621, %617, %607
tail call void @abort()
unreachable
626: ; preds = %621
%627 = bitcast float* %71 to i8*
%628 = bitcast float* %72 to i8*
%629 = bitcast float* %73 to i8*
%630 = bitcast float* %74 to i8*
%631 = bitcast float* %75 to i8*
store volatile float -0.000000e+00, float* %71
store volatile float -0.000000e+00, float* %72
%632 = load volatile float, float* %71
%633 = load volatile float, float* %72
%634 = fcmp une float %632, 0.000000e+00
%635 = fcmp une float %633, 0.000000e+00
%636 = or i1 %634, %635
br i1 %636, label %645, label %637
637: ; preds = %626
%638 = load volatile float, float* %71
%639 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %638)
%640 = fcmp une float %639, -1.000000e+00
br i1 %640, label %645, label %641
641: ; preds = %637
%642 = load volatile float, float* %72
%643 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %642)
%644 = fcmp une float %643, -1.000000e+00
br i1 %644, label %645, label %646
645: ; preds = %641, %637, %626
tail call void @abort()
unreachable
646: ; preds = %641
store volatile float 0.000000e+00, float* %75
%647 = load volatile float, float* %71
%648 = load volatile float, float* %72
%649 = load volatile float, float* %75
%650 = fadd float %647, %649
store volatile float %650, float* %73
store volatile float %648, float* %74
%651 = load volatile float, float* %73
%652 = load volatile float, float* %74
%653 = fcmp une float %651, 0.000000e+00
%654 = fcmp une float %652, 0.000000e+00
%655 = or i1 %653, %654
br i1 %655, label %664, label %656
656: ; preds = %646
%657 = load volatile float, float* %73
%658 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %657)
%659 = fcmp une float %658, 1.000000e+00
br i1 %659, label %664, label %660
660: ; preds = %656
%661 = load volatile float, float* %74
%662 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %661)
%663 = fcmp une float %662, -1.000000e+00
br i1 %663, label %664, label %665
664: ; preds = %660, %656, %646
tail call void @abort()
unreachable
665: ; preds = %660
%666 = bitcast float* %76 to i8*
%667 = bitcast float* %77 to i8*
%668 = bitcast float* %78 to i8*
%669 = bitcast float* %79 to i8*
%670 = bitcast float* %80 to i8*
store volatile float -0.000000e+00, float* %76
store volatile float -0.000000e+00, float* %77
%671 = load volatile float, float* %76
%672 = load volatile float, float* %77
%673 = fcmp une float %671, 0.000000e+00
%674 = fcmp une float %672, 0.000000e+00
%675 = or i1 %673, %674
br i1 %675, label %684, label %676
676: ; preds = %665
%677 = load volatile float, float* %76
%678 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %677)
%679 = fcmp une float %678, -1.000000e+00
br i1 %679, label %684, label %680
680: ; preds = %676
%681 = load volatile float, float* %77
%682 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %681)
%683 = fcmp une float %682, -1.000000e+00
br i1 %683, label %684, label %685
684: ; preds = %680, %676, %665
tail call void @abort()
unreachable
685: ; preds = %680
store volatile float -0.000000e+00, float* %80
%686 = load volatile float, float* %76
%687 = load volatile float, float* %77
%688 = load volatile float, float* %80
%689 = fadd float %686, %688
store volatile float %689, float* %78
store volatile float %687, float* %79
%690 = load volatile float, float* %78
%691 = load volatile float, float* %79
%692 = fcmp une float %690, 0.000000e+00
%693 = fcmp une float %691, 0.000000e+00
%694 = or i1 %692, %693
br i1 %694, label %703, label %695
695: ; preds = %685
%696 = load volatile float, float* %78
%697 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %696)
%698 = fcmp une float %697, -1.000000e+00
br i1 %698, label %703, label %699
699: ; preds = %695
%700 = load volatile float, float* %79
%701 = tail call float @llvm.copysign.f32(float 1.000000e+00, float %700)
%702 = fcmp une float %701, -1.000000e+00
br i1 %702, label %703, label %704
703: ; preds = %699, %695, %685
tail call void @abort()
unreachable
704: ; preds = %699
ret void
}