#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <complex>
#include <utility>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <bitset>
#include <ctime>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cassert>
#include <cstddef>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <sstream>
#include <fstream>

#define REP(i,n) for(int (i)=0;(i)<(n);(i)++)
#define FOR(i,a,b) for(int (i)=(a);(i)<(b);(i)++)
#define RREP(i,a) for(int (i)=(a)-1;(i)>=0;(i)--)
#define FORR(i,a,b) for(int (i)=(a)-1;(i)>=(b);(i)--)
#define PI acos(-1.0)
#define DEBUG(C) cout<<C<<endl;
#define VI vector<int>
#define VII vector<VI>
#define VL vector<LL>
#define VLL vector<VL>
#define VD vector<double>
#define VDD vector<VD>
#define PII pair<int,int>
#define PDD pair<double,double>
#define PLL pair<LL,LL>
#define VPII vector<PII>
#define ALL(a) (a).begin(),(a).end()
#define SORT(a) sort(ALL(a))
#define REVERSE(a) reverse(ALL(a))
#define MP make_pair
#define FORE(a,b) for(auto &&a:b)
#define FIND(s,n) s.find(n)!=s.end()

using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF=1e9;
const int MOD=INF+7;

/*** UnionFindクラス ***/
class UnionFind{
private:
    //uni[i]<0ならばiが親，そうでなければfind(uni[i])が親
    vector<int> uni;
    //グループ数
    int size;
public:

    UnionFind(int size){
        //初期状態では全ノード-1に設定し，よってすべてが親
        this->uni=vector<int>(size,-1);
        this->size=size;
    }
    UnionFind(){}

    //xの親を返す
    int find(int x){
        //uni[x]<0なのでxは親
        if(uni[x]<0) return x;
        //uni[x]に親ノードを入れることで連続での探索時間の短縮
        return uni[x]=find(uni[x]);
    }

    //xとyが同じグループならばtrue
    bool same(int x,int y){
        //xとyの親が同じならば同じグループに属するといえる
        return find(x)==find(y);
    }

    //xとyがそれぞれ属するグループを併合
    //併合処理を行ったならばtrueを返す
    //xとyがもともと同じグループならばfalseを返す
    bool unite(int x,int y){
        x=find(x); y=find(y);
        if(x==y) return false;
        //木の深さが小さいノードから大きいノードへ辺をはる
        if(uni[x]>uni[y]) swap(x,y);
        //yのグループをxに足す
        uni[x]+=uni[y];
        //yの親をxとする
        uni[y]=x;
        size--;
        return true;
    }

    //グループ数を返す
    int get_all_size(){
        return size;
    }

    //xが属するグループのノード数を返す
    int get_size(int x){
        return -uni[find(x)];
    }
};

int N,M,Q;
UnionFind uf;
VI ans;
VPII br;
set<PII> nobr;
vector<set<int>> ver;

int main(void){
    cin >> N >> M >> Q;
    uf = UnionFind(N);
    ver = vector<set<int>>(N);
    REP(i,M){
        int a,b;
        scanf("%d %d",&a,&b);
        a--;b--;
        nobr.insert(MP(a,b));
    }
    br = VPII(Q);
    REP(i,Q){
        int a,b;
        scanf("%d %d",&a,&b);
        a--;b--;
        br[i] = MP(a,b);
        nobr.erase(br[i]);
    }
    FORE(el,nobr){
        uf.unite(el.first,el.second);
    }
    ans = VI(N,0);
    REP(i,N) ver[uf.find(i)].insert(i);
    REP(i,N) if(uf.same(0,i)) ans[i] = -1;
    RREP(i,Q){
        int a = uf.find(br[i].first);
        int b = uf.find(br[i].second);
        if(uf.same(a,b)) continue;
        if(uf.same(0,a)){
            FORE(el,ver[b]){
                ans[el] = i+1;
            }
        }
        if(uf.same(0,b)){
            FORE(el,ver[a]){
                ans[el] = i+1;
            }
        }
        bool f = false;
        if(uf.get_size(a)<uf.get_size(b)){
            swap(a,b); f = true;
        }
        ver[a].insert(ALL(ver[b]));
        ver[b].clear();
        uf.unite(a,b);
        //if(f) swap(ver[a],ver[b]);
    }
    FOR(i,1,N) cout << ans[i] << endl;
}