#include <bits/stdc++.h>

using namespace std;

template<ranges::range T, class = enable_if_t<!is_convertible_v<T, string_view>>>
istream& operator>>(istream &s, T &&v) { for (auto &&x : v) s >> x; return s; }
template<ranges::range T, class = enable_if_t<!is_convertible_v<T, string_view>>>
ostream& operator<<(ostream &s, T &&v) { for (auto && x : v) s << x << ' '; return s; }

#ifdef LOCAL
template<class... T> void dbg(T... x) { char e{}; ((cerr << e << x, e = ' '), ...); }
#define debug(x...) dbg(#x, '=', x, '\n')
#else
#define debug(...) ((void)0)
#endif

#define ff first
#define ss second
#define all(v) (v).begin(), (v).end()

template<class T> bool chmin(T &a, T b) { return (b < a) and (a = b, true); }
template<class T> bool chmax(T &a, T b) { return (a < b) and (a = b, true); }
template<class T> inline constexpr T inf = numeric_limits<T>::max() / 2;

using i64 = long long;
using u64 = unsigned long long;

constexpr u64 P = 1e9 + 321;

template<class S>
struct Seg {
    Seg<S> *ls{}, *rs{};
    int l, r;
    S d{};
    Seg(int _l, int _r) : l{_l}, r{_r} {
        if (r - l == 1) {
            return;
        }
        int mid = (l + r) / 2;
        ls = new Seg(l, mid);
        rs = new Seg(mid, r);
        pull();
    }
    void pull() {
        d = ls->d + rs->d;
    }
    S query(int x, int y) {
        if (y <= l or r <= x) return S{};
        if (x <= l and r <= y) return d;
        return ls->query(x, y) + rs->query(x, y);
    }
    void set(int p, const S &g) {
        if (p + 1 <= l or r <= p) return;
        if (r - l == 1) {
            d = g;
            return;
        }
        ls->set(p, g);
        rs->set(p, g);
        pull();
    }
};

const int kN = 1e6 + 5;
u64 pw[kN + 1];

void init() {
    pw[0] = 1;
    for (int i = 1; i <= kN; i++)
        pw[i] = pw[i - 1] * P;
}

struct Info {
    u64 H{};
    int siz{};
    friend Info operator+(const Info &a, const Info &b) {
        return {a.H + b.H * pw[a.siz], a.siz + b.siz};
    }
};

void solve() {
    int K, M, N;
    cin >> K >> M >> N;

    auto cal = [K](const vector<int> &p) -> u64 {
        vector<int> ord(p.size());
        iota(all(ord), 0);
        sort(all(ord), [&](int a, int b) {
                return p[a] < p[b];
            });
        u64 h = 0;
        for (int i = 0; i < K; i++) {
            h += ord[i] * pw[i];
        }
        return h;
    };

    vector P(M, vector<int>(K));
    map<u64, int> pid;
    for (int i = 0; i < M; i++) {
        cin >> P[i];
        debug(cal(P[i]));
        pid[cal(P[i])] = i;
    }
    
    auto seq = [N]() -> vector<int> {
        vector<int> seq(N);
        cin >> seq;
        auto uni = seq;
        sort(all(uni));
        uni.erase(unique(all(uni)), uni.end());
        for (int &x : seq) {
            x = lower_bound(all(uni), x) - uni.begin();
        }
        return seq;
    }();
    debug(seq);

    u64 base = 0;
    for (int i = 0; i < K; i++)
        base += pw[i];
    debug(base);
    debug(2 * pw[1] + pw[2]);
    debug((Info{2, 1} + Info{1, 1} + Info{0, 1}).H);

    Seg<Info> seg(0, N);
    for (int i = 0; i < N; i++) {
        seg.set(seq[i], {i, 1});
        if (i - K >= 0) {
            seg.set(seq[i - K], {0, 0});
        }
        if (i >= K - 1) {
            u64 cur = seg.query(0, N).H - base * (i - K + 1);
            debug(i, cur);
            debug(i, seg.query(0, N).H);
            if (pid.count(cur)) {
                cout << P[pid[cur]] << '\n';
                return;
            }
        }
    }

    cout << 0 << '\n';
    
}

signed main() {
    init();
    cin.tie(0)->sync_with_stdio(false);
    solve();
    return 0;
}