Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.

The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.

The pseudo code of the unexpected code is as follows:
    
    
      
    input n  
    for i from 1 to n  
        input the i-th point's coordinates into p[i]  
    sort array p[] by increasing of x coordinate first and increasing of y coordinate second  
    d=INF        //here INF is a number big enough  
    tot=0  
    for i from 1 to n  
        for j from (i+1) to n  
            ++tot  
            if (p[j].x-p[i].x>=d) then break    //notice that "break" is only to be  
                                                //out of the loop "for j"  
            d=min(d,distance(p[i],p[j]))  
    output d  
    

Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.

You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?

Input

A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).

Output

If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.

The conditions below must be held:

  * All the points must be distinct. 
  * |xi|, |yi| ≤ 109. 
  * After running the given code, the value of tot should be larger than k. 

Examples

Input

4 3


Output

0 0
0 1
1 0
1 1


Input

2 100


Output

no solution
import java.util.*;

public class Pair{
	public static void main(String[] args){
		Scanner reader = new Scanner(System.in);
		int n = reader.nextInt();
		int k = reader.nextInt();
		Point[] p = new Point[n];
		Point dir = new Point(1,2001);
		p[0] = new Point(0,0);
		for(int i = 1; i < n; i++)
			p[i] = p[i-1].add(dir);
		if((n*(n-1))/2 > k){
			for(int i = 0; i < n; i++)
				System.out.println(p[i].x + " " + p[i].y);
		}else{
			System.out.println("no solution");
		}
	}
	
	public static boolean test(Point[] p, int k){
		Arrays.sort(p);
		int n = p.length;
		int tot = 0;
		double d = 1e16;
		for(int i = 0; i < n; i++)
			for(int j = i+1; j < n; j++){
				tot++;
				if(p[j].x-p[i].x >= d)
					break;
				d = Math.min(d, p[i].dis(p[j]));
			}
		return tot > k;
	}
	
	public static class Point implements Comparable<Point>{
		int x,y;
		public Point(int _x, int _y){
			x = _x;
			y = _y;
		}
		public Point add(Point p){
			return new Point(x+p.x, y+p.y);
		}
		public double dis(Point p){
			return Math.sqrt(Math.pow(x-p.x,2)+Math.pow(y-p.y,2));
		}
		public int compareTo(Point p){
			if(x == p.x)
				return y-p.y;
			return x-p.x;
		}
	}
}
