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

public class Main { 
    
    static boolean FROM_FILE = false;
    
    static class FastReader { 
        BufferedReader br; 
        StringTokenizer st; 
        public FastReader() { 
            if (FROM_FILE) {
                try {
                    br = new BufferedReader(new FileReader("input.txt")); 
                } catch (IOException error) {
                }   
            } else {
                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; 
        } 
    }
    static int max(int... nums) {
        int res = Integer.MIN_VALUE;
        for (int num: nums) res = Math.max(res, num);
        return res;
    }
    static int min(int... nums) {
        int res = Integer.MAX_VALUE;
        for (int num: nums) res = Math.min(res, num);
        return res;
    }
    static long max(long... nums) {
        long res = Long.MIN_VALUE;
        for (long num: nums) res = Math.max(res, num);
        return res;
    }
    static long min(long... nums) {
        long res = Long.MAX_VALUE;
        for (long num: nums) res = Math.min(res, num);
        return res;
    }
    
    static FastReader fr = new FastReader();
    static PrintWriter out;
    
    public static void main(String[] args) { 
        if (FROM_FILE) {
            try {
                out = new PrintWriter(new FileWriter("output.txt"));
            } catch (IOException error) {
                
            }
        } else {
            out = new PrintWriter(new OutputStreamWriter(System.out));
        }
        new Main().run();
        out.flush();
        out.close();
    } 
    
    long getLevel(long n, long idx) {
        for (long i = 1; i <= n; i += 1) {
            if ((2 * n - 1 - i) * i >= idx) return i;
        }
        return -1;
    }
    
    void run() {
        int t = fr.nextInt();
        while (t-- > 0) {
            long n = fr.nextLong(), l = fr.nextLong(), r = fr.nextLong();
            if (l == n * (n - 1) + 1) {
                out.println(1);
                continue;
            }
            int len = (int)(r - l) + 1;
            long[] res = new long[len];
            int idx = 0;
            long k = getLevel(n, l), pre = (2 * n - 1 - (k - 1)) * (k - 1), col = k + (l - pre) / 2;
            if ((l - pre) % 2 == 0) res[idx++] = col;
            // out.println(col);
            for (long i = col + 1; i <= n && idx + 1 < len; i += 1) { res[idx++] = k; res[idx++] = i; }
            // out.println(Arrays.toString(res));
            boolean finalOne = false;
            if (r == n * (n - 1) + 1) {
                r -= 1;
                finalOne = true;
            }
            long k2 = getLevel(n, r);
            // out.println(k + " " + k2);
            for (long level = k + 1; level < k2; level += 1) {
                for (long i = level + 1; i <= n; i += 1) { res[idx++] = level; res[idx++] = i; }
            }
            // out.println(Arrays.toString(res));
            long last_x = k2, last_y = last_x + 1;
            while (idx + 1 < len) {
                res[idx++] = last_x;
                res[idx++] = last_y++;
            }
            if (idx < len) {
                res[idx] = finalOne ? 1 : last_x;
            }
            out.println(LongStream.of(res).mapToObj(e -> "" + e).collect(Collectors.joining(" ")));
            
        }
    }
}