#include <bits/stdc++.h>
using namespace std;

#ifdef DEBUG
ifstream in_file("minta/be1.txt");
#define input in_file
#define INTHENAMEOFGOD
#else
#define input cin
#define INTHENAMEOFGOD \
    ios::sync_with_stdio(0); \
    cin.tie(0); \
    cout.tie(0);
#endif
typedef long long ll;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef pair<ll, ll> pii;
typedef array<ll, 3> pt;

ll N, x;
vector<pt> ps, points, sp;
set<pt> layer;
map<pt, bool> m;
set<int> ax;

void dfs(pt x) {
    m[x] = true;
    for (int axis : ax) {
        pt next = x;
        next[axis]++;
        if (layer.count(next) && !m[next]) {
            dfs(next);
        }
        next[axis] -= 2;
        if (layer.count(next) && !m[next]) {
            dfs(next);
        }
    }
}

void validate_layer(int i) {
    ax = {0, 1, 2};
    ax.erase(i);
    m.clear();
    dfs(*layer.begin());
    for (pt p : layer) {
        if (!m[p]) {
            cout << "NO\n";
            exit(0);
        }
    }

    sp.clear();
    for (pt p : layer) {
        sp.push_back(p);
    }

    int a = *ax.begin();
    int b = *++ax.begin();
    for (int i = 0; i < 2; i++) {
        sort(sp.begin(), sp.end(), [&](pt l, pt r) {
            if (l[a] == r[a])
                return l[b] < r[b];
            return l[a] < r[a];
        });

        ll row = -1;
        pt last;
        for (pt p : sp) {
            if (p[a] != row)
                row = p[a];
            else if (p[b] != last[b]+1) {
                cout << "NO\n";
                exit(0);
            }
            last = p;
        }

        swap(a, b);
    }
}

void dfs3d(pt x) {
    m[x] = true;
    for (int axis : ax) {
        pt next = x;
        next[axis]++;
        if (layer.count(next) && !m[next])
            dfs3d(next);
        next[axis] -= 2;
        if (layer.count(next) && !m[next])
            dfs3d(next);
    }
}

int main() {
    INTHENAMEOFGOD
    input >> N;
    points.resize(N);
    ps.resize(N);
    for (ll n = 0; n < N; n++)
        input >> points[n][0];
    for (ll n = 0; n < N; n++)
        input >> points[n][1];
    for (ll n = 0; n < N; n++)
        input >> points[n][2];

    for (pt p : points)
        layer.insert(p);
    ax = {0, 1, 2};
    dfs3d(points[0]);
    for (pt p : points) {
        if (!m[p]) {
            cout << "NO\n";
            exit(0);
        }
    }
    layer.clear();

    copy_n(points.begin(), N, ps.begin());
    for (int axis = 0; axis < 3; axis++) {
        sort(ps.begin(), ps.end(), [&](pt a, pt b) {
            return a[axis] < b[axis];
        });
        ll layer_ind = ps[0][axis];
        layer.clear();
        for (pt p : ps) {
            if (p[axis] != layer_ind) {
                validate_layer(axis);
                layer_ind = p[axis];
                layer.clear();
            }
            layer.insert(p);
        }
        validate_layer(axis);
    }
    cout << "YES\n";
}