//#pragma GCC optimize("Ofast", "unroll-loops")
//#pragma GCC target("sse", "sse2", "sse3", "ssse3", "sse4")

#ifdef __APPLE__

#include <iostream>
#include <cmath>
#include <algorithm>
#include <stdio.h>
#include <cstdint>
#include <cstring>
#include <string>
#include <cstdlib>
#include <vector>
#include <bitset>
#include <map>
#include <queue>
#include <ctime>
#include <stack>
#include <set>
#include <list>
#include <random>
#include <deque>
#include <functional>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <complex>
#include <numeric>
#include <cassert>
#include <array>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <thread>

#else
#include <bits/stdc++.h>
#endif

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

template<typename T>
bool umin(T &a, T b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<typename T>
bool umax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

#if __APPLE__
#define D for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl

template<class ...Ts>
auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }

#else
#define D while (false)
#define LOG(...)
#endif

const int max_n = -1, inf = 1000111222;

//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

struct fedge {
    int v = 0, u = 0;
    ll cap = 0, flow = 0;

    fedge(int _v, int _u, ll _cap) : v(_v), u(_u), cap(_cap) {}
};

struct Dinic {
    const ll finf = 1e18 + 42;
    vector<fedge> edg;
    vector<vector<int> > g;
    int n = 0, m = 0, s = 0, t = 0;
    vector<int> lvl, ptr;
    queue<int> q;

    Dinic(int _n, int _s, int _t) {
        n = _n;
        s = _s;
        t = _t;
        g.resize(n + 1);
        lvl.resize(n + 1);
        ptr.resize(n + 1);
    }

    void add_edge(int v, int u, ll cap) {
        edg.pb(fedge(v, u, cap));
        edg.pb(fedge(u, v, 0));
        g[v].pb(m++);
        g[u].pb(m++);
    }

    char bfs() {
        while (!q.empty()) {
            int v = q.front();
            q.pop();
            for (auto &x: g[v]) {
                if (edg[x].cap - edg[x].flow < 1 || lvl[edg[x].u] != -1) continue;
                lvl[edg[x].u] = lvl[v] + 1;
                q.push(edg[x].u);
            }
        }
        return (lvl[t] != -1);
    }

    ll dfs(int v, ll pushed) {
        if (pushed <= 0) return 0;
        if (v == t) return pushed;
        for (auto &x = ptr[v]; x < g[v].size(); x++) {
            int id = g[v][x];
            int to = edg[id].u;
            if (lvl[v] + 1 != lvl[to] || edg[id].cap - edg[id].flow < 1) continue;
            ll cr = dfs(to, min(pushed, edg[id].cap - edg[id].flow));
            if (!cr) continue;
            edg[id].flow += cr;
            edg[id ^ 1].flow -= cr;
            return cr;
        }
        return 0;
    }

    ll flow() {
        ll res = 0;
        while (true) {
            for (int i = 0; i <= n; i++) {
                lvl[i] = -1;
                ptr[i] = 0;
            }
            lvl[s] = 0;
            q.push(s);
            if (!bfs()) break;
            while (true) {
                ll cr = dfs(s, finf);
                if (!cr) break;
                else res += cr;
            }
        }
        return res;
    }
};

void solve() {
    int p, v;
    cin >> p >> v;
    int sz = p + v + 10000 + 42 + 2;
    int src = sz - 2, snk = sz - 1;
    Dinic dinic(sz, src, snk);
    for(int i = 0; i < p; i++) {
        int a, b;
        cin >> a >> b;
        dinic.add_edge(src, i, 1);
        dinic.add_edge(i, p + v + a, 1);
        dinic.add_edge(i, p + v + b, 1);
    }
    vector<int> C(v);
    for(int i = 0; i < v; i++) {
        int c;
        cin >> c;
        C[i] = c;
        dinic.add_edge(p + v + c, p + i, 1);
        dinic.add_edge(p + i, snk, 1);
    }
    if(dinic.flow() != v) {
        cout << "impossible\n";
    } else {
        vector<vector<int> > av(10000 + 42);
        for(int i = 0; i < dinic.edg.size(); i += 2)
            if(dinic.edg[i].v <= p && dinic.edg[i].flow)
                av[dinic.edg[i].u - (p + v)].pb(dinic.edg[i].v + 1);
        for(int i = 0; i < v; i++) {
            cout << av[C[i]].back() << '\n';
            av[C[i]].pop_back();
        }
        cout << '\n';
    }
}

signed main() {
//   freopen("input.txt", "r", stdin);
//   freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t = 1;

    //cin >> t;

    while (t--) solve();

}

/*
KIVI
*/