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:
// package codeforces; /Users/attilaj/IdeaProjects/Codejam/src/codeforces/D1334.java

import java.util.Scanner;

public class D1334 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int tt = Integer.parseInt(sc.nextLine());
        for (int t = 1; t <= tt; t++) {
            String[] line = sc.nextLine().split(" ");
            int n = Integer.parseInt(line[0]);
            long l = Long.parseLong(line[1]);
            long r = Long.parseLong(line[2]);

            StringBuilder sb = new StringBuilder();
            fill2(sb, n, 1, l - 1, r - 1);
            System.out.println(sb.toString().substring(1));
        }
    }

    private static boolean fill(StringBuilder sb, int n, int add, long l, long r) {
        if (r < 0) {
            return true;
        } else if (n == 1) {
            sb.append(' ').append(1);
            return true;
        } else if (l >= (n - 1) * 2) {
            return fill(sb, n - 1, add + 1, l - (n - 1) * 2, r - (n - 1) * 2);
        } else if (l < (n - 1) * 2) {
            if (l % 2 == 1) {
                sb.append(' ').append((l + 3) / 2 + add - 1);
                l++;
            }
            long ll = l;
            for (long i = l / 2; i <= r / 2 && i < n - 1; i++) {
                sb.append(' ').append(add);
                ll++;
                if (i * 2 + 1 <= r) {
                    sb.append(' ').append(i + add + 1);
                    ll++;
                }
            }
            l = ll;
            return fill(sb, n - 1, add + 1, 0, r - l);
        } else {
            throw new IllegalStateException("??");
        }
    }

    private static void fill2(StringBuilder sb, int n, int add, long l, long r) {
        while (r >= 0) {
            if (n == 1) {
                sb.append(' ').append(1);
                break;
            } else if (l >= (n - 1) * 2) {
                add++;
                l -= (n - 1) * 2;
                r -= (n - 1) * 2;
                n--;
            } else {
                if (l % 2 == 1) {
                    sb.append(' ').append((l + 3) / 2 + add - 1);
                    l++;
                }
                long ll = l;
                for (long i = l / 2; i <= r / 2 && i < n - 1; i++) {
                    sb.append(' ').append(add);
                    ll++;
                    if (i * 2 + 1 <= r) {
                        sb.append(' ').append(i + add + 1);
                        ll++;
                    }
                }
                n--;
                add++;
                r -= ll;
                l = 0;
            }
        }
    }
}

// n*(n-1)+1
// 2-->3
// 3-->7
// 4-->13
// 5-->21

// 1 2 1 3            2 3                             1    4+2+1
// 1 2 1 3 1 4        2 3 2 4         3 4             1    6+4+2+1
// 1 2 1 3 1 4 1 5    2 3 2 4 2 5     3 4 3 5   4 5   1    8+6+4+2+1
// (n-1)*2  (n-2)*2


// 1  2
// 3  4