#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<vector>
#include<map>
#include<cstdio>
#include<iomanip>
#include<set>
#include<numeric>
#include<queue>
#include<deque>
#include<utility>
#include<stack>
#include <random>
//constexpr int MOD = 1000000007;
constexpr int MOD = 998244353;
#pragma region Macros
using namespace std;
#define int long long
#define double long double


constexpr double PI = 3.14159265358979323846;
const  int INF = 1e12;
const int dx[8] = { 1, 0, -1, 0, 1, -1, -1, 1 };
const int dy[8] = { 0, 1, 0, -1, 1, 1, -1, -1 };


#define rep(i,n) for(int i=0;i<n;++i)
#define REP(i,n) for(int i=1;i<=n;i++)
#define krep(i,k,n) for(int i=(k);i<n+k;i++)
#define Krep(i,k,n) for(int i=(k);i<n;i++)
#define rrep(i,n) for(int i=n-1;i>=0;i--)
#define Rrep(i,n) for(int i=n;i>0;i--)
#define LAST(x) x[x.size()-1]
#define ALL(x) (x).begin(),(x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x)
#define RUD(a,b) ((a+b-1)/b)
#define sum1_n(n) ((n)*(n+1)/2)
#define SUM1n2(n) (n*(2*n+1)*(n+1))/6
#define SUMkn(k,n) (SUM1n(n)-SUM1n(k-1))
#define SZ(x) ((int)(x).size())
#define PB push_back
#define Fi first
#define Se second 

int factorial(int a) {
	if (a == 0)
		return 1;
	else
		return a * factorial(a - 1);
}
int nPr(int n, int r) {
	int s = n - r + 1;
	int sum = 1;
	for (int i = s; i <= n; i++)
		sum *= i;
	return sum;
}
int GCD(int a, int b){
	if (a < b)
		swap(a, b);
	if (b == 0)
		return a;
	if (a % b == 0)
		return b;
	return GCD(b, a % b);
}
int LCM(int a, int b){
	return  a / GCD(a, b)*b;
}

int divisor_count(int n) {
	//約数の数
	int ans = 0;
	REP(i, sqrt(n)) {
		if (n % i == 0)
			ans += 2;
		if (n == i * i)
			ans--;
	}
	return ans;
}
int divisor_sum(int n) {
	//約数の総和
	int ans = 0;
	REP(i, sqrt(n)) {
		if (n % i == 0)
			ans += i + n / i;
		if (n == i * i)
			ans -= n / i;
	}
	return ans;
}
int CEIL1(int n) {
	//1桁目切り上げ
	return (n + 9) / 10 * 10;
}
int getdigit(int n) {
	return log10(n) + 1;
}
/*
int digit(int n, int k) {
	//nのk桁目
	rep(i, k - 1)
		n /= 10;
	return n % 10;
}
*/
int DIVTIME(int n, int k) {
	//nをkで何回割れるか的な
	int div = 0;
	while (n % k == 0) {
		div++;
		n /= k;
	}
	return div;
}
#pragma region base
/*
int n_decimal(int k, int n) {
	int ans = 0;
	for (int i = 0; k > 0; i++) {
		ans += k % n * intpow(10, i);
		k /= n;
	}
	return ans;
}
*/
/*
int binary_2to10(string n) {
	int ans = 0;
	rep(i, n.size()) {
		if (n[i] == '1')
			ans += intpow(2, n.size() - i - 1);
	}
	return ans;
}
*/
string base_k(int n, int k) {
	//n(10)をk進数(string)で
	string ans = "";
	while (n) {
		ans += to_string(n % k);
		n /= k;
	}
	reverse(ALL(ans));
	return ans;
}
#pragma endregion
int intabs(int n) {
	if (n < 0)
		return -1 * n;
	else
		return n;
}
/*
int Kaibun(int n) {
	int ans = 0;
	int d = getdigit(n);
	REP(i, d)
		ans += digit(n, i) * pow(10, d - i);
	return ans;
}
*/




double LOG(int a, int b) {
	return log(b) / log(a);
}
double DISTANCE(int x1, int y1, int x2, int y2) {
	return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
double clock_angle(int h, int m) {
	h %= 12;
	double mm = 6.0 * m;
	double nn = 30.0 * h + 0.5 * m;
	return std::min(fabs(mm - nn), 360.0 - fabs(nn - mm));
}
inline bool BETWEEN(int x, int min, int max) {
	if (min <= x && x <= max)
		return true;
	else
		return false;
}
inline bool between(int x, int min, int max) {
	if (min < x && x < max)
		return true;
	else
		return false;
}
template<class T>
inline bool chmin(T& a, T b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template<class T>
inline bool chmax(T& a, T b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}

#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl

#pragma endregion

typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<vvint> vvvint;
typedef vector<string> vstring;
typedef vector<bool> vbool;
typedef vector<vbool> vvbool;
typedef map<int, int> mapint;
typedef pair<int, int> pint;
typedef vector<pint> vpint;
typedef vector<vpint> vvpint;
using Graph = vector<vint>;

#pragma region MOD
template<int MOD> struct Fp {
	long long val;
	constexpr Fp(long long v = 0) noexcept : val(v% MOD) {
		if (val < 0) val += MOD;
	}
	constexpr int getmod() const { return MOD; }
	constexpr Fp operator - () const noexcept {
		return val ? MOD - val : 0;
	}
	constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
	constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
	constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
	constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
	constexpr Fp& operator += (const Fp& r) noexcept {
		val += r.val;
		if (val >= MOD) val -= MOD;
		return *this;
	}
	constexpr Fp& operator -= (const Fp& r) noexcept {
		val -= r.val;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr Fp& operator *= (const Fp& r) noexcept {
		val = val * r.val % MOD;
		return *this;
	}
	constexpr Fp& operator /= (const Fp& r) noexcept {
		long long a = r.val, b = MOD, u = 1, v = 0;
		while (b) {
			long long t = a / b;
			a -= t * b, swap(a, b);
			u -= t * v, swap(u, v);
		}
		val = val * u % MOD;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr bool operator == (const Fp& r) const noexcept {
		return this->val == r.val;
	}
	constexpr bool operator != (const Fp& r) const noexcept {
		return this->val != r.val;
	}
	friend constexpr istream& operator >> (istream& is, Fp<MOD>& x) noexcept {
		is >> x.val;
		x.val %= MOD;
		if (x.val < 0) x.val += MOD;
		return is;
	}
	friend constexpr ostream& operator << (ostream& os, const Fp<MOD>& x) noexcept {
		return os << x.val;
	}
	friend constexpr Fp<MOD> modpow(const Fp<MOD>& r, long long n) noexcept {
		if (n == 0) return 1;
		if (n < 0) return modpow(modinv(r), -n);
		auto t = modpow(r, n / 2);
		t = t * t;
		if (n & 1) t = t * r;
		return t;
	}
	friend constexpr Fp<MOD> modinv(const Fp<MOD>& r) noexcept {
		long long a = r.val, b = MOD, u = 1, v = 0;
		while (b) {
			long long t = a / b;
			a -= t * b, swap(a, b);
			u -= t * v, swap(u, v);
		}
		return Fp<MOD>(u);
	}
};
using mint = Fp<MOD>;
#pragma endregion

#pragma region nCr
const int MAXR = 10000000;
int fac[MAXR], finv[MAXR], inv[MAXR];

void COMinit() {
	fac[0] = fac[1] = 1;
	finv[0] = finv[1] = 1;
	inv[1] = 1;
	for (int i = 2; i < MAXR; i++) {
		fac[i] = fac[i - 1] * i % MOD;
		inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
		finv[i] = finv[i - 1] * inv[i] % MOD;
	}
}

int nCr(int n, int k) {
	if (n < k)
		return 0;
	if (n < 0 || k < 0)
		return 0;
	return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

mint nCrm(long long N, long long K) {
	mint res = 1;
	for (long long n = 0; n < K; ++n) {
		res *= (N - n);
		res /= (n + 1);
	}
	return res;
}
int nCr2(int n, int r) {
	//MODらない奴
	int ans = 1;
	REP(i, r) {
		ans *= n--;
		ans /= i;
	}
	return ans;
}
#pragma endregion

vector<pint> prime_factorize(int N) {
	vector<pint>  res;
	for (int i = 2; i * i <= N; i++) {
		if (N % i != 0)
			continue;
		int ex = 0;
		while (N % i == 0) {
			++ex;
			N /= i;
		}
		res.push_back({ i, ex });
	}
	if (N != 1)
		res.push_back({ N, 1 });
	return res;
}
double median(vint a) {
	int N = a.size();
	if (N % 2 == 1)
		return (double)a[N / 2];
	else
		return (double)(a[N / 2 - 1] + a[N / 2]) / 2;
}


char z(char a, char b) {
	if (a > b)
		swap(a, b);
	if (a == b)
		return a;
	if (a == 'R' && b == 'S')
		return  'R';
	if (a == 'P' && b == 'R')
		return  'P';
	if (a == 'P' && b == 'S')
		return  'S';
}

typedef vector<mint> vmint;
typedef vector<vmint> vvmint;

int ipow(int x, int n, int M) {
	int ans = 1;
	while (n > 0) {
		if (n & 1)
			ans = ans * x % M;
		x = x * x % M;
		n >>= 1;
	}
	return ans;
}


template<typename T> class BIT {
private:
	int n;
	vector<T> bit;
public:
	// 0_indexed で i 番目の要素に x を加える
	void add(int i, T x) {
		i++;
		while (i < n) {
			bit[i] += x, i += i & -i;
		}
	}
	// 0_indexed で [0,i] の要素の和(両閉区間！！)
	T sum(int i) {
		i++;
		T s = 0;
		while (i > 0) {
			s += bit[i], i -= i & -i;
		}
		return s;
	}
	BIT() {}
	//初期値がすべて0の場合
	BIT(int sz) : n(sz + 1), bit(n, 0) {}
	BIT(const vector<T>& v) : n((int)v.size() + 1), bit(n, 0) {
		for (int i = 0; i < n - 1; i++) {
			add(i, v[i]);
		}
	}
	void print() {
		for (int i = 0; i < n - 1; i++) {
			cout << sum(i) - sum(i - 1) << " ";
		}
		cout << "\n";
	}
	//-1スタート
	void print_sum() {
		for (int i = 0; i < n; i++) {
			cout << sum(i - 1) << " ";
		}
		cout << "\n";
	}
};

// u を昇順にソートするのに必要な交換回数(転倒数) (u は {0,..., n-1} からなる重複を許した長さ n の数列)
long long inv_count(const vector<int>& u)
{
	int n = (int)u.size();
	BIT<int> bt(n);
	long long ans = 0;
	for (int i = 0; i < n; i++) {
		ans += i - bt.sum(u[i]);
		bt.add(u[i], 1);
	}
	return ans;
}

// u を v に変換するのに必要な交換回数(転倒数)
// (u, v は {0,..., n-1} からなる重複を許した長さ n の数列. ただし u, v 全体で各数字の個数は一致するものとする)
long long inv_count(const vector<int>& u, const vector<int>& v,int j)
{
	int n = (int)u.size();
	vector<vector<int> > p(n);
	BIT<int> bt(n);
	for (int i = n - 1; i >= 0; --i) {
		p[u[(i+j)%n]].push_back((i+j)%n);
	}
	long long ans = 0;
	for (int i = 0; i < n; ++i) {
		int pos = p[v[(i+j)%n]].back();
		p[v[(i+j)%n]].pop_back();
		ans += pos - bt.sum(pos);
		bt.add(pos, 1);
	}
	return ans;
}


int f (int n, int k) {
	int ans = 0,cnt = 1;
	while (n > 0) {
		ans += (n % 10) * cnt;
		cnt *= k;
		n /= 10;
	}
	return ans;
}

void dijkstra(vvpint& G, int s,vint& dist) {
	priority_queue<pint, vpint,greater<pint>> que;
	que.push({ 0, s });
	while (!que.empty()) {
		pint P = que.top();
		que.pop();
		int v = P.second;
		if (dist[v] < P.first)
			continue;
		dist[v] = P.first;
		for (auto& next : G[v])
			que.push({ dist[v] + next.second, next.first });
	}
}

signed main() {
	vint a(3), b(3);
	rep(i, 3)
		cin >> a[i];
	rep(i, 3)
		cin >> b[i];
	rep(i, 3) {
		rep(j, 3) {
			vint x(3), y(3);
			rep(k, 3)
				x[k] = a[k], y[k] = b[k];
			swap(x[i], y[j]);
			if (x[0] != x[1] && x[1] != x[2] && x[2] != x[0] && y[0] != y[1] && y[1] != y[2] && y[2] != y[0]) {
				int xm = x[1], ym = y[1];
				sort(ALL(x)), sort(ALL(y));
				if (xm != x[1] && ym != y[1]) {
					cout << "Yes" << endl;
					return 0;
				}
			}
		}
	}
	cout << "No" << endl;
}


//bit全探索テンプレ
/*
rep(bit,1<<N){
	vint S;
	rep(i,N){
		if (bit & (1 << i))
			S.push_back(i);
	}
}
*/

//グラフ受け取り
/*
int N, M;
cin >> N >> M;

Graph G(N);
rep(i, M) {
	int a, b;
	cin >> a >> b;
	a--,b--;
	G[a].push_back(b);
	G[b].push_back(a);
}
*/


//素因数分解する時のやつ
/*
const auto& res = prime_factorize(N);
for (auto p : res) {
}
*/

//グラフデバッグ
/*
REP(i, N) {
	cout << "G[" << i << "]=";
	rep(j, G[i].size)
		cout << G[i][j] << " ";
	cout << endl;
}
*/

// fixed << setprecision(15)<<
// << setw(2) << setfill('0')

/*
/*int NumberofDivsors(int N) {
	vector<pint> a = Prime_factorize(N);
	int ans = 1;
	for (pint p : a)
		ans *= p.second() + 1;
	return ans;
}
*/