{-# LANGUAGE ScopedTypeVariables #-}

import qualified Data.ByteString.Char8 as B
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import Data.Char
import Control.Monad
import Control.Monad.Primitive 

type Parent = VUM.IOVector Int
type Size = VUM.IOVector Int
 
makeUF :: Int -> IO (Parent, Size)
makeUF n = do
    par <- VU.unsafeThaw $ VU.generate n id
    siz <- VUM.replicate n 1
    return (par, siz)
 
root :: Int -> Parent -> IO 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 :: Int -> Int -> Parent -> IO Bool
same x y par = do
    rx <- root x par
    ry <- root y par
    return $ rx == ry
 
unite :: Int -> Int -> Parent -> Size -> IO ()
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 :: Int -> Parent -> Size -> IO Int
size x par siz = root x par >>= VUM.read siz

toTuple :: B.ByteString -> (Int, Int)
toTuple bs =
    let
        Just (a, bs') = B.readInt bs
        Just (b, _) = B.readInt $ B.dropWhile isSpace bs'
    in
        (a, b)
    
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
    replicateM_ m $ do
        (a,b) <- toTuple <$> B.getLine 
        unite a b par siz
        VUM.modify cnt (+1) a
        VUM.modify cnt (+1) b

    replicateM_ k $ do
        (c,d) <- toTuple <$> B.getLine 
        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 ""