//
//  second.cpp
//  CoderTest
//
//  Created by yuya on 2019/07/25.
//  Copyright © 2019 yuya. All rights reserved.
//

#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
#define all(x) (x).begin(), (x).end()
#define rep(i,n) for(int (i) = 0; (i) < (int)(n); i++)
#define rep1(i,n) for(int (i) = 1; (i) <= (int)(n); i++)
#define INF 1000000

class UF{       // UnionFind
public:
    int n;      // the number of nodes
    vector<int> par;        // the parents of nodes. (the body of UnionFindTree)
    
    UF(){
        n = 1;
        par.assign(n, -1);      // parents of root nodes are negative
    }
    
    UF(int N){
        n = N;
        par.assign(n, -1);      // parents of root nodes are negative
    }
    
    // find the root of x
    int root(int x) {
        if (par[x] < 0) {
            return x;
        } else {
            return par[x] = root(par[x]);
        }
    }
    
    // merge set of x and set of y
    bool merge(int x, int y) {
        x = root(x);
        y = root(y);
        if (x == y)
            return false;
        if (par[x] > par[y])
            swap(x, y);
        par[x] += par[y];
        par[y] = x;
        return true;
    }
    
    // x and y belong the same set or not
    bool same(int x, int y) {
        return root(x) == root(y);
    }
    
    // size of set of x
    int size(int x)
    {
        return -par[root(x)];
    }
};


int nC2(int n);
int coloring(vector<int> &nodes, vector<vector<int>> G, int N);
void dfs(vector<int> &nodes, vector<vector<int>> G, int N, int color, int start);

int main()
{
    int N, M, K;
    cin >> N >> M >> K;
    
    UF G(N+1); // friends graph
    
    vector<int> minus(N+1);
    
    // relationships of friends
    int a,b;
    rep(i, M){
        cin >> a >> b;
        G.merge(a, b);
        // minus for direct relationship
        minus[a]++;
        minus[b]++;
    }
    
    // relationships of block
    int c,d;
    rep(i, K){
        cin >> c >> d;
        // minus for block
        if (G.same(c, d)) {
            minus[c]++;
            minus[d]++;
        }
    }
    
    int x;
    rep1(i, N){
        x = G.root(i);
        cout << G.size(x) -  minus[i] - 1 << " " ;
    }
    cout << endl;
    
    
    
    
    
//
//    vector<vector<int>> G(N+1);
//    /*
//    for (int i=0; i<=N; i++) {
//        G[i].assign(N+1, 0);
//    }
//    */
//
//    // Graph...  Friend : 1  ,  Block : -1
//
//    vector<int> minus(N+1);         // num of direct or block
//
//    int A,B;
//    vector<P> friends(M);
//    for (int i=0; i<M; i++) {
//        cin >> A >> B;
//        //G[A][B] = 1;
//        //G[B][A] = 1;
//        G[A].push_back(B);
//        G[B].push_back(A);
//        friends[i] = P(A,B);
//
//        // minus because of direct
//        minus[A]++;
//        minus[B]++;
//    }
//
//    int C,D;
//    vector<P> block(K);
//    for (int i=0; i<K; i++) {
//        cin >> C >> D;
//        //G[C][D] = -1;
//        //G[D][C] = -1;
//        block[i] = P(C,D);
//    }
//
//    vector<int> nodes(N+1);
//
//    int colors = coloring(nodes, G, N);
//
//
//
//    //////////////////////////
//    /*
//    for (int i=1; i<=N; i++) {
//        cout << nodes[i];
//    }
//    cout << endl << colors << endl;
//    */
//    //////////////////////
//
//
//
//
//    vector<int> members(colors+1);
//    for (int i=1; i <= N; i++) {
//        members[nodes[i]]++;
//    }
//
//
//
//
//    ////////////////////////
//    /*
//    for (int i=1; i <= colors; i++) {
//        cout << i << " " << members[i] << endl;
//    }
//     */
//    ////////////////////////
//
//
//    // minus because of block
//    for (int i=0; i<K; i++) {
//        C = block[i].first;
//        D = block[i].second;
//        if(nodes[C] == nodes[D]) {
//            minus[C]++;
//            minus[D]++;
//        }
//    }
//
//
//
//
//    for (int i=1; i <= N; i++) {
//        cout << members[nodes[i]] - minus[i] - 1 << " ";
//    }
//
//    cout << endl;
//
//
    
    return 0;
}

int nC2(int n)
{
    if(n <= 1) return 0;
    else return n*(n-1)/2;
}


int coloring(vector<int> &nodes, vector<vector<int>> G, int N){
    int color = 0;
    for (int i=1; i <= N; i++) {
        if(nodes[i] == 0){
            color++;
            nodes[i] = color;
            dfs(nodes, G, N, color, i);
        }
    }
    return color;
}

void dfs(vector<int> &nodes, vector<vector<int>> G, int N, int color, int start){
    //for (int i=1; i<=N; i++) {
    for (int i=0; i < G[start].size(); i++) {
        //if (G[start][i] == 1 && nodes[i] == 0) {
        int to = G[start][i];
        if (nodes[to] == 0) {
            nodes[to] = color;
            dfs(nodes, G, N, color, to);
        }
    }
}


Measured memory_bytes: 1664