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.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class Codeforces implements Runnable {

    private BufferedReader br = null;
    private PrintWriter pw = null;
    private StringTokenizer stk = new StringTokenizer("");

    public static void main(String[] args) {
        new Thread(new Codeforces()).run();
    }

    public void run() {

    /*
     * try { br = new BufferedReader(new FileReader("/home/user/freshdb.sql")); pw = new
     * PrintWriter("/home/user/freshdb_fix.sql"); } catch (FileNotFoundException e) {
     * e.printStackTrace(); }
     */

        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        solver();
        pw.close();

    }

    private void nline() {
        try {
            if (!stk.hasMoreTokens())
                stk = new StringTokenizer(br.readLine());
        } catch (IOException e) {
            throw new RuntimeException("KaVaBUnGO!!!", e);
        }
    }

    private String nstr() {
        while (!stk.hasMoreTokens())
            nline();
        return stk.nextToken();
    }

    private int ni() {
        return Integer.valueOf(nstr());
    }

    private long nl() {
        return Long.valueOf(nstr());
    }

    private double nd() {
        return Double.valueOf(nstr());
    }

    String nextLine() {
        try {
            return br.readLine();
        } catch (IOException e) {
        }
        return null;
    }

    class Point {
        int x;
        int y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    private void bfs(int t, boolean[] using, int[][] g) {
        Stack<Integer> st = new Stack<Integer>();
        int n = using.length;
        st.add(t);
        while (!st.empty()) {
            int p = st.pop();
            for (int i = 0; i < n; i++) {
                if (g[p][i] == 1 && !using[i]) {
                    st.add(i);
                    using[i] = true;
                }
            }
        }
    }

    public int gcd(int a, int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    private boolean checkPrime(int a) {
        for (int i = 2; i <= Math.sqrt(a); i++) {
            if (a % i == 0)
                return false;
        }
        return true;
    }


    class KeySet implements Comparable<KeySet> {
        int key;
        int value;

        public KeySet(int key, int value) {
            this.key = key;
            this.value = value;
        }

        public int getKey() {
            return key;
        }

        public void setKey(int key) {
            this.key = key;
        }

        @Override
        public int compareTo(KeySet keySet) {
            if (this.value > keySet.value) {
                return 1;
            } else if (this.value < keySet.value) {
                return -1;
            } else {
                return 0;
            }
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }
    }

    BigInteger toPositive(BigInteger bi) {
        return bi.signum() < 0 ? bi.negate() : bi;
    }

    int fact(int x) {
        int ans = 1;
        for (int i = 1; i <= x; i++) {
            ans *= i;
        }
        return ans;
    }

    private void solver() {
        int n = ni(), k = ni();
        int l = 1, r = n;
        boolean d = true;
        int p  = 0;
        while (p < k){
            if (d){
                System.out.print(l + " ");
                l++;
                d = false;
                p++;
            }else {
                System.out.print(r + " ");
                r--;
                d = true;
                p++;
            }
        }

        for(int i=0; i<n-k; i++){
            if(!d){
                System.out.print(l + " ");
                l++;
            }else {
                System.out.print(r + " ");
                r--;
            }
        }


    }

    private BigInteger nbi() {
        return new BigInteger(nstr());
    }

    void exit() {
        pw.close();
        System.exit(0);
    }

}