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.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
import java.lang.*;
import java.util.*;
import java.math.*;
import java.util.Collections;
import java.util.Comparator;
import java.util.StringTokenizer;
import java.lang.String;

public class Solution {

    public static void main(String[] args) {
        new Solution().myRun();
    }

    FastInputScanner in;
    PrintWriter out;

    void solveTask() {
        int n = in.nextInt();
        int m = in.nextInt();
        int i = 1;
        int j = n;
        int move = 0;
        int last = -1;
        ArrayList<Integer> answer = new ArrayList<Integer>();
        while (m > 0) {
            --m;
            if (move % 2 == 0) {
                 answer.add(i);
                 ++i;
                 last = i - 1;
            } else {
                answer.add(j);
                --j;
                last = j + 1;
            }
            move = 1 - move;
        }
        if (last == i - 1) {
            while (i <= j) {
                answer.add(i);
                ++i;
            }
        } else {
            while (i <= j) {
                answer.add(j);
                --j;
            }
        }
        for (int k = 0; k < answer.size(); ++k) {
            out.print(answer.get(k) + " ");
        }
        out.println();
    }

    void myRun() {
        in = new FastInputScanner(System.in);
        out = new PrintWriter(new OutputStreamWriter(System.out));
        solveTask();
        out.close();
    }

    void myRunIO(){
        try  {
            in = new FastInputScanner(new File("input.txt"));
            out = new PrintWriter(new FileWriter(new File("output.txt")));
            solveTask();
            out.close();
        } catch(Exception exception){
            exception.printStackTrace();
        }
    }

    class FastInputScanner{

        BufferedReader bufferedReader;
        StringTokenizer stringTokenizer;

        public FastInputScanner(File file){
            try{
                bufferedReader = new BufferedReader(new FileReader(file));
            }
            catch(IOException exception){
                exception.printStackTrace();
            }
        }

        public FastInputScanner(InputStream inputStream){
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream), 32768);
        }

        String next(){
            while(stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
                try {
                    stringTokenizer = new StringTokenizer(bufferedReader.readLine());
                }
                catch(IOException exception) {
                    exception.printStackTrace();
                }
            }
            return stringTokenizer.nextToken();
        }

        int nextInt(){
            return Integer.parseInt(next());
        }

        double nextDouble(){
            return Double.parseDouble(next());
        }

        float nextFloat(){
            return Float.parseFloat(next());
        }

        String nextLine(){
            try {
                return bufferedReader.readLine();
            }
            catch(Exception exception) {
                exception.printStackTrace();
            }
            return "";
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        BigInteger nextBigInteger() {
            return new BigInteger(next());
        }

        BigDecimal nextBigDecimal() {
            return new BigDecimal(next());
        }

        int[] nextIntArray(int n) {
            int a[] = new int[n];
            for(int i = 0; i < n; i++)
                a[i] = Integer.parseInt(next());
            return a;
        }

        long[] nextLongArray(int n){
            long a[] = new long[n];
            for(int i = 0; i < n; i++)
                a[i] = Long.parseLong(next());
            return a;
        }

    }

}
