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.io.*;
   public class Solution implements Runnable{
        FastScanner sc;
        PrintWriter pw;
        final class FastScanner {
            BufferedReader br;
            StringTokenizer st;
     
            public FastScanner() {
                try {
                    br = new BufferedReader(new InputStreamReader(System.in));
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
     
            public long nlo() {
                return Long.parseLong(next());
            }
     
            public String next() {
                if (st.hasMoreTokens()) return st.nextToken();
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return st.nextToken();
            }
     
            public int ni() {
                return Integer.parseInt(next());
            }
     
            public String nli() {
                String line = "";
                if (st.hasMoreTokens()) line = st.nextToken();
                else try {
                    return br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                while (st.hasMoreTokens()) line += " " + st.nextToken();
                return line;
            }
     
            public double nd() {
                return Double.parseDouble(next());
            }
        }
        public static void main(String[] args)
        {
            new Thread(null,new Solution(),"codeforces",1<<25).start();
        }
        public void run()
        {
            sc=new FastScanner();
            pw=new PrintWriter(System.out);
           solve();
            pw.flush();
            pw.close();
        }
        public long gcd(long a,long b)
        {
            return b==0L?a:gcd(b,a%b);
        }
        public long ppow(long a,long b,long mod)
        {
            if(b==0L)
            return 1L;
            long tmp=1;
            while(b>1L)
            {
                if((b&1L)==1)
                tmp*=a;
                a*=a;
                a%=mod;
                tmp%=mod;
                b>>=1;
            }
            return (tmp*a)%mod;
        }
        public  int gcd(int x,int y)
        {
            return y==0?x:gcd(y,x%y);
        }
        //////////////////////////////////
        /////////////  LOGIC  ///////////
        ////////////////////////////////
       public void solve(){
           int t=sc.ni();
           while(t-->0)
           {
                long n=sc.nlo();
                long l=sc.nlo();
                long r=sc.nlo();
                long tt=r-l+1L;
                StringBuilder str=new StringBuilder();
                for(long i=1;i<n;i++)
                {
                    l-=(n-i)*2L;
                    if(l>0)
                    continue;
                    l+=(n-i)*2L;
                    if(l%2==0){
                        long j=l/2+i;
                    str.append(j+" ");
                tt--;}
                    tt=dop(i,l/2+1,n,tt,str);
                    break;
                }
                if(tt>0)
                str.append(1);
                pw.println(str);
           }
        }
        public long dop(long i,long p,long n,long t,StringBuilder str)
        {
            //pw.println(i+" "+p+" "+t);
            for(;i<n;i++)
            {
                for(long j=i+p;j<=n;j++)
                {
                    if(t>=2)
                    {str.append(i+" "+j+" ");t-=2L;}
                    else if(t==1)
                    {
                        str.append(i+" ");
                        t-=1;
                    }
                    if(t==0)
                    break;
                }
                p=1;
                if(t==0)
                break;
            }
            if(t==1)
           {t--; str.append(1);}
            return t;
        }
    }