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.io.*;
import java.util.*;

public class D {

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

    public static void main (String[] args) throws IOException{
        
        FastReader s = new FastReader();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        int t = s.nextInt();//t: number of test cases
        
        for (int i = 0; i < t; i++) {
            int n = s.nextInt();
            double l = s.nextDouble();
            double r = s.nextDouble();
            
            boolean islLast = l == 1.0 * n * (n-1) + 1;
            boolean isrLast = r == 1.0 * n * (n-1) + 1;
            
            if(!islLast){
                double templ_01 = Math.ceil(((2*n-1)-Math.sqrt(4*Math.pow(n,2)-4*n+1-4*l))/2);
                double templ_02 = (templ_01 - 1) * (2*n - templ_01);
                int templ_11 = (int)(templ_01);
                int templ_12 = (int)((l - 1 - templ_02) / 2 + templ_11 + 1);
                
                if (isrLast) 
                    r--;
                
                boolean isrOdd = r%2==1;
                
                if (isrOdd) {
                    r--;
                }
                
                double tempr_01 = Math.ceil(((2*n-1)-Math.sqrt(4*Math.pow(n,2)-4*n+1-4*r))/2);
                double tempr_02 = (tempr_01 - 1) * (2*n - tempr_01);
                int tempr_11 = (int) (tempr_01);
                int tempr_12 = (int)((r - 1 - tempr_02) / 2 + tempr_11 + 1);
                
                if (l%2==0) {
                    bw.write(templ_12 + " ");
                    
                    templ_12++;
                    if (templ_12 > n) {
                        templ_11 ++;
                        templ_12 = templ_11 + 1;
                    }
                }
                
                while(templ_11 < tempr_11 || templ_11 == tempr_11 && templ_12 <= tempr_12){
                    bw.write(templ_11 + " ");
                    bw.write(templ_12 + " ");
                    
                    templ_12++;
                    if (templ_12 > n) {
                        templ_11 ++;
                        templ_12 = templ_11 + 1;
                    }
                }
                if (isrOdd) {
                    bw.write(templ_11 + " ");
                }
                if (isrLast) {
                    bw.write("1");
                }
            }
            else
                bw.write("1");
            
            bw.write("\n");
            
        }
        
        
        bw.flush();
        bw.close();
    }
    
}