import Control.Monad
import qualified Data.ByteString.Char8 as B
import qualified Data.IntSet as S
import qualified Data.Array.IArray as A

readInt :: B.ByteString -> Int
readInt = maybe undefined fst . B.readInt

main = do
  [n,k,l] <- map read . words <$> getLine
  esq <- readUndirectedEdge <$> replicateM k B.getLine
  esr <- readUndirectedEdge <$> replicateM l B.getLine
  putStrLn $ unwords $ map show (connectivity n esq esr)

connectivity n esq esr = zipWith (\vsq vsr -> S.size (S.intersection vsq vsr)) vsq vsr
  where
    vsq = map (bfs gq) [1..n]
    vsr = map (bfs gr) [1..n]
    gq = buildG (1,n) esq
    gr = buildG (1,n) esr


--type Height = Int
type Width = Int
type Index = Int
type Bound = (Vertex, Vertex)

type Vertex = Int
type Vertexes = S.IntSet
type Edge = (Vertex, Vertex)
type Graph = A.Array Vertex Vertexes

buildG :: Bound -> [Edge] -> Graph
buildG = A.accumArray (flip S.insert) S.empty

from :: Graph -> Vertex -> Vertexes
from = (A.!)

readUndirectedEdge = concatMap (constructTwoWay . map readInt . B.words)

constructTwoWay :: [Int] -> [Edge]
constructTwoWay [s, t] = [(s, t), (t, s)]
constructTwoWay _ = undefined

bfs :: Graph -> Vertex -> Vertexes
bfs g v = go (S.singleton v) (S.singleton v)
  where
    go acc border
      | S.null border = acc
      | otherwise = go (S.union acc next) next
        where
          next = S.difference (transMap g border) acc

reachable :: Graph -> Vertex -> Vertex -> Bool
reachable g v w = S.member w (bfs g v)

transMap :: Graph -> Vertexes -> Vertexes
transMap g = S.unions . map (from g) . S.elems