#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

struct Rect {
    int w, h;
};

Rect a[3];
bool ok = false;

// Kiểm tra một cấu hình c cụ thể
bool check(Rect x, Rect y, Rect z) {
    long long area = 1LL * x.w * x.h + 1LL * y.w * y.h + 1LL * z.w * z.h;
    long long side = sqrt(area);
    if (side * side != area) return false;

    // Case 1: 3 hình xếp thành hàng/dọc
    if (x.h == y.h && y.h == z.h && x.h == side && x.w + y.w + z.w == side) return true;
    if (x.w == y.w && y.w == z.w && x.w == side && x.h + y.h + z.h == side) return true;

    // Case 2: 2 hình trên, 1 hình dưới
    if (x.w + y.w == side && x.h == y.h && x.h + z.h == side && z.w == side) return true;

    // Case 3: 2 hình dọc, 1 hình ngang
    if (x.h + y.h == side && x.w == y.w && x.w + z.w == side && z.h == side) return true;

    return false;
}

void backtrack(int i) {
    if (i == 3) {
        vector<int> p = {0, 1, 2};
        do {
            if (check(a[p[0]], a[p[1]], a[p[2]])) { ok = true; return; }
        } while (next_permutation(p.begin(), p.end()));
        return;
    }
    for (int j = 0; j < 2; ++j) {
        backtrack(i + 1);
        swap(a[i].w, a[i].h);
    }
}

int main() {
    for(int i=0; i<3; ++i) cin >> a[i].w >> a[i].h;
    backtrack(0);
    if (ok) cout << "YES";
    else cout << "NO";
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstring>

using namespace std;

struct Rect { int w, h; };
Rect rects[8]; // Lưu tất cả các trạng thái xoay
int side;
int memo[1 << 3][205][205];

// dp[mask][r][c]: có thể điền vào hàng r, cột c với các hình trong mask hay không?
int dp(int mask, int r, int c) {
    if (mask == (1 << 3) - 1) return r == side && c == side;
    if (r == side && c == side) return 0;
    if (r > side || c > side) return 0;
    if (memo[mask][r][c] != -1) return memo[mask][r][c];

    // Nếu hàng hiện tại đã đầy, chuyển sang hàng mới
    if (c == side) return memo[mask][r][c] = dp(mask, r + 1, 0);

    // Thử đặt từng hình chữ nhật chưa dùng vào vị trí (r, c)
    for (int i = 0; i < 8; ++i) {
        if (!(mask & (1 << (i / 2)))) { // Kiểm tra xem hình gốc đã dùng chưa
            int w = rects[i].w;
            int h = rects[i].h;

            // Đặt hình vuông con tại (r, c)
            // Kiểm tra xem có thể điền vào các ô trong diện tích w x h không
            // (Ở đây ta đơn giản hóa: chỉ kiểm tra điều kiện biên)
            if (r + h <= side && c + w <= side) {
                // Tạo mask mới đánh dấu hình này đã dùng
                int new_mask = mask | (1 << (i / 2));
                // Thử điền tiếp từ vị trí tiếp theo
                if (dp(new_mask, r, c + w)) return memo[mask][r][c] = 1;
            }

            // Thử xoay nếu cần (đã có trong list 8 phần tử rồi, nên không cần xoay ở đây)
        }
    }
    return memo[mask][r][c] = 0;
}

int main() {
    int total_area = 0;
    for (int i = 0; i < 3; ++i) {
        int w, h; cin >> w >> h;
        rects[2 * i] = {w, h};
        rects[2 * i + 1] = {h, w};
        total_area += w * h;
    }
    side = sqrt(total_area);
    if (side * side != total_area) { cout << "NO"; return 0; }

    memset(memo, -1, sizeof(memo));
    if (dp(0, 0, 0)) cout << "YES";
    else cout << "NO";
    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

struct Rect { int w, h; };
Rect rects[3];

bool solve() {
    long long total_area = 0;
    for(int i=0; i<3; ++i) total_area += 1LL * rects[i].w * rects[i].h;
    long long side = sqrt(total_area);
    if (side * side != total_area) return false;

    // Sinh tất cả các hoán vị và xoay
    vector<int> p = {0, 1, 2};
    do {
        for (int m1 = 0; m1 < 2; ++m1) {
            for (int m2 = 0; m2 < 2; ++m2) {
                for (int m3 = 0; m3 < 2; ++m3) {
                    int r0_w = (m1 ? rects[p[0]].h : rects[p[0]].w);
                    int r0_h = (m1 ? rects[p[0]].w : rects[p[0]].h);
                    int r1_w = (m2 ? rects[p[1]].h : rects[p[1]].w);
                    int r1_h = (m2 ? rects[p[1]].w : rects[p[1]].h);
                    int r2_w = (m3 ? rects[p[2]].h : rects[p[2]].w);
                    int r2_h = (m3 ? rects[p[2]].w : rects[p[2]].h);

                    // Case 1: 3 hình xếp thành hàng ngang
                    if (r0_h == side && r1_h == side && r2_h == side && r0_w + r1_w + r2_w == side) return true;
                    // Case 2: 3 hình xếp thành hàng dọc
                    if (r0_w == side && r1_w == side && r2_w == side && r0_h + r1_h + r2_h == side) return true;

                    // Case 3: 2 hình trên, 1 hình dưới
                    if (r0_h + r1_h == side && r0_w == r1_w && r0_w == r2_w && r2_h == side) return true;
                    if (r0_h + r2_h == side && r0_w == r2_w && r0_w == r1_w && r1_h == side) return true;
                    if (r1_h + r2_h == side && r1_w == r2_w && r1_w == r0_w && r0_h == side) return true;

                    // Case 4: 2 hình dọc, 1 hình ngang
                    if (r0_w + r1_w == side && r0_h == r1_h && r0_h + r2_h == side && r2_w == side) return true;
                    if (r0_w + r2_w == side && r0_h == r2_h && r0_h + r1_h == side && r1_w == side) return true;
                    if (r1_w + r2_w == side && r1_h == r2_h && r1_h + r0_h == side && r0_w == side) return true;
                }
            }
        }
    } while (next_permutation(p.begin(), p.end()));
    return false;
}

int main() {
    for(int i=0; i<3; ++i) cin >> rects[i].w >> rects[i].h;
    if (solve()) cout << "YES";
    else cout << "NO";
    return 0;
}