#include <iostream>
#include <algorithm>

double sqrtQuake(double number) {
  using std::int64_t;
      double ynum = number;
      double x2num = ynum * 0.5;
      int64_t inum = reinterpret_cast<int64_t>(
                    (reinterpret_cast<int64_t*>(&ynum)));
      inum = 0x5fe6eb50c7b537a9 - (inum >> 1);
      ynum = *(reinterpret_cast<double*>(&inum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      ynum = ynum * (1.5 - (x2num * ynum * ynum));
      return 1 / ynum;
}


void swap_s(int& al, int& bl) {
  int temp = al;
  al = bl;
  bl = temp;
}

inline double sqr(double num) {
  return num * num;
}

inline double max(double num, double snum) {
  return (num + snum + abs(num - snum)) * 0.5;
}

inline double min(double num, double snum) {
  return (num + snum - abs(num - snum)) * 0.5;
}

inline double getSin(double num) {
  return sqrtQuake(1 - num * num);
}

int main() {
  using std::cout;
  using std::cin;

  int al = 0;
  int bl = 0;
  int cl = 0;
  int dl = 0;
  int el = 0;

  double discrim = 0;
  double x1num = 0;
  double x2num = 0;
  double returnsin = 0;
  bool skipdiscrim = false;

  cin >> al >> bl >> cl >> dl >> el;

  // "quick" sort
  if (cl > bl) {
    swap_s(cl, bl);
    if (bl > al) {
      swap_s(bl, al);
    }
    if (cl > bl) {
      swap_s(cl, bl);
    }
  } else {
    if (bl > al) {
      swap_s(bl, al);
      if (cl > al) {
        swap_s(cl, al);
      }
    }
  }
  if (dl > el) {
    swap_s(dl, el);
  }


  if ((al <= dl && bl <= el) || (al <= el && bl <= dl)) {
      cout << "YES" << "\n";
      return 0;
  } else {
    if (( cl <= dl && bl <= el) || (cl <= el && bl <= dl)) {
      cout << "YES" << "\n";
      return 0;
    } else {
      if ((al <= dl && cl <= el) || (al <= el && cl <= dl)) {
        cout << "YES" << "\n";
        return 0;
      }
    }
  }
  double discrimab = 4 * (sqr(al) * sqr(dl)
                   + (sqr(al) + sqr(bl)) * (sqr(dl) - sqr(bl)));
  double discrimac = 4 * (sqr(al) * sqr(dl)
                   + (sqr(al) + sqr(bl)) * (sqr(dl) - sqr(bl)));
  double discrimbc = 4 * (sqr(bl) * sqr(dl)
                   + (sqr(bl) + sqr(cl)) * (sqr(dl) - sqr(cl)));



  double abrootone = (2 * al * dl
                  + sqrtQuake(discrimab))
                  / (2 * (sqr(al) + sqr(bl)));
  double abroottwo = (2 * al * dl
                  - sqrtQuake(discrimab))
                  / (2 * (sqr(al) + sqr(bl)));

  double acrootone = (2 * al * dl
                  + sqrtQuake(discrimac))
                  / (2 * (sqr(al) + sqr(cl)));

  double acroottwo = (2 * al * dl
                  - sqrtQuake(discrimac))
                  / (2 * (sqr(al) + sqr(cl)));

  double bcrootone = (2 * bl * dl
                  - sqrtQuake(discrimbc))
                  / (2 * (sqr(bl) + sqr(cl)));

  double bcroottwo = (2 * bl * dl
                  + sqrtQuake(discrimbc))
                  / (2 * (sqr(bl) + sqr(cl)));

  if((discrimab > 0 && al * getSin(abrootone) + bl * abrootone <= el
  || al * getSin(abroottwo) + bl * abroottwo <= el)
  || (discrimac > 0 && al * getSin(acrootone) + cl * acrootone <= el
  || al * getSin(acroottwo) + cl * acroottwo <= el)
  || (discrimbc > 0 && bl * getSin(bcrootone) + cl * acrootone <= el
  || bl * getSin(bcroottwo) + cl * acroottwo <= el)) {
    cout << "YES" << "\n";
  } else {
    cout << "NO" << "\n";
  }
  // ПЕРЕМОГА ИЛИ ЗРАДА?
  return 0;
}