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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Round236_Div1_A {

    
    public void solve()throws Exception{
        InputReader in = new InputReader();
        
        int t = in.nextInt();
        while(t-- > 0){
            int n = in.nextInt();
            int p = in.nextInt();
            int all = (n*(n-1))/2;
            int toRemove = all - (2*n + p);
            int [][]ans = new int[2][all];
            int []degree = new int[n];
            Arrays.fill(degree, n-1);
            boolean[] taken = new boolean[all];
            int next =0;
            for(int i =0;i < n;i++)
                for(int j = i+1;j < n;j++){
                    ans[0][next] = i;
                    ans[1][next] = j;
                    next++;
                }

            while(toRemove-- > 0){
                int maxDegree =0;
                int minDegree =0;
                int node1 =0;
                int node2 =0;
                int edgeIndex =0;
                for(int i =0;i < all;i++){
                    if(taken[i])continue;
                    int min = Math.min(degree[ans[0][i]], degree[ans[1][i]]);
                    int max = Math.max(degree[ans[0][i]], degree[ans[1][i]]);
                    if(max > maxDegree || (max == maxDegree && min > minDegree)){
                        maxDegree = max;
                        minDegree = min;
                        node1 = ans[0][i];
                        node2 = ans[1][i];
                        edgeIndex = i;
                    }
                }
                degree[node1]--;
                degree[node2]--;
                taken[edgeIndex] = true;
            }

            StringBuffer ret = new StringBuffer();
            for(int i =0;i < all;i++){
                if(!taken[i]){
                    ret.append((ans[0][i]+1) + " " + (ans[1][i]+1)+"\n");
                }
            }
            System.out.print(ret);
        }
        
        
    }
    
    
    public static void main(String[] args) throws Exception {
        new Round236_Div1_A().solve();
    }

    static class InputReader {
        BufferedReader in;
        StringTokenizer st;

        public InputReader() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
            st = new StringTokenizer(in.readLine());
        }

        public String next() throws IOException {

            while (!st.hasMoreElements())
                st = new StringTokenizer(in.readLine());
            return st.nextToken();
        }

        public int nextInt() throws NumberFormatException, IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws NumberFormatException, IOException {
            return Long.parseLong(next());
        }
    }

}
