There are $n$ persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.

We want to plan a trip for every evening of $m$ days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:   Either this person does not go on the trip,  Or at least $k$ of his friends also go on the trip. 

Note that the friendship is not transitive. That is, if $a$ and $b$ are friends and $b$ and $c$ are friends, it does not necessarily imply that $a$ and $c$ are friends.

For each day, find the maximum number of people that can go on the trip on that day.


-----Input-----

The first line contains three integers $n$, $m$, and $k$ ($2 \leq n \leq 2 \cdot 10^5, 1 \leq m \leq 2 \cdot 10^5$, $1 \le k < n$) — the number of people, the number of days and the number of friends each person on the trip should have in the group.

The $i$-th ($1 \leq i \leq m$) of the next $m$ lines contains two integers $x$ and $y$ ($1\leq x, y\leq n$, $x\ne y$), meaning that persons $x$ and $y$ become friends on the morning of day $i$. It is guaranteed that $x$ and $y$ were not friends before.


-----Output-----

Print exactly $m$ lines, where the $i$-th of them ($1\leq i\leq m$) contains the maximum number of people that can go on the trip on the evening of the day $i$.


-----Examples-----
Input
4 4 2
2 3
1 2
1 3
1 4

Output
0
0
3
3

Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2

Output
0
0
0
3
3
4
4
5

Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3

Output
0
0
0
0
3
4
4



-----Note-----

In the first example,   $1,2,3$ can go on day $3$ and $4$. 

In the second example,   $2,4,5$ can go on day $4$ and $5$.  $1,2,4,5$ can go on day $6$ and $7$.  $1,2,3,4,5$ can go on day $8$. 

In the third example,   $1,2,5$ can go on day $5$.  $1,2,3,5$ can go on day $6$ and $7$.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "from collections import deque\n\ndef solve(adj, m, k, uv):\n    n = len(adj)\n    nn = [len(a) for a in adj]\n    q = deque()\n    for i in range(n):\n        if nn[i] < k:\n            q.append(i)\n    while q:\n        v = q.popleft()\n        for u in adj[v]:\n            nn[u] -= 1\n            if nn[u] == k-1:\n                q.append(u)\n    res = [0]*m\n    nk = len([1 for i in nn if i >= k])\n    res[-1] = nk\n    for i in range(m-1, 0, -1):\n        u1, v1 = uv[i]\n\n        if nn[u1] < k or nn[v1] < k:\n            res[i - 1] = nk\n            continue\n        if nn[u1] == k:\n            q.append(u1)\n            nn[u1] -= 1\n        if not q and nn[v1] == k:\n            q.append(v1)\n            nn[v1] -= 1\n\n        if not q:\n            nn[u1] -= 1\n            nn[v1] -= 1\n            adj[u1].remove(v1)\n            adj[v1].remove(u1)\n\n        while q:\n            v = q.popleft()\n            nk -= 1\n            for u in adj[v]:\n                nn[u] -= 1\n                if nn[u] == k - 1:\n                    q.append(u)\n        res[i - 1] = nk\n    return res\n\nn, m, k = map(int, input().split())\na = [set() for i in range(n)]\nuv = []\nfor i in range(m):\n    u, v = map(int, input().split())\n    a[u - 1].add(v - 1)\n    a[v - 1].add(u - 1)\n    uv.append((u-1, v-1))\n\nres = solve(a, m, k, uv)\nprint(str(res)[1:-1].replace(' ', '').replace(',', '\\n'))"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 14021