#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define rep(i,s,n) for (int i = (int)(s); i < (int)(n); i++)
#define rrep(i,s,n) for (int i = (int)(n)-1; i >= (int)(s); i--)
#define all(v) begin(v),end(v)
using namespace std;
using ll = long long;
using pll=pair<ll,ll>;
using vl=vector<ll>;
using vvl=vector<vl>;
using vp=vector<pll>;
bool chmin(auto &a, auto b) { return a > b ? a = b, 1 : 0; }
bool chmax(auto &a, auto b) { return a < b ? a = b, 1 : 0; }

using ull = unsigned long long;
const ull mod = (1ULL<<61)-1;

struct mm {
    ull x;
    mm (ull _x = 0) : x(_x) {}
    mm &operator+=(mm a){
        x += a.x;
        if (x >= mod) x -= mod;
        return *this;
    }
    mm &operator-=(mm a){
        x += mod - a.x;
        if (x >= mod) x -= mod;
        return *this;
    }
    mm &operator*=(mm a){
        x = (ull)((__uint128_t)(x) * a.x % mod);
        return *this;
    }
    mm pow(ull n) const {
        mm ret = *this, r = 1;
        while (n != 0){
            if (n & 1) ret *= r;
            r *= r;
            n >>= 1;
        }
        return ret;
    }
    mm &operator/=(mm a){
        return *this *= a.pow(mod-2);
    }
    friend mm operator+(mm a, mm b){
        return a += b;
    }
    friend mm operator-(mm a, mm b){
        return a -= b;
    }
    friend mm operator*(mm a, mm b){
        return a *= b;
    }
    friend mm operator/(mm a, mm b){
        return a /= b;
    }
    friend bool operator<(mm a, mm b){
        return a.x < b.x;
    }
};

template<class S, auto op, auto e, class F, auto mapp, auto comp, auto id> struct lazyseg {
    int n, sz, lg;
    vector<S> d;
    vector<F> lz;
    void upd(int k) { d[k] = op(d[2*k], d[2*k+1]); }
    void all_apply( int k, F f) {
        d[k] = mapp(f, d[k]);
        if (k < sz) lz[k] = comp(f, lz[k]);
    }
    void push(int k) {
        all_apply(2*k, lz[k]);
        all_apply(2*k+1, lz[k]);
        lz[k] = id();
    }
    bool tail(int p, int i) { return ((p>>i)<<i)!=p; }
    lazyseg(int _n = 0) : lazyseg(vector<S>(_n, e())) {}
    lazyseg(vector<S> v): n(v.size()) {
        sz = bit_ceil(uint32_t(n));
        lg = countr_zero(uint32_t(sz));
        d.assign(2*sz, e());
        lz.assign(sz,id());
        rep(i,0,n) d[sz+i] = v[i];
        for(int i=sz-1; i>=1; i--) upd(i);
    }
    S prod(int l, int r){
        if (l ==r ) return e();
        l += sz, r += sz;
        for (int i = lg; i>=1; i--) {
            if (tail(l, i)) push(l >> i);
            if (tail(r, i)) push(r >> i);
        }
        S sml = e(), smr = e();
        while(l < r){
            if (l & 1) sml = op(sml, d[l++]);
            if (r & 1) smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }
        return op(sml ,smr);
    }
    void set(int p, S x) {
        p += sz;
        for (int i=lg; i>=1; i--) push(p >> i);
        d[p] = x;
        for (int i=1; i<=lg; i++) upd(p>>i);
    }
    S get(int p) {
        p += sz;
        for (int i=lg; i>=1; i--) push(p >> i);
        return d[p];
    }
    void apply(int l, int r, F f) {
        if (l == r) return;
        l += sz, r += sz;
        for (int i=lg; i>=1; i--) {
            if (tail(l,i)) push(l >> i);
            if (tail(r,i)) push((r-1)>>i);
        }
        int l2 = l, r2 = r;
        while( l < r) {
            if(l & 1) all_apply(l++, f);
            if(r & 1) all_apply(--r, f);
            l >>= 1; r >>= 1;
        }
        l = l2, r = r2;
        for (int i=1; i<=lg; i++){
            if (tail(l,i)) upd(l >> i);
            if (tail(r,i)) upd((r-1) >> i);
        }
    }

    int max_right(int l, auto g) {
        if (l == n) return n;
        l += sz;
        for (int i=lg; i>=1; i--) push(l >> i);
        S sm = e();
        do {
            while(l % 2 == 0) l >>= 1;
            if (!g(op(sm,d[l]))) {
                while(l < sz) {
                    push(l);
                    l <<= 1;
                    if(g(op(sm,d[l]))) {sm = op(sm,d[l++]);}
                }
                return l - sz;
            }
            sm = op(sm, d[l++]);
        } while ((l&-l)!=l);
        return n;
    }
    int min_left(int r, auto g) {
        if (r == 0) return 0;
        r += sz;
        for (int i=lg; i>=1; i--) push((r-1)>>i);
        S sm = e();
        do {
            r--;
            while(r > 1 && (r %2)) r >>= 1;
            if (!g(op(d[r],sm))){
                while(r<sz){
                    push(r);
                    r=(2*r+1);
                    if (g(op(d[r],sm))){
                        sm=op(d[r--],sm);
                    }
                }
                return r+1-sz;
            }
            sm=op(d[r],sm);
        }while((r&-r)!=r);
        return 0;
    }
};

using mint = mm;
using vm=vector<mint>;
const int L=1;
using T=array<mint,L>;

struct S{
    T a;
    ll s;
};

random_device rnd;
mt19937_64 mt(rnd());
T base,inv;
array<vm,L> pows,sums;

S op(S x, S y){
    rep(i,0,L) x.a[i]+=y.a[i]*pows[i][x.s];
    x.s+=y.s;
    return x;
}
S e(){
    return S{T(),0};
}
S mapping(ll f, S x){
    rep(i,0,L) x.a[i]+=sums[i][x.s]*f;
    return x;
}
ll composition(ll f, ll g){
    return f + g;
}
ll ident(){
    return 0;
}

int input(){
    int x = 0;
    char c;
    while ((c = getchar_unlocked() ^ 48) < 10){
        x = x * 10 + c;
    }
    return x;
}

int main(){
    cin.tie(0)->sync_with_stdio(0);

    
    ll k = input();
    ll m = input();
    ll n = input();

    rep(i,0,L) base[i]=mt()%mod;
    // base[0]=2;
    rep(i,0,L){
        pows[i]=vm(k);
        sums[i]=vm(k+1);
        pows[i][0]=1;
        rep(j,1,k) pows[i][j]=pows[i][j-1]*base[i];
        rep(j,0,k) sums[i][j+1]+=sums[i][j]+pows[i][j];
    }

    vvl ps(m,vl(k));
    vvl qs(m,vl(k));
    map<T,ll> mp;

    rep(i,0,m)rep(j,0,k){
        // cin>>ps[i][j];
        ps[i][j] = input();
    }
    rep(i,0,m)rep(j,0,k) qs[i][ps[i][j]-1]=k-j;
    rep(i,0,m){
        T ar;
        rep(l,0,L){
            mint x=0;
            rrep(j,0,k) x=x*base[l]+qs[i][j];
            ar[l]=x;
        }
        mp[ar]=i;
        // rep(j,0,L) cout<<ar[j].x<<' ';cout<<endl;
    }

    vl a(n);
    rep(i,0,n) a[i] = input();

    {
        map<ll,ll> tp;
        vl b=a;
        sort(all(b));
        rep(i,0,n) tp[b[i]]=i;
        rep(i,0,n) a[i]=tp[a[i]];
    }

    lazyseg<S,op,e,ll,mapping,composition,ident> st(n);
    rep(i,0,n){
        ll x=a[i];
        T ar;
        rep(l,0,L) ar[l]=1;
        st.apply(0,n,1);
        st.set(x,S{ar,1});
        T h=st.prod(0,n).a;
        // rep(j,0,L) cout<<h[j].x<<' ';cout<<endl;
        if(mp.find(h)!=mp.end()){
            vl rs=ps[mp[h]];
            rep(j,0,k) cout<<rs[j]<<" \n"[j==n-1];
            return 0;
        }
        if(i>=k-1){
            ll y=a[i-k+1];
            st.set(y,e());
        }
    }
    cout<<0<<endl;
}