#include <iostream>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <iomanip>
#include <set>
#include <ctime>
#include <tuple>
#include <bitset>
#include <assert.h>
#include <deque>
#include <functional>
using namespace std;
typedef long long ll;

#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define debugA cerr << "AAAAA" << endl
#define debug_ cerr << "-------------" << endl
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v)                   \
    cout << #v << endl;                \
    for (int i = 0; i < v.size(); i++) \
    {                                  \
        cout << v[i] << " ";           \
    }                                  \
    cout << endl;
#define debug_vec2(v)                         \
    cout << #v << endl;                       \
    for (int i = 0; i < v.size(); i++)        \
    {                                         \
        for (int j = 0; j < v[i].size(); j++) \
        {                                     \
            cout << v[i][j] << " ";           \
        }                                     \
        cout << endl;                         \
    }

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

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

template <typename T>
void quit(T a)
{
    cout << a << endl;
    exit(0);
}

using Graph = vector<vector<int>>;
using P = pair<int, int>;
using P1 = pair<int, pair<int, int>>; // クラスカル法とかで、{cost, {from, to}}的に使う。
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const double pi = acos(-1);

class UnionFind
{
public:
    // 親の番号を格納する。親だった場合は -(その集合のサイズ)とする。
    vector<int> Parent;

    // 作るときはParentの値を全て-1にする。
    UnionFind(int N)
    {
        Parent = vector<int>(N, -1);
    }

    // Aがどのグループに所属しているか調べる。
    int root(int A)
    {
        if (Parent[A] < 0)
            return A;
        return Parent[A] = root(Parent[A]);
    }

    // 自分のいる頂点の数を調べる。
    int size(int A)
    {
        return -Parent[root(A)]; // 親を取ってきたい。
    }

    // AとBをくっつける。
    bool unite(int A, int B)
    {
        // root(A)をroot(B)にくっつける。
        A = root(A);
        B = root(B);
        if (A == B)
        {
            return false;
        }
        // 大きい方(A)に小さい方(B)をくっつけたい。
        // 大小が逆ならひっくり返す。
        if (size(A) < size(B))
        {
            swap(A, B);
        }

        // Aのサイズを更新する。
        Parent[A] += Parent[B];
        // Bの親をAに変更する。
        Parent[B] = A;
        return true;
    }
};

int main()
{
    int n, m, k;
    cin >> n >> m >> k;
    // Graph tree1(n);
    // Graph tree2(n);
    UnionFind tree(n);
    vector<int> vec(n, 0);
    for (int i = 0; i < m; i++)
    {
        int x, y;
        cin >> x >> y;
        x--;
        y--;
        // tree1[x].push_back(y);
        // tree1[y].push_back(x);
        tree.unite(x, y);
        vec[x]++;
        vec[y]++;
    }
    for (int i = 0; i < k; i++)
    {
        int x, y;
        cin >> x >> y;
        x--;
        y--;
        // tree2[x].push_back(y);
        // tree2[y].push_back(x);
        if (tree.root(x) == tree.root(y))
        {
            vec[x]++;
            vec[y]++;
        }
    }
    for (int i = 0; i < n; i++)
    {
        cout << tree.size(i) - vec[i] - 1 << " ";
    }
    cout << endl;

    return 0;
}


Measured memory_bytes: 4004