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. 
def get_diff_list(item):    
    length = len(item)
    if length < 2:
        return {}

    diff_list = {}
    for i in range(1, len(item)):
        diff = item[i - 1] - item[i]
        if diff < 0:
            diff = -diff
        diff_list[diff] = diff_list.setdefault(diff, 0) + 1
    return diff_list

def get_k(item):
    return len(get_diff_list(item))

def permutation(n, k, level = 0):
    if n == 1:
        yield [1,], {}
    else:
        pass_down_k = min(k, n - 2)
        for item, previous_diff_list in permutation(n - 1, pass_down_k, level + 1):
            _k = len(previous_diff_list)
            if level == 0:
                if _k < k - 1 or _k > k + 1:
                    #print 'cont 2'
                    continue
            for i in xrange(n):
                if i == 0:
                    diff_to_remove = None
                    diff_to_add1 = None
                    diff_to_add2 = n - item[i]          
                elif i == n - 1:
                    diff_to_remove = None
                    diff_to_add1 = n - item[i - 1]
                    diff_to_add2 = None     
                else:
                    diff_to_remove = item[i] - item[i - 1]
                    diff_to_add1 = n - item[i - 1]
                    diff_to_add2 = n - item[i]

                if diff_to_remove and diff_to_remove < 0:
                    diff_to_remove = -diff_to_remove
                if diff_to_add1 and diff_to_add1 < 0:
                    diff_to_add1 = -diff_to_add1
                if diff_to_add2 and diff_to_add2 < 0:
                    diff_to_add2 = -diff_to_add2

                delta_list = {}
                if diff_to_remove:
                    delta_list[diff_to_remove] = -1
                if diff_to_add1:
                    delta_list[diff_to_add1] = delta_list.setdefault(diff_to_add1, 0) + 1
                if diff_to_add2:
                    delta_list[diff_to_add2] = delta_list.setdefault(diff_to_add2, 0) + 1

                new_k = _k
                for k, v in delta_list.items():
                    if k not in previous_diff_list:
                        new_k += 1
                    elif v + previous_diff_list[k] <= 0:
                        new_k -= 1
                
                if new_k < k - level or new_k > k + level:
                    #print 'cont 3'
                    continue

                cp = [a for a in item]
                cp.insert(i, n)
                diff_list = get_diff_list(cp)
                assert new_k == len(diff_list), '{0}:{1}:{2}:{3}:{4}:{5}:{6}:{7}:{8}:{9}'.format(item, cp, previous_diff_list, diff_list, delta_list, diff_to_remove, diff_to_add1, diff_to_add2, new_k, len(diff_list))

                yield cp, diff_list

def diverse_permutation(n, k):
    assert k > 0
    assert n > k
    assert n <= 1e5
    for item, diff in permutation(n, k):
        if get_k(item) == k:
            return item

def diverse_permutation_constructive(n, k):
    assert k > 0
    assert n > k
    assert n <= 1e5
    current = 1
    yield current
    coefficient = 1
    for i in xrange(k):        
        current = current + coefficient * (k - i)
        yield current
        coefficient = -coefficient
    for i in range(1 + k + 1, n + 1):
        yield i

if __name__ == '__main__':
    import sys
    sys.setrecursionlimit(10000000)
    array = raw_input().strip().split()
    iterator = diverse_permutation_constructive(int(array[0]), int(array[1]))
    if iterator:
        print(' '.join((str(i) for i in iterator)))
    