#pragma region macro
#include <bits/stdc++.h>
using i64 = int_fast64_t;
#define repeat(i, a, b) for(int i = (a); (i) < (b); ++(i))
#define rep(i, n) repeat(i, 0, n)

namespace std {
template <typename A, typename B>
string to_string(pair<A, B> p);

string to_string(const string &s) {
    return '"' + s + '"';
}

string to_string(const char *s) {
    return to_string((string)s);
}

string to_string(bool b) {
    return (b ? "true" : "false");
}

string to_string(vector<bool> v) {
    bool first = true;
    string res = "{";
    for(int i = 0; i < static_cast<int>(v.size()); i++) {
        if(!first) {
            res += ", ";
        }
        first = false;
        res += to_string(v[i]);
    }
    res += "}";
    return res;
}

template <size_t N>
string to_string(bitset<N> v) {
    string res = "";
    for(size_t i = 0; i < N; i++) {
        res += static_cast<char>('0' + v[i]);
    }
    return res;
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for(const auto &x : v) {
        if(!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
};  // namespace std
#pragma endregion

/* UnionFind */
template <typename T>
struct UnionFind {
    std::vector<T> data;
    std::stack<std::pair<int, T>> history;

    UnionFind() = default;
    UnionFind(int sz) { data.assign(sz, -1); }

    bool unite(int x, int y) {
        x = root(x), y = root(y);
        history.emplace(x, data[x]);
        history.emplace(y, data[y]);
        if(x == y) return (false);
        if(data[x] > data[y]) std::swap(x, y);
        data[x] += data[y];
        data[y] = x;
        return (true);
    }

    int root(int k) {
        if(data[k] < 0) return (k);
        return (root(data[k]));
    }

    bool same(int x, int y) { return root(x) == root(y); }

    int size(int k) { return (-data[root(k)]); }

    void undo() {
        data[history.top().first] = history.top().second;
        history.pop();
        data[history.top().first] = history.top().second;
        history.pop();
    }

    void snapshot() {
        while(history.size()) history.pop();
    }

    void rollback() {
        while(history.size()) undo();
    }
};

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;
    UnionFind<int> uf(n);
    std::map<int, std::vector<int>> mp;
    rep(i, m) {
        int a, b;
        scanf("%d%d", &a, &b);
        uf.unite(a - 1, b - 1);
        mp[a - 1].emplace_back(b - 1);
        mp[b - 1].emplace_back(a - 1);
    }
    rep(i, k) {
        int c, d;
        scanf("%d%d", &c, &d);
        mp[c - 1].emplace_back(d - 1);
        mp[d - 1].emplace_back(c - 1);
    }
    std::vector<int> ans(n);
    rep(i, n) ans[i] = uf.size(i) - 1;
    rep(i, n) {
        for(auto &&x : mp[i]) {
            if(uf.same(i, x)) {
                ans[i]--;
            }
        }
    }
    rep(i, n) std::cout << ans[i] << " \n"[i == n - 1];
}

int main() {
    // std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    solve();
    return 0;
}

Measured memory_bytes: 15744