#include "iostream"
#include "fstream"
#include "algorithm"
#include "iomanip"
#include "stack"
#include "queue"
#include "string"
#include "vector"
#include "map"
#include "set"
#include "unordered_set"
#include "unordered_map"
#include "iterator"
#include <ctime>
#include "bitset"
#include "cmath"
#include "list"
#include "complex"
#include <cassert>
#include "deque"
#include "numeric"
#include <cstdio>

using namespace std;

//#define f(i,n) for(int i=0; i<n;i++) 
//#define rf(i, n) for(int i=n-1;i>=0;i--)
//#define forn(i, j, n) for(int i=j; i<n; i++)
//#define ff(i, j, n) f(i, n)f(j, n)
#define pb push_back
#define mp make_pair
#define maxi(a,b) a = max(a, b);
#define mini(a,b) a = min(a, b);
#define endl '\n'
#define all(a) a.begin(), a.end()
#define sqr(x) ((x) * (x))
#define SZ(a) ((int)(a.size()))
#define watch(x) cout << (#x) << " = " << x << endl;
//typedef long long ll;
typedef long double ld;
#define int long long
#define double ld
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<pii> vpii;
typedef vector<char> vc;

template<class T>
void show(const vector<T> &a)
{
	for (T x : a)
		cout << x << " ";
	cout << endl;
}

const int sze = 1e5 + 50, oo = 1e18 + 500, mod = 1e9 + 7;
const double eps = 1e-9, PI = 2 * acos(0.0);
vi vertices[sze];
vc visit(sze, false);
vi arr(sze, 0);
int n, m, k;
int A, B;
int cnt = 0;
//int s, t;
//
//struct edge {
//	int from, to, flow, cap;
//};
//
//vector<edge> e;
//
//void add_edge(int u, int v, int w)
//{
//	edge e1 = { u, v, 0, w };
//	edge e2 = { v, u, 0, 0 };
//
//	vertices[u].pb(e.size());
//	e.pb(e1);
//	vertices[v].pb(e.size());
//	e.pb(e2);
//}
//
//int d[sze], ptr[sze];
//
//bool bfs()
//{
//	queue<int> q;
//	q.push(s);
//
//	fill(d, d + n + 10, -1);
//	d[s] = 0;
//
//	while (!q.empty() && d[t] == -1)
//	{
//		int v = q.front();
//		q.pop();
//
//		for (auto id : vertices[v])
//		{
//			int to = e[id].to;
//
//			if (d[to] == -1 && e[id].cap > e[id].flow)
//			{
//				q.push(to);
//				d[to] = d[v] + 1;
//			}
//		}
//	}
//
//	return d[t] != -1;
//}
//
//int dfs(int v, int flow)
//{
//	if (!flow)
//		return 0;
//
//	if (v == t && flow != oo)
//		return flow;
//
//	for (; ptr[v] < vertices[v].size(); ptr[v] ++)
//	{
//		int id = vertices[v][ptr[v]];
//		int to = e[id].to;
//
//		if (d[to] != d[v] + 1) continue;
//
//		int pushed = dfs(to, min(flow, e[id].cap - e[id].flow));
//
//		if (pushed)
//		{
//			e[id].flow += pushed;
//			e[id ^ 1].flow -= pushed;
//			return pushed;
//		}
//	}
//
//	return 0;
//}
//
//
//int dinic()
//{
//	int flow = 0;
//
//	while (bfs())
//	{
//		fill(ptr, ptr + n + 10, 0);
//		while (int pushed = dfs(s, oo))
//		{
//			flow += pushed;
//		}
//	}
//
//	return flow;
//}
//
//bool from[sze], to[sze];

bool check(vi & perm)
{
	for (int i = 0; i < 3; i++)
	{
		int u = perm[i];
		int v = perm[i + 1];

		bool b = false;
		for (auto to : vertices[u])
		{
			if (to == v)
			{
				b = true;
			}
		}

		if (!b)
		{
			return false;
		}
	}

	return true;
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	for (int i = 0; i < 3; i++)
	{
		int u, v;
		cin >> u >> v;
		u--;
		v--;
		vertices[u].pb(v);
		vertices[v].pb(u);
	}

	vi perm;
	for (int i = 0; i < 4; i++)
	{
		perm.pb(i);
	}

	do
	{
		if (check(perm))
		{
			cout << "YES";
			return 0;
		}
	} 
	while (next_permutation(all(perm)));

	cout << "NO";
	return 0;
}



Measured memory_bytes: 3456