using System;
using System.Text;
using System.Collections.Generic;
using static System.Math;
using System.Linq;
using static System.Array;

namespace DigitsParades
{

    class Programk
    {
        static void Main(string[] args)
        {
            var NMK = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            var N = NMK[0];
            var M = NMK[1];
            var K = NMK[2];

            var friends = new long[N + 1];
            var UF = new UnionFind(N + 1);
            for (int i = 0; i < M; i++)
            {
                var AB = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
                var A = AB[0];
                var B = AB[1];
                //AとBの友達の数をそれぞれ追加
                friends[A]++;
                friends[B]++;
                UF.Union(A, B);
            }
            var blocks = new long[N + 1];
            for (int i = 1; i <= K; i++)
            {
                var AB = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
                var A = AB[0];
                var B = AB[1];
                if (UF.Same(A, B))
                {
                    blocks[A]++;
                    blocks[B]++;
                }

            }

            var ans = new long[N];
            for (int i = 0; i < N; i++)
            {
                var tmp = UF.Size(i+1) - (1+blocks[i+1] + friends[i+1]);
                ans[i] = Max(0,tmp);
            }
            Console.WriteLine(String.Join(" ",ans));
        }
    }

    #region スキャナー
    class Scanner
    {
        public Scanner()
        {
            _pos = 0;
            _line = new string[0];
        }

        const char Separator = ' ';
        private int _pos;
        private string[] _line;

        #region スペース区切りで取得

        public string Next()
        {
            if (_pos >= _line.Length)
            {
                _line = Console.ReadLine().Split(Separator);
                _pos = 0;
            }

            return _line[_pos++];
        }

        public int NextInt()
        {
            return int.Parse(Next());
        }

        public long NextLong()
        {
            return long.Parse(Next());
        }

        public double NextDouble()
        {
            return double.Parse(Next());
        }

        #endregion

        #region 型変換

        private int[] ToIntArray(string[] array)
        {
            var result = new int[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                result[i] = int.Parse(array[i]);
            }

            return result;
        }

        private long[] ToLongArray(string[] array)
        {
            var result = new long[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                result[i] = long.Parse(array[i]);
            }

            return result;
        }

        private double[] ToDoubleArray(string[] array)
        {
            var result = new double[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                result[i] = double.Parse(array[i]);
            }

            return result;
        }

        #endregion

        #region 配列取得

        public string[] Array()
        {
            if (_pos >= _line.Length)
                _line = Console.ReadLine().Split(Separator);

            _pos = _line.Length;
            return _line;
        }

        public int[] IntArray()
        {
            return ToIntArray(Array());
        }

        public long[] LongArray()
        {
            return ToLongArray(Array());
        }

        public double[] DoubleArray()
        {
            return ToDoubleArray(Array());
        }

        #endregion
    }
    #endregion  

    class UnionFind

    {

        // 親要素のインデックスを保持する

        // 親要素が存在しない(自身がルートである)とき、マイナスでグループの要素数を持つ

        public long[] Parents { get; set; }

        public UnionFind(long n)

        {

            this.Parents = new long[n];

            for (int i = 0; i < n; i++)

            {

                // 初期状態ではそれぞれが別のグループ(ルートは自分自身)

                // ルートなのでマイナスで要素数(1個)を保持する

                this.Parents[i] = -1;

            }

        }



        // 要素xのルート要素はどれか

        public long Find(long x)

        {

            // 親がマイナスの場合は自分自身がルート

            if (this.Parents[x] < 0) return x;

            // ルートが見つかるまで再帰的に探す

            // 見つかったルートにつなぎかえる

            this.Parents[x] = Find(this.Parents[x]);

            return this.Parents[x];

        }



        // 要素xの属するグループの要素数を取得する

        public long Size(long x)

        {

            // ルート要素を取得して、サイズを取得して返す

            return -this.Parents[this.Find(x)];

        }



        // 要素x, yが同じグループかどうか判定する

        public bool Same(long x, long y)

        {

            return this.Find(x) == this.Find(y);

        }



        // 要素x, yが属するグループを同じグループにまとめる

        public bool Union(long x, long y)

        {

            // x, y のルート

            x = this.Find(x);

            y = this.Find(y);

            // すでに同じグループの場合処理しない

            if (x == y) return false;



            // 要素数が少ないグループを多いほうに書き換えたい

            if (this.Size(x) < this.Size(y))

            {

                var tmp = x;

                x = y;

                y = tmp;

            }

            // まとめる先のグループの要素数を更新

            this.Parents[x] += this.Parents[y];

            // まとめられるグループのルートの親を書き換え

            this.Parents[y] = x;

            return true;

        }

    }
}


Measured memory_bytes: 22536