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.*;

public class Main {
		
	public static void main(String[] args) throws IOException {
		new Main().solve();
	}
	
	PrintWriter out;
	int n;
	int m;
	boolean[] use;
	int mod = 1000000007;
	int rv = 0;
	int[][] g;
	void solve() throws IOException{
		Reader in = new Reader("output.txt");
		out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
		//out = new PrintWriter(new FileWriter(new File("output.txt"))); 
		
		
		int n = in.nextInt();
		int k = in.nextInt();
		
		int h = n;
		int l = 1;
		
		int f = 1;
		
		out.print(h+" ");
		h--;
		
		while (k > 1) {
			
			if (f == 1) {
				out.print(l+" ");
				l++;
				f = 0;
			}
			else
			if (f == 0) {
				out.print(h+" ");
				h--;
				f = 1;
			}
			
			k--;
		
		}
		
		if (f == 1)
			for (int i = h; i >= l; i--)
				out.print(i+" ");
		else
			for (int i = l; i <= h; i++)
				out.print(i+" ");
		
		out.flush();
		out.close();
		
	}
	
	long gcd(long m, long n) {
		if (n == 0)
			return m;
			
		return gcd(n, m%n);
	}
	
	long pow(int x, int m) {
		if (m == 0)
			return 1;
		return x*pow(x, m-1);
	}

	
class Pair implements Comparable<Pair> {
		
		long v;
		int i;
		
		Pair (long v, int i) {
			this.v = v;
			this.i = i;
		}

		@Override
		public int compareTo(Pair p) {
			if (v < p.v)
				return 1;
			if (v > p.v)
				return -1;
			return 0;
		}
		
	}

	class Item implements Comparable<Item> {

		int a;
		int b;
		long u;
		
		Item(int v, int l, long z) {
			this.a = v;
			this.b = l;
			this.u = z;
		}
		
		@Override
		public int compareTo(Item item) {
			
			if (u > item.u)
				return 1;
			else
			if (u < item.u)
				return -1;
			else {
				return 0;
			}
						
		}
		
	}
	
	class Reader {
	    
	    StringTokenizer token;
	    BufferedReader in;
	    
	    public Reader(String file) throws IOException {
	        //in = new BufferedReader( new FileReader( file ) );
	        in = new BufferedReader( new InputStreamReader( System.in ) );
	    }
	    
	    public byte nextByte() throws IOException {
	        return Byte.parseByte(Next());
	    }
	    
	    public int nextInt() throws IOException {
	        return Integer.parseInt(Next());
	    }
	    
	    public long nextLong() throws IOException {
	        return Long.parseLong(Next());
	    }
	    
	    public String nextString() throws IOException {
	        return in.readLine();
	    }
	    
	    public String Next() throws IOException {
	        while (token == null || !token.hasMoreTokens()) {
	            token = new StringTokenizer(in.readLine());
	        }
	        return token.nextToken();
	    }

	    
	}
	
}
	
	

	
