{-# LANGUAGE ScopedTypeVariables #-}

import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import Control.Monad
import Control.Monad.Primitive 

-- Union-Find
makeUF :: PrimMonad m => Int -> m ((VUM.MVector (PrimState m) Int), (VUM.MVector (PrimState m) Int))
makeUF n = do
    par <- VU.unsafeThaw $ VU.generate n id
    siz <- VUM.replicate n 1
    return (par, siz)

root :: PrimMonad m => Int -> VUM.MVector (PrimState m) Int -> m Int
root x par = do
    r <- VUM.read par x
    if x == r
        then return x
        else do
            newr <- root r par
            VUM.write par x newr
            return newr

same :: PrimMonad m => Int -> Int -> VUM.MVector (PrimState m) Int -> m Bool
same x y par = do
    rx <- root x par
    ry <- root y par
    return $ rx == ry

unite :: PrimMonad m => Int -> Int -> VUM.MVector (PrimState m) Int -> VUM.MVector (PrimState m) Int -> m ()
unite x y par siz = do
    x' <- root x par
    y' <- root y par
    sx <- VUM.read siz x'
    sy <- VUM.read siz y'
    unless (x' == y') $ 
        if sx < sy
            then do
                VUM.modify siz (+sx) y'
                VUM.write par x' y'
            else do
                VUM.modify siz (+sy) x'
                VUM.write par y' x'

size :: PrimMonad m => Int -> VUM.MVector (PrimState m) Int -> VUM.MVector (PrimState m) Int -> m Int
size x par siz = root x par >>= VUM.read siz
    
main = do
    [n,m,k] <- map read . words <$> getLine :: IO [Int]
    (par, siz) <- makeUF (n+1)
    (cnt :: VUM.IOVector Int) <- VUM.replicate (n+1) 0
    forM_ [1..m] $ \_ -> do
        [a,b] <- map read . words <$> getLine :: IO [Int]
        unite a b par siz
        VUM.modify cnt (+1) a
        VUM.modify cnt (+1) b
    forM_ [1..k] $ \_ -> do
        [c,d] <- map read . words <$> getLine :: IO [Int]
        branch <- same c d par
        when branch $ do
            VUM.modify cnt (+1) c
            VUM.modify cnt (+1) d
        
    forM_ [1..n] $ \i -> do
        s <- size i par siz
        c <- VUM.read cnt i
        putStr $ show (s - c - 1)
        putStr " "
    putStrLn ""