#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x)  cerr << #x << " = " << (x) << endl;
using namespace std;


template<typename T>
class Value{
	T value;

	public:
	class boolean{
		bool b;
		public:
			boolean() { }
			boolean(bool b) : b(b) { }

			void operator = (const bool b){
				this->b = b;
			}

			boolean And(boolean a){ return b and a.get(); };
			boolean Or(boolean a){ return b or a.get(); };
			boolean Xor(boolean a){ return b xor a.get(); };

			bool get(){ return b; }
			void outyn(){ cout << (b ? "Yes" : "No") << endl; }
	};

	Value() { }
	Value(T value) : value(value) { }

	Value<T> add(Value<T> a){ return Value<T>(value + a.get()); }
	Value<T> sub(Value<T> a){ return Value<T>(value - a.get()); }
	Value<T> pro(Value<T> a){ return Value<T>(value * a.get()); }
	Value<T> div(Value<T> a){ return Value<T>(value / a.get()); }
	Value<T> mod(Value<T> a){ return Value<T>(value % a.get()); }

	Value<T> abs(){ return std::abs(value); }

	boolean eq(Value<T> a){ return value == a.get(); }
	boolean seq(Value<T> a){
		assert(typeid(a.get()) == typeid(string));
		std::set<char> x, y;
		for(auto i : value) x.emplace(i);
		for(auto i : a.get()) y.emplace(i);
		return x == y;
	}
	boolean gt(Value<T> a){ return value > a.get(); }
	boolean gtq(Value<T> a){ return value >= a.get(); }
	boolean lt(Value<T> a){ return value < a.get(); }
	boolean ltq(Value<T> a){ return value <= a.get(); }


	T get(){ return value; }
	void set(T v){ value = v; }

	auto begin(){ return value.begin(); }
	auto end(){ return value.end(); }

	void out(){ cout << value << endl; };
};

template<typename T>
Value<T> max(Value<T> a, Value<T> b){
	return a.get() < b.get() ? b : a;
}
template<typename T>
Value<T> min(Value<T> a, Value<T> b){
	return a.get() < b.get() ? a : b;
}

/* output */
template<typename T>
ostream& operator << (ostream& os, Value<T> t){
	os << t.get();
	return os;
}
void yn(bool b){
	cout << (b ? "Yes" : "No") << endl;
}
template<typename T> void out(T a){
	cout << a << endl;
}
template<typename T> void out(vector<T> a, bool space = true){
	rep(i,a.size()){
		cout << a[i] << (i + 1 == a.size() ? "\n" : (space ? " " : ""));
	}
}
template<typename T> void out(vector<vector<Value<T>>>& v){
	rep(i,v.size()){
		out(v[i]);
	}
}

/* 多重vector */
template <typename X, typename T>
auto vectors(X x, T a) {
	return vector<T>(x, a);
}

template <typename X, typename Y, typename Z, typename... Zs>
auto vectors(X x, Y y, Z z, Zs... zs) {
	auto cont = vectors(y, z, zs...);
	return vector<decltype(cont)>(x, cont);
}

/* input */
template<typename T>
istream& operator >> (istream& is, Value<T>& t){
	T res;
	is >> res;
	t.set(res);
	return is;
}

template<typename T> T in(){
	T res;
	cin >> res;
	return res;
}
template<typename T> vector<T> in(int n){
	vector<T> res(n);
	rep(i,n) res[i] = in<T>();
	return res;
}
template<typename T> vector<vector<T>> in(int h, int w){
	vector<vector<T>> res(h);
	rep(i,h) res[i] = in<T>(w);
	return res;
}


template<class C>
void solve(){
	vector<Value<typename C::T>> a = in<Value<typename C::T>>(C::Number());
	a[0].sub(a[1]).abs().ltq(a[3]).And(a[1].sub(a[2]).abs().ltq(a[3])).Or(a[0].sub(a[2]).abs().ltq(a[3])).outyn();
}

struct type{
	using T = int;
	static constexpr int Number(){ return 4; }
};

int main(){
	solve<type>();
}


Measured memory_bytes: 256