Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#############
# Main Code #
#############

N,M,K = inputIL()

friend = [[] for _ in range(N)]
friend_edges = []
for _ in range(M):
  a, b = inputIL()
  friend_edges.append((a-1, b-1))
for a, b in friend_edges:
  friend[a].append(b)
  friend[b].append(a)
  
block = [[] for _ in range(N)]
block_edges = []
for _ in range(K):
  a, b = inputIL()
  block_edges.append((a-1, b-1))
for a, b in block_edges:
  block[a].append(b)
  block[b].append(a)

  
cluster = [None for i in range(N)]
count = []

Q = list(range(N))
n = -1
while Q:
  n += 1
  q = deque([Q.pop()])
  memo = [q[0]]
  cluster[q[0]] = n
  c = 1
  while q:
    i = q.popleft()
    for j in friend[i]:
      if cluster[j] == None:
        cluster[j] = n
        c += 1
        q.append(j)
        memo.append(j)
  count.append(c)
  Q = list(set(Q)-set(memo))

ans = [count[cluster[i]]-1 for i in range(N)]

for a, b in friend_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1

for a, b in block_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1
  

print(*ans,sep=" ")

Fixed submission:
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#############
# Main Code #
#############

N,M,K = inputIL()

friend = [[] for _ in range(N)]
friend_edges = []
for _ in range(M):
  a, b = inputIL()
  friend_edges.append((a-1, b-1))
for a, b in friend_edges:
  friend[a].append(b)
  friend[b].append(a)
  
block = [[] for _ in range(N)]
block_edges = []
for _ in range(K):
  a, b = inputIL()
  block_edges.append((a-1, b-1))
for a, b in block_edges:
  block[a].append(b)
  block[b].append(a)

  
cluster = [None for i in range(N)]
count = []

n = -1
for v in range(N):
  if cluster[v] == None:
    n += 1
    q = deque([v])
    cluster[v] = n
    c = 1
    while q:
      i = q.popleft()
      for j in friend[i]:
        if cluster[j] == None:
          cluster[j] = n
          c += 1
          q.append(j)
    count.append(c)

ans = [count[cluster[i]]-1 for i in range(N)]

for a, b in friend_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1

for a, b in block_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1
  

print(*ans,sep=" ")

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#############
# Main Code #
#############

N,M,K = inputIL()

friend = [[] for _ in range(N)]
friend_edges = []
for _ in range(M):
  a, b = inputIL()
  friend_edges.append((a-1, b-1))
for a, b in friend_edges:
  friend[a].append(b)
  friend[b].append(a)
  
block = [[] for _ in range(N)]
block_edges = []
for _ in range(K):
  a, b = inputIL()
  block_edges.append((a-1, b-1))
for a, b in block_edges:
  block[a].append(b)
  block[b].append(a)

  
cluster = [None for i in range(N)]
count = []

Q = list(range(N))
n = -1
while Q:
  n += 1
  q = deque([Q.pop()])
  cluster[q[0]] = n
  c = 1
  while q:
    i = q.popleft()
    for j in friend[i]:
      if cluster[j] == None:
        cluster[j] = n
        c += 1
        Q.remove(j)
        q.append(j)
  count.append(c)

ans = [count[cluster[i]]-1 for i in range(N)]

for a, b in friend_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1

for a, b in block_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1
  

print(*ans,sep=" ")

Fixed submission:
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#############
# Main Code #
#############

N,M,K = inputIL()

friend = [[] for _ in range(N)]
friend_edges = []
for _ in range(M):
  a, b = inputIL()
  friend_edges.append((a-1, b-1))
for a, b in friend_edges:
  friend[a].append(b)
  friend[b].append(a)
  
block = [[] for _ in range(N)]
block_edges = []
for _ in range(K):
  a, b = inputIL()
  block_edges.append((a-1, b-1))
for a, b in block_edges:
  block[a].append(b)
  block[b].append(a)

  
cluster = [None for i in range(N)]
count = []

n = -1
for v in range(N):
  if cluster[v] == None:
    n += 1
    q = deque([v])
    cluster[v] = n
    c = 1
    while q:
      i = q.popleft()
      for j in friend[i]:
        if cluster[j] == None:
          cluster[j] = n
          c += 1
          q.append(j)
    count.append(c)

ans = [count[cluster[i]]-1 for i in range(N)]

for a, b in friend_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1

for a, b in block_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1
  

print(*ans,sep=" ")

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#############
# Main Code #
#############

N,M,K = inputIL()

friend = [[] for _ in range(N)]
for _ in range(M):
  a,b = inputIL()
  friend[a-1].append(b-1)
  friend[b-1].append(a-1)
  
block = [[] for _ in range(N)]
for _ in range(K):
  a,b = inputIL()
  block[a-1].append(b-1)
  block[b-1].append(a-1)

  
cluster = [None for i in range(N)]
count = []

Q = list(range(N))
n = -1
while Q:
  n += 1
  q = deque([Q.pop()])
  cluster[q[0]] = n
  c = 1
  while q:
    i = q.popleft()
    for j in friend[i]:
      if cluster[j] == None:
        cluster[j] = n
        c += 1
        Q.remove(j)
        q.append(j)
  count.append(c)

ans = []

for i in range(N):
  a = count[cluster[i]]
  for j in friend[i]:
    if cluster[i]==cluster[j]:
      a -= 1
  for j in block[i]:
    if cluster[i]==cluster[j]:
      a -= 1
  ans.append(str(a-1))

print(" ".join(ans))

Fixed submission:
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache


#############
# Constants #
#############

MOD = 10**9+7
INF = float('inf')

#############
# Functions #
#############

######INPUT######
def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]

#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)

######Combination######
kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret

######Factorization######
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr

#####LCM#####
def lcm(a, b):
    return a * b // gcd (a, b)

#############
# Main Code #
#############

N,M,K = inputIL()

friend = [[] for _ in range(N)]
friend_edges = []
for _ in range(M):
  a, b = inputIL()
  friend_edges.append((a-1, b-1))
for a, b in friend_edges:
  friend[a].append(b)
  friend[b].append(a)
  
block = [[] for _ in range(N)]
block_edges = []
for _ in range(K):
  a, b = inputIL()
  block_edges.append((a-1, b-1))
for a, b in block_edges:
  block[a].append(b)
  block[b].append(a)

  
cluster = [None for i in range(N)]
count = []

n = -1
for v in range(N):
  if cluster[v] == None:
    n += 1
    q = deque([v])
    cluster[v] = n
    c = 1
    while q:
      i = q.popleft()
      for j in friend[i]:
        if cluster[j] == None:
          cluster[j] = n
          c += 1
          q.append(j)
    count.append(c)

ans = [count[cluster[i]]-1 for i in range(N)]

for a, b in friend_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1

for a, b in block_edges:
  if cluster[a]==cluster[b]:
    ans[a] -= 1
    ans[b] -= 1
  

print(*ans,sep=" ")