Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill: 

  * the graph contains exactly 2n + p edges; 
  * the graph doesn't contain self-loops and multiple edges; 
  * for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges. 



A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices. 

Your task is to find a p-interesting graph consisting of n vertices.

Input

The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test. 

It is guaranteed that the required graph exists.

Output

For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n. 

Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.

Examples

Input

1
6 0


Output

1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6
import java.util.*;
import java.lang.reflect.Array;
import java.math.*;
import java.io.*;
import java.awt.*;

public class Main{
    static FastReader in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(System.out);
    static final int maxn = (int)1e2 + 11;
    static int inf = (1<<30) - 1;
    static Integer n,m;
    static int a[] = new int [maxn];
    static int b[] = new int [maxn];
    static int c[] = new int [maxn];
    static ArrayList<Integer> list = new ArrayList<>();
    
    public static void solve() throws Exception {

        int t = in.nextInt();
        
        for (int k=1; k<=t; k++) {
            n = in.nextInt();
            int p = in.nextInt();
            for (int i=1; i<=n; i++) {
                if ((i+1)%n==0) 
                    out.println(i + " " + n);
                else 
                    out.println(i + " " + ( (i+1)%n) );
                
                if ((i+2)%n==0) 
                    out.println(i + " " + n);
                else 
                    out.println(i + " " + ( (i+2)%n));
                
            }
            
            for (int h=3; h<=n; h++) {
                for (int i=1; i<=n; i++) {
                    if (p<=0) break;
                    if ((i+h)%n==0) 
                        out.println(i + " " + n);
                    else 
                        out.println(i + " " + (i+h)%n); 
                    p--;
                }
            }
        }
        
        
    
    }

    public static void main (String args[]) throws Exception {
        solve();
        out.close();
    }
    
    

}

class Pair implements Comparable<Pair> {
    int x,y;
    public Pair (int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    @Override
    public int compareTo(Pair p) {
        if (this.x<p.x) {
            return -1;
        } else if (this.x == p.x) {
            return 0;
        } else {
            return 1;
        }
    }
    
    
}

class FastReader {

    BufferedReader bf;
    StringTokenizer tk = null;
    String DELIM = " ";

    public FastReader(BufferedReader bf) {
        this.bf = bf;
    }

    public String nextToken() throws Exception {

        if(tk==null || !tk.hasMoreTokens()) {
            tk = new StringTokenizer(bf.readLine(),DELIM);
        }
        return tk.nextToken();
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}