Problem: You are given a complete directed graph K_n with n vertices: each pair of vertices u ≠ v in K_n have both directed edges (u, v) and (v, u); there are no self-loops.

You should find such a cycle in K_n that visits every directed edge exactly once (allowing for revisiting vertices).

We can write such cycle as a list of n(n - 1) + 1 vertices v_1, v_2, v_3, ..., v_{n(n - 1) - 1}, v_{n(n - 1)}, v_{n(n - 1) + 1} = v_1 — a visiting order, where each (v_i, v_{i + 1}) occurs exactly once.

Find the lexicographically smallest such cycle. It's not hard to prove that the cycle always exists.

Since the answer can be too large print its [l, r] segment, in other words, v_l, v_{l + 1}, ..., v_r.

Input

The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.

Next T lines contain test cases — one per line. The first and only line of each test case contains three integers n, l and r (2 ≤ n ≤ 10^5, 1 ≤ l ≤ r ≤ n(n - 1) + 1, r - l + 1 ≤ 10^5) — the number of vertices in K_n, and segment of the cycle to print.

It's guaranteed that the total sum of n doesn't exceed 10^5 and the total sum of r - l + 1 doesn't exceed 10^5.

Output

For each test case print the segment v_l, v_{l + 1}, ..., v_r of the lexicographically smallest cycle that visits every edge exactly once.

Example

Input


3
2 1 3
3 3 6
99995 9998900031 9998900031


Output


1 2 1 
1 3 2 3 
1 

Note

In the second test case, the lexicographically minimum cycle looks like: 1, 2, 1, 3, 2, 3, 1.

In the third test case, it's quite obvious that the cycle should start and end in vertex 1.

Solution (in PYTHON3):

Solution:
import sys
import math
input = sys.stdin.readline
from functools import cmp_to_key;

def pi():
    return(int(input()))
def pl():
    return(int(input(), 16))
def ti():
    return(list(map(int,input().split())))
def ts():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(map(int,input().split()))
mod = 1000000007;
f = [];
def fact(n,m):
    global f;
    f = [1 for i in range(n+1)];
    f[0] = 1;
    for i in range(1,n+1):
        f[i] = (f[i-1]*i)%m;

def fast_mod_exp(a,b,m):
    res = 1;
    while b > 0:
        if b & 1:
            res = (res*a)%m;
        a = (a*a)%m;
        b = b >> 1;
    return res;

def inverseMod(n,m):
    return fast_mod_exp(n,m-2,m);

def ncr(n,r,m):
    if r == 0: return 1;
    return ((f[n]*inverseMod(f[n-r],m))%m*inverseMod(f[r],m))%m;

def main():
    D();

def xdfs(root, v, sub, parent):
    st = [root];
    while len(st) > 0:
        node = st.pop();
        for i in range(len(v[node])):
            if v[node][i] != node:
                st.append(v[node][i]);


def X():
    try:
        t = pi();
        while t:
            t -= 1;
            n = pi();
            v = [[] for i in range(n)];
            for i in range(n-1):
                [x,y] = ti();
                v[x-1].append(y-1);
                v[y-1].append(x-1);
            m = pi();
            p = ti();
            e = [0 for i in range(n-1)];
            sub = [0 for i in range(n)];
            dfs(0,v,sub,-1)
            for i in range(1,n):
                e[i-1] = (sub[i]*(n-sub[i]));
            if len(p) < n-1:
                while len(p) < n-1:
                    p.append(1);
            p = sorted(p);    
            if len(p) > n-1:
                x = 1;
                for i in range(n-2,len(p)):
                    x = (x*p[i]);
                while len(p) > n-2:
                    p.pop();
                p.append(x);

            e = sorted(e);
            res = 0;
            for i in range(n-1):
                res = (res+(p[i]*e[i]))%mod;
            print(res);
    except:
        print(sys.exc_info());

def bfs(v,root):
    q = [root,None];
    l = 0;
    visited = [0 for i in range(len(v))];
    dist = [0 for i in range(len(v))];
    while len(q) > 0:
        node = q.pop(0);
        if node is not None:
            visited[node] = 1;
            dist[node] = l;
            for i in range(len(v[node])):
                if visited[v[node][i]] == 0:
                    visited[v[node][i]] = 1;
                    q.append(v[node][i]);
        else:
            l += 1;
            if len(q) != 0:
                q.append(None);
    return dist;


def B():
    n = pi();
    v = [[] for i in range(n)];
    for i in range(n-1):
        [x,y] = ti();
        v[x-1].append(y-1);
        v[y-1].append(x-1);
    leafs = [];
    for i in range(n):
        if len(v[i]) == 1:
            leafs.append(i);

    mn = 1;
    d = bfs(v,leafs[0]);
    for i in range(1,len(leafs)):
        if d[leafs[i]] % 2 != 0:
            mn = 3;
            break;
    count = 0;
    for i in range(n):
        f = 0;
        for j in range(len(v[i])):
            if len(v[v[i][j]]) == 1:
                f = 1;
                break;
        if f: count += 1;
    mx = n-1-len(leafs)+count;
    print(mn,mx)


def D():
    t = pi();
    while t:
        t -= 1;
        [n,l,r] = ti();
        p = 0;
        i = 1;
        nxt = 0;
        res = [];
        st = 0;
        while i <= n and p <= l:
            if p+2*(n-i) >= l:
                d = l-p-1;
                if d%2 == 0:
                    st = i;
                    nxt = i+1+(d/2);
                if d%2 != 0:
                    st = i+1+((d-1)/2);
                p = l;
                break;
            p += 2*(n-i);
            i += 1;
        
        while i <= n and p <= r:
            if nxt != 0:
                while p <= r and nxt <= n:
                    if p <= r:
                        res.append(i);
                        p += 1;
                    if p <= r:
                        res.append(int(nxt));
                        p += 1;
                    nxt += 1;
                i += 1;
                nxt = i+1;
            else:
                nxt = st+1;
                # if nxt == n:
                #     i += 1;
                #     nxt = i+1;
                res.append(int(st));
                p += 1;
                while p <= r and nxt <= n:
                    if p <= r:
                        res.append(i);
                        p += 1;
                    if p <= r:
                        res.append(int(nxt));
                        p += 1;
                    nxt += 1;
                i += 1;
                nxt = i+1;
        if r == (n-1)*(n-1)+n: res.append(1);
        print(*res, sep=" ");
                


main();