    {-# 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
     
    -- Union-Find
    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
        case compare x r of
            EQ -> return x
            _ -> do
                r' <- root r par
                VUM.write par x r'
                return r'
    
    same :: Int -> Int -> Parent -> IO Bool
    same x y par = do
        x' <- root x par
        y' <- root y par
        return $! x' == y'
    
    unite :: Int -> Int -> Parent -> Size -> IO Bool
    unite x y par siz = do
        x' <- root x par
        y' <- root y par
        sx <- VUM.read siz x'
        sy <- VUM.read siz y'
        case compare x' y' of 
            EQ -> return False
            _ -> do
                case compare sx sy of
                    LT -> do
                        VUM.modify siz (+sx) y'
                        VUM.write par x' y'
                    _ -> do
                        VUM.modify siz (+sy) x'
                        VUM.write par y' x'
                return True
    
    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 ""