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.*;

/**
 * @author Tran Anh Tai
 * @link: https://codeforces.com/contest/1334/problem/D
 * @Idea: the minimum lexicographical cycle will be in formed:
 * 1. (1-2)-(1-3)-(1-4)....-(1-n); (2 * (n - 1))
 * 2. (2-3)-(2-4)-(2-5)....-(2-n); (2 * (n - 2))
 * 3. ...........................; 2 * (n - 1);
 * n. 1
 */
public class MinimumEulerCycle {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }
    // main solver
    static class Task{
        public void solve(InputReader in, PrintWriter out) {
            int t = in.nextInt();
            for (int test = 0; test < t; test++){
                int n = in.nextInt();
                long l = in.nextLong();
                long r = in.nextLong();
                int row = 0;
                long total = 0;
                for  (row = 1; row <= n - 1; row++){
                    total += 2 * (n - row);
                    if (total >= l){
                        break;
                    }
                }
                if (row == n){
                    out.println(1); continue;
                }
                else{
                    int k = (int)(r - l + 1);
                    total -= 2 * (n - row);
                    l -= total;
                    int turn = 0;
                    int cur_vertice = row + 1;
                    int cur_row = row;
                    for (int i = 0; i < l - 1; i++){
                        if (turn == 1){
                            cur_vertice++;
                        }
                        turn = turn ^ 1;
                    }
                    for (int time =  0; time < k; time++){
                        if (cur_row == n){
                            out.print(1);
                        }
                        else if (turn == 0){
                            out.print(cur_row + " ");
                        }
                        else{
                            out.print(cur_vertice + " ");
                            cur_vertice++;
                            if (cur_vertice > n){
                                cur_row++;
                                cur_vertice = cur_row + 1;
                            }
                        }
                        turn = turn ^ 1;
                    }
                    out.println();
                }
            }
        }
    }

    // fast input reader class;
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;

        public InputReader(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                String line = null;
                try {
                    line = br.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                if (line == null) {
                    return null;
                }
                st = new StringTokenizer(line);
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        public long nextLong(){
            return Long.parseLong(nextToken());
        }
    }
}