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.*;
import java.math.*;
//BigInteger A;
//A= BigInteger.valueOf(54);
//ArrayList<Integer> a=new ArrayList<>();
//TreeSet<Integer> ts=new TreeSet<>();
//HashMap<Integer,Integer> hm=new HashMap<>();
//PriorityQueue<Integer> pq=new PriorityQueue<>();
public final class Practice
{
    static ArrayList<Integer> dfsorder;
    static int child[];
    //static int c=0;
    public static void dfs(ArrayList<ArrayList<Integer>> adj,boolean vis[],int u)
    {
        vis[u]=true;
        dfsorder.add(u);
        child[u]=1;
        for(int i=0;i<adj.get(u).size();i++)
        {
            if(!vis[adj.get(u).get(i)])
            {
                dfs(adj,vis,adj.get(u).get(i));
                child[u]+=child[adj.get(u).get(i)];
            }
        }
    }
    public static void main(String[]args)throws IOException
    {
        int K=(int)Math.pow(10,9)+7;
        FastReader ob=new FastReader();
        int t=ob.nextInt();
        while(t-->0)
        {
            long n=ob.nextLong();
            long l=ob.nextLong();
            long r=ob.nextLong();
            ArrayList<Long> a=new ArrayList<>();
            long k=0;
            while(l>2*(n-1)&&n>0)
            {
                l-=2*(n-1);
                r-=2*(n-1);
                ++k;
                --n;
            }
            while(l<=2*(n-1)&&n>0)
            {
                for(long i=l;i<=Math.min(r,2*n-2);i++)
                {
                    if(i%2!=0)
                    a.add(1+k);
                    else
                    a.add((i/2)+1+k);
                }
                l=1;
                r-=2*(n-1);
                ++k;
                --n;
            }
            if(r==1)
            a.add(1l);
            for(int i=0;i<a.size();i++)
            System.out.print(a.get(i)+" ");
            System.out.println();
        }
    }
}
class FastReader {
    BufferedReader br;
    StringTokenizer st;
    public FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    public String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e)  {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }
    public String nextLine()
    {
        String s="";
        try {
        s=br.readLine();
        } catch (IOException e)  {
                e.printStackTrace();
            }
        return s;
    }
    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}