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:
/*
 *created by Kraken on 02-05-2020 at 14:27
 */
//package com.kraken.cf.practice;

import java.util.*;
import java.io.*;

public class D1334 {

  public static void main(String[] args) {
    FastReader sc = new FastReader();
    int t = sc.nextInt();
    while (t-- > 0) {
      int n = sc.nextInt();
      long l = sc.nextLong(), r = sc.nextLong();
      long[] block = new long[n + 1];
      block[0] = 0;
      for (int i = 1; i <= n; i++) block[i] = 2 * (n - i) + block[i - 1];
      block[n] += 2;
//      System.out.println(Arrays.toString(block));
      long left = findBlock(block, l);
      long right = findBlock(block, r);
//      System.out.printf("left: %d, right: %d\n", left, right);
      long curr = left;
      ArrayList<Long> path = new ArrayList<>();
      while (curr <= right) {
        for (long i = curr + 1; i <= n; i++) {
          path.add(curr);
          path.add(i);
        }
        curr++;
      }
      if (right == n) path.add(1L);
//      System.out.println(path.toString());
      StringBuilder sb = new StringBuilder();
      long lidx = l - block[(int) (left - 1)] - 1;
      for (int i = 0; i < r - l + 1; i++) {
        sb.append(path.get((int) (lidx + i))).append(" ");
      }
      System.out.println(sb.toString());
    }
  }

  private static int findBlock(long[] a, long key) {
    int l = 1, r = a.length - 1;
    while (l < r) {
      int mid = l + (r - l) / 2;
      if (a[mid] >= key) r = mid;
      else l = mid + 1;
    }
    return r;
  }

  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;
    }
  }
}