Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers not larger than n. We'll denote as n the length of permutation p1, p2, ..., pn.

Your task is to find such permutation p of length n, that the group of numbers |p1 - p2|, |p2 - p3|, ..., |pn - 1 - pn| has exactly k distinct elements.

Input

The single line of the input contains two space-separated positive integers n, k (1 ≤ k < n ≤ 105).

Output

Print n integers forming the permutation. If there are multiple answers, print any of them.

Examples

Input

3 2


Output

1 3 2


Input

3 1


Output

1 2 3


Input

5 2


Output

1 3 2 4 5

Note

By |x| we denote the absolute value of number x. 
import java.io.*;
import java.util.Random;
import java.util.*;
import java.util.Scanner;

public class Main {

	  
	  public static String binary = "";
	  //System.out.println(ans);
	  public static int gcd(int a,int b){
		if(a == 0)
			return b;
		return gcd(b % a, a);
	  }
	  
	  private static void Binaryform(int number) {
        int remainder;
        if (number <= 1) {
            binary += number;
            return;
        }
        remainder = number %2; 
        Binaryform(number >> 1);
        binary += remainder +"";
      }
	  
	  public static void print(Object o){
		System.out.print(o +" ");
	  }
	  
	  public static void println(Object o){
		System.out.println(o);
	  }

	  public  static class Point{
			  public int x = 0;
			  public int y = 0;
			  
			  Point (int x , int y){
				  this.x = x;
				  this.y = y;
				  }
			  	
			}			
		
		public static int isSquare(Point p1, Point p2,Point p3,Point p4){
			double dx = 0, dy = 0;
			double dd [] = new double [6];
			Point [] pp = new Point[4];
			pp[0]=p1; pp[1]=p2; pp[2]=p3; pp[3]=p4;
			int ii = 0; int jj = 0; int kk = 0; int nn = 0;
			
			for(ii = 0; ii < 3; ii++){
				for(jj = ii + 1; jj < 4; jj++){
					dx = pp[ii].x - pp[jj].x;
					dy = pp[ii].y - pp[jj].y;
					dd[kk] = dx*dx + dy*dy;
					if(dd[kk] == 0) return 0;
					if(kk > 1){
						for(nn = 0; nn < kk - 1; nn++){
							if (!( (2*dd[nn] == dd[kk] ) || (dd[nn] == dd[kk]) || (2*dd[kk] == dd[nn] )) ) 
								return 0;
						}
					}
					kk += 1;
				}
			}
			return 1;
		}
	  
	  /*
	   4
		2 3 4 9
		1 3
	   */
	   
	  public static long GetGCDByModulus(long value1, long value2)
		{
				while (value1 != 0 && value2 != 0)
				{
					if (value1 > value2)
						value1 %= value2;
					else
						value2 %= value1;
				}
				return Math.max(value1, value2);
		}
	public static boolean Coprime(long value1, long value2)
	{
		return GetGCDByModulus(value1, value2) == 1;
	}
	
      public static void main(String arg[]){

		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n = in.nextInt();
		int k = in.nextInt();
		int a = 1; int b = n; boolean flag = true;
		int cont = 1;
		for(int i = 1; i <= n; i++){
				if(flag){
					out.print(a +" ");
					a += 1;
					
					if(cont + 1 <= k)
						flag = false;
				}
				else{
					out.print(b +" ");
					b -= 1;
			
					if(cont + 1 <= k)
						flag = true;
				}
				cont += 1; 
		}
		in.close();
		out.close();
		
	  }
		


} 


 	
