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 A {
    public static void main(String[] args) throws Exception {

        new A().solve();
    }


    void solve() throws IOException {
        FastScanner in = new FastScanner(System.in);

        int n = in.nextInt();
        int k = in.nextInt();
        int[] p = new int[n];

        int cnt = 0;
        int minus = 1;
        for (int i = 1; i < n; i++) {
            if (cnt < k) {
                minus *= -1;
                cnt++;

                if (minus == -1) {
                    p[i] = Math.abs(p[i - 1]) + 1;
                } else {
                    p[i] = Math.abs(p[i - 1]);
                }
                p[i] *= minus;


            } else {// k
                p[i] = Math.abs(p[i - 1]) + 1;
                p[i] *= minus;
            }
        }

        int min = 0;
        for (int i = 0; i < p.length; i++) {
            min = Math.min(min, p[i]);
        }
        for (int i = 0; i < p.length; i++) {
            p[i] -= min;
            p[i]++;
        }

        StringBuilder sb = new StringBuilder();
        sb.append(p[0]);
        for (int i = 1; i < p.length; i++) {
            sb.append(" " + p[i]);
        }

        System.out.print(sb);

    }
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //


    class FastScanner {

        private InputStream _stream;
        private byte[] _buf = new byte[1024];
        private int _curChar;
        private int _numChars;
        private StringBuilder _sb = new StringBuilder();

        FastScanner(InputStream stream) {
            this._stream = stream;
        }

        public int read() {
            if (_numChars == -1) throw new InputMismatchException();
            if (_curChar >= _numChars) {
                _curChar = 0;
                try {
                    _numChars = _stream.read(_buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (_numChars <= 0) return -1;
            }
            return _buf[_curChar++];
        }

        public String next() {
            int c = read();
            while (isWhitespace(c)) {
                c = read();
            }
            _sb.setLength(0);
            do {
                _sb.appendCodePoint(c);
                c = read();
            } while (!isWhitespace(c));
            return _sb.toString();
        }

        public int nextInt() {
            return (int) nextLong();
        }
        public long nextLong() {
            int c = read();
            while (isWhitespace(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isWhitespace(c));
            return res * sgn;
        }

        public boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
    }


}
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
