#include <iostream>
#include <sstream>
#include <cmath>
using namespace std;

#define EPS (1e-10)
#define equals(a, b) (fabs((a)-(b)) < EPS )

// Point, Vector class
class Point {
public:
  double x, y;

  Point( double x = 0, double y = 0 ): x(x), y(y){}

  Point operator + ( Point p ){ return Point( x + p.x, y + p.y ); }
  Point operator - ( Point p ){ return Point( x - p.x, y - p.y ); }
  Point operator * ( double k ){ return Point( x * k, y * k ); }

  double abs() { return sqrt( norm() ); }
  double norm() { return x * x + y * y; }

  bool operator < ( const Point& p ) const {
    return x != p.x ? x < p.x : y < p.y;
  }

  bool operator == ( const Point& p ) const {
    return fabs( x - p.x ) < EPS && fabs( y - p.y ) < EPS;
  }
};
typedef Point Vector;

// Segment
struct Segment {
  Point p1, p2;
};
typedef Segment Line;

double norm( Point p ) {
  return p.x * p.x + p.y * p.y;
}

double abs( Point p ) {
  return sqrt( norm( p ) );
}

// ¥Ù¥¯¥È¥E, b¤ÎÆâÀÑ¤òµá¤á¤E
double dot( Vector a, Vector b ) {
  return a.x * b.x + a.y * b.y;
}

// ¥Ù¥¯¥È¥E, b¤Î³°ÀÑ¤òµá¤á¤E
double cross( Vector a, Vector b ) {
  return a.x * b.y - a.y * b.x;
}

// ¥Ù¥¯¥È¥E, b¤ÎÄ¾¸òÈ½ÄE
bool isOrthogonal( Vector a, Vector b ) {
  return equals( dot(a, b), 0.0 );
}

// À&#63730;Ê¬a1a2, b1b2¤ÎÄ¾¸òÈ½Äê¤ò¹Ô¤¦
bool isOrthogonal( Point a1, Point a2, Point b1, Point b2 ) {
  return isOrthogonal( a1 - a2, b1 - b2 );
}

// À&#63730;Ê¬s1, s2¤ÎÄ¾¸òÈ½Äê¤ò¹Ô¤¦
bool isOrthogonal( Segment s1, Segment s2 ) {
  return equals( dot( s1.p2 - s1.p1, s2.p2 - s2.p1 ), 0.0 );
}

// ¥Ù¥¯¥È¥E, b¤ÎÊ¿¹ÔÈ½Äê¤ò¹Ô¤¦
bool isParallel( Vector a, Vector b ) {
  return equals( cross( a, b ), 0.0 );
}

// À&#63730;Ê¬a1a2, b1b2¤ÎÊ¿¹ÔÈ½Äê¤ò¤ª¤³¤Ê¤¦
bool isParallel( Point a1, Point a2, Point b1, Point b2 ) {
  return isParallel( a1 - a2, b1 - b2 );
}

// À&#63730;Ê¬s1, s2¤ÎÊ¿¹ÔÈ½Äê¤ò¹Ô¤¦¥×¥úÁ°¥é¥E
bool isParallel( Segment s1, Segment s2 ) {
  return equals( cross( s1.p2-s1.p1, s2.p2 - s2.p1 ), 0.0 );
}

// À&#63730;Ê¬s¤ËÂÐ¤¹¤EÀp¤Î¼Í±Æ¤òµá¤á¤E
Point project( Segment s, Point p ) {
  Vector base = s.p2 - s.p1;
  double t = dot( p - s.p1, base ) / base.norm();
  return s.p1 + base * t;
}

// À&#63730;Ê¬s¤òÂÐ¾Î¼´¤È¤·¤¿ÅÀp¤ÎÀ&#63730;ÂÐ¾Î¤ÎÅÀx¤òµá¤á¤E
Point reflect( Segment s, Point p ) {
  return p + ( project( s, p ) - p ) * 2.0;
}

// ¥Ù¥¯¥È¥E0p1¤ËÂÐ¤¹¤EÀp2¤Î°ÌÃÖ´Ø·¸¤òµá¤á¤E
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

int ccw( Point p0, Point p1, Point p2 ) {
  Vector a = p1 - p0;
  Vector b = p2 - p0;
  if ( cross( a, b ) > EPS ) return COUNTER_CLOCKWISE;
  if ( cross( a, b ) < -EPS ) return CLOCKWISE;
  if ( dot( a, b ) < -EPS ) return ONLINE_BACK;
  if ( a.norm() < b.norm() ) return ONLINE_FRONT;
  return ON_SEGMENT;
}

// À&#63730;Ê¬p1p2¤ÈÀ&#63730;Ê¬p3p4¤Î¸òº¹È½Äê¤ò¹Ô¤¦
bool isIntersect( Point p1, Point p2, Point p3, Point p4 ) {
  return ( ccw( p1, p2, p3 ) * ccw( p1, p2, p4 ) <= 0 &&
	   ccw( p3, p4, p1 ) * ccw( p3, p4, p2 ) <= 0 );
}

// À&#63730;Ê¬s1, s2¤Î¸òº¹È½Äê¤ò¹Ô¤¦¥×¥úÁ°¥é¥E
bool isIntersect( Segment s1, Segment s2 ) {
  return isIntersect( s1.p1, s1.p2, s2.p1, s2.p2 );
}

// À&#63730;Ê¬s1¤ÈÀ&#63730;Ê¬s2¤Î¸òÅÀ¤òµá¤á¤E
Point getCrossPoint( Segment s1, Segment s2 ) {
  Vector base = s2.p2 - s2.p1;
  double d1 = abs( cross( base, s1.p1 - s2.p1 ) );
  double d2 = abs( cross( base, s1.p2 - s2.p1 ) );
  double t = d1 / ( d1 + d2 );
  return s1.p1 + ( s1.p2 - s1.p1 ) * t;
}

// ÅÀa¤ÈÅÀb¤Îµ÷Î¥¤òµá¤á¤E
double getDistance( Point a, Point b ) {
  Point c = a - b;
  return c.abs();
}

// Ä¾À&#63730;s¤ÈÅÀp¤Îµ÷Î¥¤òµá¤á¤E
double getDistanceLP( Line s, Point p ) {
  return abs( cross( s.p2 - s.p1, p - s.p1 ) / abs( s.p2 - s.p1 ) );
}

// À&#63730;Ê¬s¤ÈÅÀp¤Îµ÷Î¥¤òµá¤á¤E
double getDistanceSP( Segment s, Point p ) {
  Point c1 = p - s.p1;
  Point c2 = p - s.p2;
  if ( dot( s.p2 - s.p1, p - s.p1 ) < 0.0 ) return c1.abs();
  if ( dot( s.p1 - s.p2, p - s.p2 ) < 0.0 ) return c2.abs();
  return getDistanceLP( s, p );
}

// À&#63730;Ê¬s1¤ÈÀ&#63730;Ê¬s2¤Îµ÷Î¥¤òµá¤á¤E
double getDistance( Segment s1, Segment s2 ) {
  if ( isIntersect( s1, s2 ) ) return 0.0;
  return min( min( getDistanceSP( s1, s2.p1 ), getDistanceSP( s1, s2.p2 ) ),
	      min( getDistanceSP( s2, s1.p1 ), getDistanceSP( s2, s1.p2 ) ));
}

int main() {
  string line;
  while ( getline( cin, line ) ) {
    double xa1, ya1, xa2, ya2, xb1, yb1, xb2, yb2;
    istringstream is( line );
    is >> xa1 >> ya1 >> xa2 >> ya2 >> xb1 >> yb1 >> xb2 >> yb2;

    Line A[4] = {
      { Point( xa1, ya1 ), Point( xa2, ya1 ) },
      { Point( xa2, ya1 ), Point( xa2, ya2 ) },
      { Point( xa2, ya2 ), Point( xa1, ya2 ) },
      { Point( xa1, ya2 ), Point( xa1, ya1 ) }
    };
    Line B[4] = {
      { Point( xb1, yb1 ), Point( xb2, yb1 ) },
      { Point( xb2, yb1 ), Point( xb2, yb2 ) },
      { Point( xb2, yb2 ), Point( xb1, yb2 ) },
      { Point( xb1, yb2 ), Point( xb1, yb1 ) }
    };

    bool answer = false;
    if ( xa1 < xb1 && xa2 > xb2 && ya1 < yb1 && ya2 > yb2 ) answer = true;
    if ( xb1 < xa1 && xb2 > xa2 && yb1 < ya1 && yb2 > ya2 ) answer = true;

    for ( int i = 0; i < 4; i++ ) {
      for ( int j = 0; j < 4; j++ ) {
	    if ( isIntersect( A[i], B[j] ) ) answer = true;
      }
    }
   
    cout << ( answer ? "YES" : "NO" ) << endl;
  }
  return 0;
}

Measured memory_bytes: 0