using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

internal static class CR
{
    public static string GetText() { return Console.ReadLine(); }
    public static List<string> GetTexts() { return Console.ReadLine().Split(' ').ToList(); }
    public static long GetLong() { return long.Parse(Console.ReadLine()); }
    public static List<long> GetLongs() { return Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToList(); }
}

namespace AtCoder.D
{
    public class Program
    {
        public static long N { get; private set; }
        public static long M { get; private set; }
        public static long K { get; private set; }

        public static void Main() { var r = GetResult(); Debug.WriteLine(r); Console.Write(r); }

        private static object GetResult()
        {
            var inputs = CR.GetLongs();
            N = inputs[0];
            M = inputs[1];
            K = inputs[2];

            var uf = new UnionFind((int)N);
            var result = new int[N];

            for (int i = 0; i < M; i++)
            {
                inputs = CR.GetLongs();
                var a = (int)inputs[0] - 1;
                var b = (int)inputs[1] - 1;

                uf.Union(a, b);
                result[a] -= 1;
                result[b] -= 1;
            }

            for (int i = 0; i < K; i++)
            {
                inputs = CR.GetLongs();
                var c = (int)inputs[0] - 1;
                var d = (int)inputs[1] - 1;

                if (uf.Same(c, d))
                {
                    result[c] -= 1;
                    result[d] -= 1;
                }
            }

            for (int i = 0; i < N; i++)
            {
                result[i] += uf.Size(i) - 1;
            }

            return string.Join(" ", result.Select(x => x));
        }
    }

    class UnionFind
    {
        // 親要素のインデックスを保持する
        // 親要素が存在しない(自身がルートである)とき、マイナスでグループの要素数を持つ
        public int[] Parents { get; set; }
        public UnionFind(int n)
        {
            Parents = new int[n];
            for (int i = 0; i < n; i++)
            {
                // 初期状態ではそれぞれが別のグループ(ルートは自分自身)
                // ルートなのでマイナスで要素数(1個)を保持する
                Parents[i] = -1;
            }
        }

        // 要素xのルート要素はどれか
        public int Find(int x)
        {
            // 親がマイナスの場合は自分自身がルート
            if (Parents[x] < 0) return x;
            // ルートが見つかるまで再帰的に探す
            // 見つかったルートにつなぎかえる
            Parents[x] = Find(Parents[x]);
            return Parents[x];
        }

        // 要素xの属するグループの要素数を取得する
        public int Size(int x)
        {
            // ルート要素を取得して、サイズを取得して返す
            return -Parents[Find(x)];
        }

        // 要素x, yが同じグループかどうか判定する
        public bool Same(int x, int y)
        {
            return Find(x) == Find(y);
        }
        // 要素x, yが属するグループを同じグループにまとめる
        public bool Union(int x, int y)
        {
            // x, y のルート
            x = Find(x);
            y = Find(y);
            // すでに同じグループの場合処理しない
            if (x == y) return false;

            // 要素数が少ないグループを多いほうに書き換えたい
            if (Size(x) < Size(y))
            {
                var tmp = x;
                x = y;
                y = tmp;
            }
            // まとめる先のグループの要素数を更新
            Parents[x] += Parents[y];
            // まとめられるグループのルートの親を書き換え
            Parents[y] = x;
            return true;
        }
    }
}


Measured memory_bytes: 18952