#include <set>
#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <limits>
#include <map>
#include <numeric>

#define ll long long
using namespace std;
static ll imin = std::numeric_limits<ll>::min();
static ll imax = std::numeric_limits<ll>::max();
#define rep(i, n) for(int i = 0; (i)<(n); ++(i))
#define rep1(i, n) for(int i = 1; (i)<(n); ++(i))
#define rev_rep(i, n) for(int i = (n) - 1; (i) >= 0; --(i))
#define range(a, i, b) for(int i = (a); (i) < (b); ++(i))
#define dump(x) cout << #x << ":" << x << "\n";
#define all(v) v.begin(), v.end()
#define readl(N) ll N; cin >> N
#define readlv(N, vec) vector<ll> vec(N); rep(i, N){cin >> vec[i];}
#define greater_than [](ll l, ll r){return l > r;}
template<class T1, class T2>
std::ostream& operator << (std::ostream& os, std::map<T1, T2>& mp);
template<class T1, class T2>
std::ostream& operator << (std::ostream& os, std::pair<T1, T2>& pair);
template<class T>
std::ostream& operator << (std::ostream& os, std::vector<T>& vec);
template<class T1, class T2>
std::ostream& operator << (std::ostream& os, std::pair<T1, T2>& pair){
  os << '(' << pair.first << ',' << pair.second << ')';
  return os;
}

template<class T>
std::ostream& operator << (std::ostream& os, std::vector<T>& vec){
  std::size_t n = vec.size();
  if(n == 0){
    return os;
  }
  os << " ";
  for(ll i = 0; i<n - 1; ++i){
    os << vec[i] << " ";
  }
  os << vec[n - 1];
  os << std::endl;
  return os;
}

template<class T1, class T2>
std::ostream& operator << (std::ostream& os, std::map<T1, T2>& mp){
  std::size_t n = mp.size();
  if(n == 0){
    return os;
  }
  os << " ";
  for(auto && x:mp){
    os << x << " ";
  }
  os << std::endl;
  return os;
}

template<class T>
std::ostream& operator << (std::ostream& os, std::set<T>& mp){
  std::size_t n = mp.size();
  if(n == 0){
    return os;
  }
  os << " ";
  for(auto && x:mp){
    os << x << " ";
  }
  os << std::endl;
  return os;
}

template<class T> inline bool chmin(T& a, T const b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template<class T> inline bool chmax(T& a, T const b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

ll fact(ll n){
  ll res=1;
  while(n>=0){
    res*=n;
    n--;
  }
  return res;
}
    
ll pow(ll i, ll n){
  ll res=1;
  while(n>=0){
    res*=i;
    n--;
  }
  return res;
}
vector<vector<ll>> graph;
vector<ll> visited;
bool ok = false;
bool search(ll current){
  // dump(current);
  if(visited[current]){
    return false;
  }

  visited[current] = 1;
  bool end = true;
  rep(i, 4){
    if(visited[i] == 0){
      end = false;
    }
  }
  
  if(end){
    ok = true;
    return true;
  }
  
  rep(j, 4){
    if(graph[current][j]){
      if(search(j)){
        continue;
      }else{
        return false;
      }
    }
  }
  return true;
}

#ifndef BOOST_TEST_MAIN
int main(int const argc, char const** argv){
  graph = vector<vector<ll>>(4, vector<ll>(4, 0));
  rep(i, 3){
    ll a, b;
    cin >> a >> b;
    graph[a - 1][b - 1] = graph[b - 1][a - 1] = 1;
  }
  
  rep(st, 4){
    // dump("beg");
    ok = false;
    visited = vector<ll>(4, 0);
    search(st);
    if(ok){
      cout << "YES" << endl;
      return 0;
    }
  }

  cout << "NO" << endl;

  return 0;
  
}
#endif

// #include <set>
// #include <string>
// #include <iostream>
// #include <vector>
// #include <algorithm>
// #include <stack>
// #include <queue>
// #include <limits>
// #include <map>
// #include <numeric>

// #define ll long long
// using namespace std;
// static ll imin = std::numeric_limits<ll>::min();
// static ll imax = std::numeric_limits<ll>::max();
// #define rep(i, n) for(int i = 0; (i)<(n); ++(i))
// #define rep1(i, n) for(int i = 1; (i)<(n); ++(i))
// #define rev_rep(i, n) for(int i = (n) - 1; (i) >= 0; --(i))
// #define range(a, i, b) for(int i = (a); (i) < (b); ++(i))
// #define dump(x) cout << #x << ":" << x << "\n";
// #define all(v) v.begin(), v.end()
// #define readl(N) ll N; cin >> N
// #define readlv(N, vec) vector<ll> vec(N); rep(i, N){cin >> vec[i];}
// #define greater_than [](ll l, ll r){return l > r;}
// template<class T1, class T2>
// std::ostream& operator << (std::ostream& os, std::map<T1, T2>& mp);
// template<class T1, class T2>
// std::ostream& operator << (std::ostream& os, std::pair<T1, T2>& pair);
// template<class T>
// std::ostream& operator << (std::ostream& os, std::vector<T>& vec);
// template<class T1, class T2>
// std::ostream& operator << (std::ostream& os, std::pair<T1, T2>& pair){
//   os << '(' << pair.first << ',' << pair.second << ')';
//   return os;
// }

// template<class T>
// std::ostream& operator << (std::ostream& os, std::vector<T>& vec){
//   std::size_t n = vec.size();
//   if(n == 0){
//     return os;
//   }
//   os << " ";
//   for(ll i = 0; i<n - 1; ++i){
//     os << vec[i] << " ";
//   }
//   os << vec[n - 1];
//   os << std::endl;
//   return os;
// }

// template<class T1, class T2>
// std::ostream& operator << (std::ostream& os, std::map<T1, T2>& mp){
//   std::size_t n = mp.size();
//   if(n == 0){
//     return os;
//   }
//   os << " ";
//   for(auto && x:mp){
//     os << x << " ";
//   }
//   os << std::endl;
//   return os;
// }

// template<class T>
// std::ostream& operator << (std::ostream& os, std::set<T>& mp){
//   std::size_t n = mp.size();
//   if(n == 0){
//     return os;
//   }
//   os << " ";
//   for(auto && x:mp){
//     os << x << " ";
//   }
//   os << std::endl;
//   return os;
// }

// template<class T> inline bool chmin(T& a, T const b) {
//   if (a > b) {
//     a = b;
//     return true;
//   }
//   return false;
// }
// template<class T> inline bool chmax(T& a, T const b) {
//   if (a < b) {
//     a = b;
//     return true;
//   }
//   return false;
// }

// ll fact(ll n){
//   ll res=1;
//   while(n>=0){
//     res*=n;
//     n--;
//   }
//   return res;
// }
    
// ll pow(ll i, ll n){
//   ll res=1;
//   while(n>=0){
//     res*=i;
//     n--;
//   }
//   return res;
// }

// vector<vector<bool>> graph;
// vector<ll> visited(50);

// bool dfs(ll v){

//   visited[v]=true;
//   for (int v2 = 0; v2 < 3; v2++) {
//     if(graph[v][v2]==false) continue;
//     if(visited[v2]==true) return false;
//     if(!dfs(v2)){
//       return false;
//     }
//   }
  
//   return true;
// }


// int main(){
//   auto origgraph=vector<vector<bool>>(4, vector<bool>(4, false));
//   vector<ll> a(3), b(3);
//   rep(i,3){
//     ll f,t;
//     cin >> f >> t;
//     a[i]=f-1;
//     b[i]=t-1;
//     origgraph[f-1][t-1]=origgraph[t-1][f-1]=true;
//   }
  
//   //dump(graph);
//   ll res=0;
  
//   for (int i = 0; i < 4; i++) {
//     auto graph = origgraph;
//     for (int j = 0; j < 4; j++) visited[j]=false;
//     auto r = dfs(0);
//     if(r){
//       rep(j, 4){
//         if(!visited[j]){
//           r = false;
//         }
//       }
//       if(r){
//         cout << "YES" << endl;
//         return 0;
//       }
//     }

//     cout<<"NO"<<endl;
//     return 0;
//   }
// }


Measured memory_bytes: 256