#include <iostream>
#include <set>
#include <vector>
#include <tuple>
#include <sstream>
#include <iterator>

using namespace std;

int main() {
    int N;
    cin >> N; // Read the number of points
    cin.ignore(); // Ignore the newline after reading N

    // Vectors to store the coordinates
    vector<int> X(N), Y(N), Z(N);

    // Read the X coordinates
    for (int i = 0; i < N; ++i) {
        cin >> X[i];
    }
    cin.ignore(); // Ignore the newline after reading X

    // Read the Y coordinates
    for (int i = 0; i < N; ++i) {
        cin >> Y[i];
    }
    cin.ignore(); // Ignore the newline after reading Y

    // Read the Z coordinates
    for (int i = 0; i < N; ++i) {
        cin >> Z[i];
    }

    // Set to hold unique positions
    set<tuple<int, int, int>> poses;
    
    // Populate the set with the tuples
    for (int i = 0; i < N; ++i) {
        poses.insert(make_tuple(X[i], Y[i], Z[i]));
    }

    // Check the movement between positions
    for (auto from_pos = poses.begin(); from_pos != poses.end(); ++from_pos) {
        for (auto to_pos = next(from_pos); to_pos != poses.end(); ++to_pos) {
            vector<int> ghost_pos = {get<0>(*from_pos), get<1>(*from_pos), get<2>(*from_pos)};

            vector<int> dirs = {
                (get<0>(*to_pos) > ghost_pos[0]) - (get<0>(*to_pos) < ghost_pos[0]),
                (get<1>(*to_pos) > ghost_pos[1]) - (get<1>(*to_pos) < ghost_pos[1]),
                (get<2>(*to_pos) > ghost_pos[2]) - (get<2>(*to_pos) < ghost_pos[2])
            };

            // Continue moving the ghost until it reaches the destination
            while (ghost_pos != vector<int>{get<0>(*to_pos), get<1>(*to_pos), get<2>(*to_pos)}) {
                bool moved = false;
                for (int axis = 0; axis < 3; ++axis) {
                    // Use get with a constant index
                    if (ghost_pos[axis] != (axis == 0 ? get<0>(*to_pos) : (axis == 1 ? get<1>(*to_pos) : get<2>(*to_pos)))) {
                        vector<int> next_pos = ghost_pos;
                        next_pos[axis] += dirs[axis];
                        if (poses.count(make_tuple(next_pos[0], next_pos[1], next_pos[2]))) {
                            ghost_pos[axis] += dirs[axis];
                            moved = true;
                            break;
                        }
                    }
                }
                if (!moved) {
                    cout << "NO" << endl;
                    return 0; // Exit on failure
                }
            }
        }
    }

    cout << "YES" << endl;
    return 0;
}