1453_E. Dog Snacks
Gildong is playing with his dog, Badugi. They're at a park that has n intersections and n-1 bidirectional roads, each 1 meter in length and connecting two intersections with each other. The intersections are numbered from 1 to n, and for every a and b (1 ≤ a, b ≤ n), it is possible to get to the b-th intersection from the a-th intersection using some set of roads.

Gildong has put one snack at every intersection of the park. Now Gildong will give Badugi a mission to eat all of the snacks. Badugi starts at the 1-st intersection, and he will move by the following rules:

  * Badugi looks for snacks that are as close to him as possible. Here, the distance is the length of the shortest path from Badugi's current location to the intersection with the snack. However, Badugi's sense of smell is limited to k meters, so he can only find snacks that are less than or equal to k meters away from himself. If he cannot find any such snack, he fails the mission. 
  * Among all the snacks that Badugi can smell from his current location, he chooses a snack that minimizes the distance he needs to travel from his current intersection. If there are multiple such snacks, Badugi will choose one arbitrarily. 
  * He repeats this process until he eats all n snacks. After that, he has to find the 1-st intersection again which also must be less than or equal to k meters away from the last snack he just ate. If he manages to find it, he completes the mission. Otherwise, he fails the mission. 



Unfortunately, Gildong doesn't know the value of k. So, he wants you to find the minimum value of k that makes it possible for Badugi to complete his mission, if Badugi moves optimally.

Input

Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).

The first line of each test case contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of intersections of the park.

The next n-1 lines contain two integers u and v (1 ≤ u,v ≤ n, u ≠ v) each, which means there is a road between intersection u and v. All roads are bidirectional and distinct.

It is guaranteed that: 

  * For each test case, for every a and b (1 ≤ a, b ≤ n), it is possible to get to the b-th intersection from the a-th intersection. 
  * The sum of n in all test cases doesn't exceed 2 ⋅ 10^5. 

Output

For each test case, print one integer — the minimum possible value of k such that Badugi can complete the mission.

Example

Input


3
3
1 2
1 3
4
1 2
2 3
3 4
8
1 2
2 3
3 4
1 5
5 6
6 7
5 8


Output


2
3
3

Note

In the first case, Badugi can complete his mission with k=2 by moving as follows: 

  1. Initially, Badugi is at the 1-st intersection. The closest snack is obviously at the 1-st intersection, so he just eats it. 
  2. Next, he looks for the closest snack, which can be either the one at the 2-nd or the one at the 3-rd intersection. Assume that he chooses the 2-nd intersection. He moves to the 2-nd intersection, which is 1 meter away, and eats the snack. 
  3. Now the only remaining snack is on the 3-rd intersection, and he needs to move along 2 paths to get to it. 
  4. After eating the snack at the 3-rd intersection, he needs to find the 1-st intersection again, which is only 1 meter away. As he gets back to it, he completes the mission. 



In the second case, the only possible sequence of moves he can make is 1 – 2 – 3 – 4 – 1. Since the distance between the 4-th intersection and the 1-st intersection is 3, k needs to be at least 3 for Badugi to complete his mission.

In the third case, Badugi can make his moves as follows: 1 – 5 – 6 – 7 – 8 – 2 – 3 – 4 – 1. It can be shown that this is the only possible sequence of moves for Badugi to complete his mission with k=3.

<image>
```python
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
 
# ------------------------------

def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
    print(' '.join(map(str,l)))
    
# sys.setrecursionlimit(100000)
# import random
# from functools import reduce
# from functools import lru_cache
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow,gcd,log
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc 

for _ in range(N()):
    n = N()
    dic = [[] for _ in range(n + 1)]
    gress = [0] * (n + 1)
    gress[1] += 1
    father = [0] * (n + 1)
    for _ in range(n - 1):
        u, v = RL()
        dic[u].append(v)
        dic[v].append(u)
    now = [1]
    s = [[] for _ in range(n + 1)]
    leaf = []
    while now:
        node = now.pop()
        for child in dic[node]:
            if child != father[node]:
                gress[node] += 1
                father[child] = node
                now.append(child)
        if gress[node] == 0:
            leaf.append(node)
    while leaf:
        node = leaf.pop()
        f = father[node]
        if not s[node]:
            s[f].append((1, 0))
        elif len(s[node]) == 1:
            d, k = s[node][0]
            s[f].append((d + 1, k))
        else:
            d = min(p[0] for p in s[node]) + 1
            k = max(max(p[1] for p in s[node]), max(p[0] for p in s[node]) + 1)
            s[f].append((d, k))
        gress[f] -= 1
        if gress[f] == 0:
            leaf.append(f)
    node = 1
    if len(s[node]) == 1:
        print(max(s[node][0]))
    else:
        k = max(p[1] for p in s[node])
        tmp = [p[0] for p in s[node]]
        m = max(tmp)
        tmp.remove(m)
        print(max(max(tmp)+1, m, k))

    # print(s)
```