#yukicoder contest 473 第1回 生成AI作問コンテスト

'''
#A
S = input().split()
print(''.join(Si[0].upper() for Si in S))


#B
N = int(input())
names = [input().split() for _ in range(N)]

#この問題AtCoderで見たな･･･？　名前を座標圧縮
S = []
for Si, Ti in names:
    S.append(Si)
    S.append(Ti)
back = None
S = [back := Si for Si in sorted(S) if back != Si]
import bisect
names = [(bisect.bisect_left(S, Si), bisect.bisect_left(S, Ti)) for Si, Ti in names]
n = len(S)

C = [0] * n
for Si, Ti in names:
    C[Si] += 1
    C[Ti] += 1
print('Yes' if all(C[Si] == 1 or C[Ti] == 1 for Si, Ti in names) else 'No')


#C
import bisect
N = int(input())
A = list(map(int, input().split()))
back = None
B = [back := Ai for Ai in sorted(A) if back != Ai]
C = [0] * ( n := len(B) )
for Ai in A:
    C[ bisect.bisect_left(B, Ai) ] += 1
for _ in range( Q := int(input()) ):
    Xi, Ki = map(int, input().split())
    print('Yes' if 0 <= ( i := bisect.bisect_left(B, Xi) ) < n and
          B[i] == Xi and C[i] >= Ki else 'No')


#D
#どうしよっかな SegTree使っていい？
#Segment Tree
class SegmentTree:
    def __init__(self, N, identity_e, node_f):
        self._N, self._size, self._e, self._f = N, 1 << N.bit_length(), identity_e, node_f
        self._node = [self._e for _ in range(self._size << 1)]
    def build(self, A):
        assert len(A) == self._N, 'array too large'
        for i, v in enumerate(A, start = self._size): self._node[i] = v
        for i in range(self._size - 1, 0, -1):
            self._node[i] = self._f( self._node[i << 1], self._node[i << 1 | 1] )
    def update(self, i, v):
        self._node[i := i + self._size] = v
        while (i := i >> 1) != 0:
            self._node[i] = self._f( self._node[i << 1], self._node[i << 1 | 1] )
    def fold(self, Lt, Rt):
        if not 0 <= Lt < Rt <= self._N: return self._e
        Lt, Rt, vL, vR = Lt | self._size, Rt + self._size, self._e, self._e
        while Lt < Rt:
            if Lt & 1: vL = self._f( vL, self._node[Lt] ); Lt += 1
            if Rt & 1: Rt -= 1; vR = self._f( self._node[Rt], vR )
            Lt >>= 1; Rt >>= 1
        return self._f( vL, vR )


ST = SegmentTree( Q := int(input()), 0, max )
Rt = 0
for _ in range(Q):
    Ti, Xi = map(int, input().split())
    match Ti:
        case 1:
            ST.update(Rt, Xi)
            Rt += 1
        case 2:
            Lt = Rt - Xi
            print(ST.fold(Lt, Rt))


#E
#複雑だな  鍵を持っていない状態を0としたいから･･･
#通路を0  鍵を1 ～ 9  扉を11 ～ 19  壁を20  に対応させればいいかな
H, W, M = map(int, input().split())
l = W.bit_length()
B = bytearray(H + 1 << l)
for i in range( len(B) ): B[i] = 20
for h in range(H):
    for w, Shw in enumerate(input().rstrip()):
        i = h << l | w
        if   Shw == '.': B[i] = 0
        elif Shw == '#': B[i] = 20
        elif Shw == 'S': B[i] = 0; st = i
        elif Shw == 'G': B[i] = 0; gl = i
        elif Shw in '123456789': B[i] = int(Shw)
        elif Shw in 'abcdefghi': B[i] = 11 + ord(Shw) - ord('a')
        else: assert False

#DP[i][f]: 現在値がi、鍵がfとなるような最短経路
m = M.bit_length()
DP = [10 ** 9] * (len(B) << m)
DP[st << m | 0] = 0
maskm = ~ ( - 1 << m )
Q, R = [], [st << m | 0]
dist = -1
while R:
    Q, R = R, Q
    dist += 1
    while Q:
        x = Q.pop()
        if DP[x] < dist: continue
        DP[x] = dist
        i, f = x >> m, x & maskm
        for t in -1, 1, 1 << l, -1 << l:
            if B[j := i + t] == 20: continue
            if   B[j] == 0: g = f
            elif  1 <= B[j] <=  9: g = B[j]
            elif 11 <= B[j] <= 19:
                if f != B[j] - 10: continue
                else: g = f
            if DP[j << m | g] > dist + 1:
                DP[j << m | g] = dist + 1
                R.append(j << m | g)
ans = min(DP[gl << m | f] for f in range(M + 1))
print(ans if ans != 10 ** 9 else -1)
'''

#F
#UnionFind
class UnionFind:
    def __init__(self, N: int): self._parent = [-1] * N
    def find(self, Vi: int):
        Pi = Vi  #2個目のwhileは parent[Vi], Vi の順で並列代入すること
        while self._parent[Pi] >= 0: Pi = self._parent[Pi]
        while Pi != Vi: self._parent[Vi], Vi = Pi, self._parent[Vi]
        return Pi
    def unite(self, Ui: int, Vi: int):
        if ( Ui := self.find(Ui) ) == ( Vi := self.find(Vi) ): return False
        if self._parent[Ui] > self._parent[Vi]: Ui, Vi = Vi, Ui
        self._parent[Ui] += self._parent[Vi]; self._parent[Vi] = Ui
        return True
    def same(self, Ui: int, Vi: int): return self.find(Ui) == self.find(Vi)
    def size(self, Vi: int): return - self._parent[ self.find(Vi) ]


#入力受取
N, M = map(int, input().split())
edges = [tuple(map(lambda x: int(x) - 1, input().split())) for _ in range(M)]
Q = int(input())
B = [int(input()) - 1 for _ in range(Q)]

UF = UnionFind(N)
bloken = bytearray(M)
for Bi in B: bloken[Bi] = 1
for i, (Ui, Vi) in enumerate(edges):
    if not bloken[i]: UF.unite(Ui, Vi)
del bloken
cnt = N * (N - 1) >> 1
for i in range(N):
    if i == UF.find(i): cnt -= UF.size(i) * (UF.size(i) - 1) >> 1
ans = [0] * Q
ans[-1] = cnt
for i in range(Q - 1, -1, -1):
    Ui, Vi = edges[Bi := B[i]]
    if not UF.same(Ui, Vi):
        sizeUi, sizeVi = UF.size(Ui), UF.size(Vi)
        cnt -= sizeUi * sizeVi
        UF.unite(Ui, Vi)
    if i:
        ans[i - 1] = cnt
print(*ans, sep = '\n')