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 JAVA):

Solution:
import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	PrintWriter out = new PrintWriter(System.out);
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");
    String next() throws IOException {
        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }
        return tok.nextToken();
    }
    int ni() throws IOException { return Integer.parseInt(next()); }
    long nl() throws IOException { return Long.parseLong(next()); }
  
    void solve() throws IOException {
        for (int tc=ni();tc>0;tc--) {
            long n=nl(),a=nl(),b=nl();
            
            long curr=1;
            long p=0;
            for (long x=1;x<=n;x++) {
                long nc=curr+2*(n-x);
                if (nc>a) { p=x; break; }
                curr=nc;
            }
            
            if (p==0) {
                out.println(1);
                continue;
            }
            
            long q=p+1;
            while (curr<a) { curr+=2; q++; }
            if (curr>a) { out.print((q-1)+" "); }
            
            while (curr<b-1 && q<=n) {
                out.print(p+" "+q+" ");
                q++;
                curr+=2;
            }
            if (curr==b) {
                if (q>n) 
                    if (p+2>n) out.println(1);
                    else out.println(p+1);
                else
                    out.println(p); 
                continue; 
            }
            if (curr==b-1) {
                if (q>n) {
                    if (p+2>n) out.println(n+"1");
                    else out.println((p+1)+" "+(p+2));
                }
                else out.println(p+" "+q);
                continue;
            }
            
            p++;
            while (p<n) {
                q=p+1;
                while (curr<b-1 && q<=n) {
                    out.print(p+" "+q+" ");
                    q++;
                    curr+=2;
                }
                if (curr>=b-1) break;
                p++;
            }
            
            if (p==n) {
                if (curr==b) out.println(n);
                else out.println(n+" 1");
            }
            else {
                if (curr==b) {
                    if (q>n) 
                        if (p+2>n) out.println(1);
                        else out.println(p+1);
                    else
                        out.println(p); 
                    continue; 
                }
                if (curr==b-1) {
                    if (q>n) {
                        if (p+2>n) out.println(n+"1");
                        else out.println((p+1)+" "+(p+2));
                    }
                    else out.println(p+" "+q);
                }
            }
            
        }
        out.flush();
    }
    
    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
}