{-# LANGUAGE ScopedTypeVariables #-}

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

-- Union-Find
type Parent = VUM.IOVector Int

makeUF :: Int -> IO Parent
makeUF n = do
    par <- VU.unsafeThaw $ VU.generate n id
    return par

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 -> IO ()
unite x y par = do
    x' <- root x par
    y' <- root y par
    when (x' /= y') $ VUM.write par x' y'

main = do
    [n,m,k] <- map read . words <$> getLine :: IO [Int]
    uf <- makeUF (n+1)
    (fre :: VUM.IOVector Int) <- VUM.replicate (n+1) 0
    (blo :: VUM.IOVector Int) <- VUM.replicate (n+1) 0
    (rt:: VUM.IOVector Int) <- VUM.replicate (n+1) 0
    replicateM_ m $ do
        [a,b] <- map read . words <$> getLine :: IO [Int]
        unite a b uf
        VUM.modify fre (+1) a
        VUM.modify fre (+1) b
    replicateM_ k $ do
        [c,d] <- map read . words <$> getLine :: IO [Int]
        branch <- same c d uf
        when branch $ do
            VUM.modify blo (+1) c
            VUM.modify blo (+1) d
    forM_ [1..n] $ \i -> do
        r <- root i uf
        VUM.modify rt (+1) r
    forM_ [1..n] $ \i -> do
        r <- root i uf
        vs <- VUM.read rt r
        f <- VUM.read fre i
        b <- VUM.read blo i
        putStr $ show (vs - f - b - 1)
        putStr " "
    putStrLn ""
