Once upon a time a little frog whose name was Vasya decided to travel around his home swamp. Overall there are n mounds on the swamp, located on one line. The distance between the neighboring mounds is one meter. Vasya wants to visit all the mounds in one day; besides, he wants to visit each one exactly once. For that he makes a route plan, to decide the order in which to jump on the mounds. Vasya can pick any mound as the first one. He thinks it boring to jump two times at the same distance. That's why he wants any two jumps on his route to have different lengths. Help Vasya the Frog and make the plan for him.

Input

The single line contains a number n (1 ≤ n ≤ 104) which is the number of mounds.

Output

Print n integers pi (1 ≤ pi ≤ n) which are the frog's route plan. 

  * All the pi's should be mutually different. 
  * All the |pi–pi + 1|'s should be mutually different (1 ≤ i ≤ n - 1). 



If there are several solutions, output any.

Examples

Input

2


Output

1 2 

Input

3


Output

1 3 2

Difficulty: EASY
Tags: Constructive algorithms

Starter code:

Solutions:
from itertools import zip_longest
n = int(input())
z = (n + 1) // 2
for (p, q) in zip_longest(range(1, z + 1), range(n, z, -1)):
	if q:
		print(p, q, end=' ')
	else:
		print(p)


n = int(input())
if n % 2 == 0:
	l1 = [x for x in range(1, n // 2 + 1)]
	l2 = list(reversed([x for x in range(n // 2 + 1, n + 1)]))
	m = []
	for i in range(n // 2):
		m.append(l2[i])
		m.append(l1[i])
else:
	l1 = [x for x in range(1, n // 2 + 1)]
	l2 = list(reversed([x for x in range(n // 2 + 1, n)]))
	m = []
	m.append(n)
	for i in range(n // 2):
		m.append(l1[i])
		m.append(l2[i])
print(*m)


n = int(input())
p = list(range(1, n + 1))
lk = []
s = 0
m = -1
if n % 2 != 0:
	for x in range(n // 2):
		lk.append(p[s])
		lk.append(p[m])
		s += 1
		m -= 1
	lk.append(p[n // 2])
else:
	for x in range(n // 2):
		lk.append(p[s])
		lk.append(p[m])
		s += 1
		m -= 1
print(*lk)


import sys
input = sys.stdin.readline
for _ in range(1):
	n = int(input())
	(l, r) = (1, n)
	while l < r:
		print(l, end=' ')
		print(r, end=' ')
		l += 1
		r -= 1
	if l == r:
		print(l)


n = int(input())
b = []
c = []
for i in range(1, n + 1):
	b.append(i)
if len(b) % 2 == 0:
	for i in range(len(b) // 2):
		c.append(b[i])
		c.append(b[len(b) - i - 1])
	for i in c:
		print(i, end=' ')
else:
	for i in range(len(b) // 2):
		c.append(b[i])
		c.append(b[len(b) - i - 1])
	c.append(b[len(b) // 2])
	for i in c:
		print(i, end=' ')


n = int(input())
a = []
large = n
small = 1
for i in range(n):
	if i % 2 == 0:
		a.append(large)
		large -= 1
	else:
		a.append(small)
		small += 1
print(*a)


import sys

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
n = iinput()
for i in range(n):
	print(n - i // 2 if i % 2 else i // 2 + 1, end=' ')


def solve(num):
	lower = 1
	upper = num
	if num % 2 == 0:
		print(num, end=' ')
		upper -= 1
	while lower != upper:
		print(lower, end=' ')
		print(upper, end=' ')
		lower += 1
		upper -= 1
	print(lower)
	return
n = int(input())
solve(n)


import math
a = []
n = int(input())
for i in range(1, math.ceil(n / 2) + 1):
	if 2 * i != n + 1:
		a.append(i)
		a.append(n + 1 - i)
	else:
		a.append(i)
print(*a)


n = int(input())
i = 1
j = n
ans = []
while i <= j:
	if i == j:
		ans.append(i)
	else:
		ans.append(i)
		ans.append(j)
	i += 1
	j -= 1
print(*ans)


t = int(input())
f = 1
m = 1
x = t
sum = 0
s = ''
while m <= x:
	if m == x:
		print(m)
		break
	else:
		print(m, end=' ')
		print(x, end=' ')
		m += 1
		x -= 1


import math
n = int(input())
if n == 1:
	print(1)
elif n == 2:
	print('1 2')
else:
	i = 1
	j = n
	while True:
		if i <= math.ceil(n / 2):
			print(i, end=' ')
		if j > n - math.floor(n / 2):
			print(j, end=' ')
		i += 1
		j -= 1
		if i >= math.ceil(n / 2) and j < n - math.floor(n / 2):
			break


n = int(input())
ans = [0] * n
l = 1
r = n
i = 0
while i < n:
	if i % 2 == 0:
		ans[i] = l
		l = l + 1
	else:
		ans[i] = r
		r = r - 1
	i = i + 1
for i in ans:
	print(i, end=' ')


mounds = int(input())
if mounds == 1:
	print(1)
	quit()
o = 2
h = mounds // 2
t = mounds
m = [1]
for i in range(0, mounds // 2 + 1):
	if t > h:
		m.append(t)
		t -= 1
	if o <= h:
		m.append(o)
		o += 1
print(' '.join(map(str, m)))


a = int(input())
l = 1
r = a
ans = [1]
while len(ans) != a:
	i = len(ans)
	if i % 2 == 1:
		ans.append(r)
		r -= 1
	else:
		ans.append(l + 1)
		l += 1
print(*ans)


import sys
n_rocks = int(sys.stdin.readline())
(left, right) = (1, n_rocks)
n = 0
while left <= right:
	if n % 2 == 0:
		print(left)
		left += 1
	else:
		print(right)
		right -= 1
	n += 1


import re
import sys
exit = sys.exit
from bisect import bisect_left as bsl, bisect_right as bsr
from collections import Counter, defaultdict as ddict, deque
from functools import lru_cache
cache = lru_cache(None)
from heapq import *
from itertools import *
from math import inf
from pprint import pprint as pp
enum = enumerate
ri = lambda : int(rln())
ris = lambda : list(map(int, rfs()))
rln = sys.stdin.readline
rl = lambda : rln().rstrip('\n')
rfs = lambda : rln().split()
cat = ''.join
catn = '\n'.join
mod = 1000000007
d4 = [(0, -1), (1, 0), (0, 1), (-1, 0)]
d8 = [(-1, -1), (0, -1), (1, -1), (-1, 0), (1, 0), (-1, 1), (0, 1), (1, 1)]
n = ri()
ans = []
(l, r, j) = (1, n, 0)
while l <= r:
	if j == 0:
		ans.append(l)
		l += 1
	else:
		ans.append(r)
		r -= 1
	j ^= 1
print(*ans)


import os
import sys
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz/'
M = 10 ** 9 + 7
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
n = Int()
low = 1
high = n
while low < high:
	print(low, high, end=' ')
	low += 1
	high -= 1
if low == high:
	print(low)


n = int(input())
for i in range(n):
	print(n - i // 2 if i % 2 else i // 2 + 1, end=' ')


n = int(input())
t = [0] * n
t[0] = 1
for i in range(1, n):
	t[i] = t[i - 1] + (n - i if i & 1 else i - n)
print(' '.join(map(str, t)))


n = int(input())
x = []
for i in range((n + 1) // 2):
	x.append(i + 1)
	x.append(n - i)
if n % 2 == 1:
	print(*x[:n], sep=' ')
else:
	print(*x, sep=' ')


import sys
n = int(input())
ans = [0 for _ in range(n)]
iter = 0
for i in range(0, n - 1, 2):
	ans[i] = iter + 1
	ans[i + 1] = n - iter
	iter = iter + 1
if n % 2:
	ans[n - 1] = n // 2 + 1
for i in ans:
	sys.stdout.write(str(i) + ' ')
print()


def frog(n):
	if n == 1:
		return 1
	ans = [1]
	cnt = [0] * (n + 1)
	curr = 1
	up = n
	low = 2
	while True:
		if cnt[abs(up - curr)] == 0:
			cnt[abs(up - curr)] += 1
			ans.append(up)
			up -= 1
			curr = ans[-1]
		if cnt[abs(low - curr)] == 0:
			cnt[abs(low - curr)] += 1
			ans.append(low)
			low += 1
			curr = ans[-1]
		else:
			break
	if len(ans) >= 2 and ans[-1] == ans[-2]:
		ans.pop(-1)
	print(*ans)
	return ''
print(frog(int(input())))


n = int(input())
a = []
c = n + 1
d = n
for i in range(n):
	if i % 2 == 0:
		c = c - d
		a.append(c)
	else:
		c = c + d
		a.append(c)
	d = d - 1
for i in range(n):
	print(a[i], end=' ')


a = int(input())
i = 1
while i <= a:
	if a != i:
		print(i, a)
	else:
		print(i)
	i += 1
	a -= 1


n = int(input())
from collections import deque
q = list(range(1, n + 1))
q = deque(q)
ans = []
for i in range(n):
	if i % 2 == 0:
		ans.append(q.popleft())
	else:
		ans.append(q.pop())
print(*ans)


N = int(input())
(L, R) = (1, N)
ind = 0
while ind < N:
	if ind & 1:
		print(R, end=' ')
		R -= 1
	else:
		print(L, end=' ')
		L += 1
	ind += 1


from sys import stdin
input = stdin.buffer.readline
n = int(input())
(k, c) = (n + 1 >> 1, 0)
while k + c > 0 and k + c <= n:
	print(k + c)
	k += c
	if c > 0:
		c += 1
	else:
		c -= 1
	c *= -1


n = int(input())
l = []
for i in range(1, n // 2 + 1):
	l += [i, n + 1 - i]
if n % 2:
	l += [n // 2 + 1]
print(*l)


def STR():
	return list(input())

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def MAP2():
	return map(float, input().split())

def LIST():
	return list(map(int, input().split()))

def STRING():
	return input()
import string
import sys
from heapq import heappop, heappush
from bisect import *
from collections import deque, Counter, defaultdict
from math import *
from itertools import permutations, accumulate
dx = [-1, 1, 0, 0]
dy = [0, 0, 1, -1]
n = INT()
if n == 2:
	print(1, 2)
	exit(0)
x = n // 2
if n % 2 == 0:
	x -= 1
arr = []
for i in range(1, x + 1):
	arr += [i, n - i]
arr2 = [n]
if n % 2 == 0:
	arr.append(n // 2)
res = arr2 + arr
print(*res)


x = int(input())
ptr1 = 1
ptr2 = x
steps = x
turn = 0
while steps > 0:
	if not turn:
		print(ptr1, end=' ')
		ptr1 += 1
		steps -= 1
		turn = not turn
	else:
		print(ptr2, end=' ')
		ptr2 -= 1
		steps -= 1
		turn = not turn


n = int(input())
a = [0] * n
i = 1
j = n
for z in range(n):
	print(i, end=' ')
	i += 1
	if i > j:
		break
	print(j, end=' ')
	j -= 1
	if i > j:
		break


N = int(input())
ans = [1]
for i in range(1, N, 1):
	if len(ans) & 1:
		ans.append(ans[len(ans) - 1] + (N - i))
	else:
		ans.append(ans[len(ans) - 1] - (N - i))
print(*ans)


n = int(input())
k1 = 1
k2 = n
ans = []
for i in range(n):
	if i % 2 == 0:
		ans.append(k1)
		k1 += 1
	else:
		ans.append(k2)
		k2 -= 1
print(*ans)


I = lambda : list(map(int, input().split()))
(n,) = I()
for i in range(1, n // 2 + 1):
	print(i, n - i + 1, end=' ')
if n % 2:
	print(n // 2 + 1)


def main():
	n = int(input())
	xx = int(n / 2)
	for i in range(1, xx + 1):
		print(i, n - i + 1)
	if n % 2 == 1:
		print(int(n / 2) + 1)
main()


n = int(input())
(x, c, s) = ((n + 1) // 2, 1, 1)
while x in range(1, n + 1):
	print(x, end=' ')
	(x, c, s) = (x + c * s, c + 1, s * -1)


n = int(input())
x = 1
y = n
while 1:
	if x > n // 2:
		if n % 2:
			print(x)
		break
	print(x, y, end=' ')
	x += 1
	y -= 1


n = int(input())
(i, j) = (1, n)
while i < j:
	print(i, j, end=' ')
	i += 1
	j -= 1
if n % 2 == 1:
	print(i)


n = int(input())
arr = []
t = 1
k = 0
for i in range(1, n + 1):
	if i % 2 == 0:
		arr.append(n - k)
		k += 1
	else:
		arr.append(t)
		t += 1
print(' '.join(map(str, arr)))


import sys
n = int(input())
for i in range((n - n % 2) // 2):
	print(i + 1, n - i, end=' ')
if n % 2:
	print(n // 2 + 1)


n = int(input())
l = 1
r = n
x = 0
ans = []
while l <= r:
	if x % 2 != 0:
		ans.append(r)
		r -= 1
	else:
		ans.append(l)
		l += 1
	x += 1
print(*ans)


n = int(input())
ans = []
z = []
for i in range(n):
	x = i + 1
	z.append(x)
par = True
y = 0
if n % 2 == 0:
	y = n / 2
else:
	par = False
	y = 1 + n // 2
for i in range(int(y)):
	ans.append(z[i])
	if not i == int(y) - 1:
		ans.append(z[-i - 1])
	elif par:
		ans.append(z[-i - 1])
print(*ans)


import math
import itertools
import collections

def getdict(n):
	d = {}
	if type(n) is list:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def rev(n):
	m = 0
	while n > 0:
		m = m * 10 + n % 10
		n = n // 10
	return m
n = ii()
ans = [1]
t = n - 1
for i in range(n - 1):
	ans.append(ans[i] + t * (-1) ** i)
	t -= 1
print(' '.join(map(str, ans)))


import sys
from array import array

def input():
	return sys.stdin.buffer.readline().decode('utf-8')
n = int(input())
if n == 1:
	print(1)
	exit()
a = [1, n]
ans = [1]
while abs(a[0] - a[1]) > 0:
	ans.append(a[1])
	if a[0] < a[1]:
		a[0] += 1
	else:
		a[0] -= 1
	(a[0], a[1]) = (a[1], a[0])
print(*ans)


n = int(input())
p = [1]
a = n - 1
b = 1
for i in range(n - 1):
	b += a
	p.append(b)
	if a < 0:
		a = -a - 1
	else:
		a = -a + 1
print(*p)


n = int(input())
l = 1
if n == 1:
	print(1)
else:
	i = 0
	while l != n:
		if i & 1:
			print(n, end=' ')
			n -= 1
		else:
			print(l, end=' ')
			l += 1
		i += 1
	print(l)


n = int(input())
for i in range(1, n + 1):
	if i < n - i + 1:
		print(i, n - i + 1)
	else:
		if n % 2 != 0:
			print(i)
		break


n = int(input())
l = [i for i in range(1, n + 1)]
i = 0
ans = []
j = len(l) - 1
while i <= j:
	if i == j:
		ans.append(l[i])
	else:
		ans.append(l[i])
		ans.append(l[j])
	i += 1
	j -= 1
print(*ans)


n = int(input())
if n == 1:
	print(1)
	exit()
(x1, x2) = (1, n)
for i in range(1, n + 1):
	if i % 2 == 1:
		print(x1, end=' ')
		x1 += 1
	else:
		print(x2, end=' ')
		x2 -= 1


n = int(input())
arr = [None] * n
low = 1
top = n
for i in range(n):
	if i % 2 == 0:
		print(low, end=' ')
		low += 1
	else:
		print(top, end=' ')
		top -= 1


n = int(input())
strs = '1 '
prev = 1
curdiff = n - 1
dicts = {}
dicts[1] = 1
for i in range(n):
	if i == 0:
		continue
	newnum = prev + curdiff
	if newnum > n or newnum in dicts:
		newnum = prev - curdiff
	dicts[newnum] = 1
	prev = newnum
	curdiff -= 1
	strs += str(newnum)
	strs += ' '
print(strs[:-1])


n = int(input())
l = 1
r = n
ans = []
while l < r:
	ans.append(str(l))
	ans.append(str(r))
	l += 1
	r -= 1
if l == r:
	ans.append(str(l))
print(' '.join(ans))


n = int(input())
j = 1
k = n
for i in range(n):
	if i % 2 == 0:
		print(j, end=' ')
		j += 1
	else:
		print(k, end=' ')
		k -= 1
print('')


n = int(input())
ls = list(range(1, n + 1))
ans = []
if n % 2 == 0:
	for i in range(n // 2):
		ans.append(ls[i])
		ans.append(ls[-i - 1])
else:
	for i in range(n // 2):
		ans.append(ls[i])
		ans.append(ls[-i - 1])
	ans.append(ls[n // 2])
print(*ans)


n = int(input())
index = [x for x in range(1, n + 1)]
ans = [0] * n
j = 0
k = n - 1
for i in range(n):
	if i % 2 == 0:
		ans[i] = index[j]
		j += 1
	else:
		ans[i] = index[k]
		k -= 1
print(*ans)


import os
import sys
from io import BytesIO, IOBase

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True
n = int(input())
f = 1
r = n
for i in range(0, n):
	if i % 2 == 0:
		print(f, end=' ')
		f += 1
	else:
		print(r, end=' ')
		r -= 1


n = int(input())
import math
for i in range(1, math.ceil(n / 2) + 1):
	print(i, end=' ')
	if n - i + 1 <= n and n - i + 1 != i:
		print(n - i + 1, end=' ')
	else:
		break


n = int(input())
x = 0
y = n + 1
for i in range(1, n + 1):
	if i % 2 != 0:
		x = x + 1
		print(x)
	else:
		y = y - 1
		print(y)


n = int(input())
a = []
s = 0
if n % 2 == 0:
	for i in range(0, n // 2):
		a.append(1 + i)
		a.append(n - i)
else:
	for i in range(0, n // 2):
		a.append(1 + i)
		a.append(n - i)
	a.append(1 + n // 2)
for i in range(len(a) - 1):
	print(a[i], end=' ')
print(a[len(a) - 1])


n = int(input())
l = list(range(1, n + 1))
a = []
start = 0
end = len(l) - 1
while len(a) < len(l):
	a.append(l[start])
	a.append(l[end])
	start = start + 1
	end = end - 1
if len(l) % 2 != 0:
	a = a[0:len(a) - 1]
print(*a)


n = int(input())
ans = [0] * n
ans[::2] = list(range(1, (n + 1) // 2 + 1))
ans[1::2] = list(range((n + 1) // 2 + 1, n + 1))[::-1]
print(*ans)


n = int(input())
left = 1
right = n
current = 0
array = []
s = ''
for i in range(n):
	if i % 2 == 1:
		array.append(right)
		right -= 1
	else:
		array.append(left)
		left += 1
s = ''
for i in range(len(array)):
	s += str(array[i]) + ' '
print(s)


from sys import stdin, setrecursionlimit, stdout
setrecursionlimit(100)
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin
from heapq import heapify, heappop, heappush, heapreplace, heappushpop
from bisect import bisect_right, bisect_left

def ii():
	return int(stdin.readline())

def fi():
	return float(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def si():
	return stdin.readline().rstrip()

def lsi():
	return list(si())
mod = 1000000007
res = ['NO', 'YES']
test = test_case = 1
while test <= test_case:
	test += 1
	n = ii()
	(l, r) = (1, n)
	ans = []
	while l <= r:
		ans.append(l)
		l += 1
		ans.append(r)
		r -= 1
	if n % 2:
		ans.pop()
	print(*ans)


n = int(input())
lo = 1
hi = n
cnt = 0
ans = []
while lo <= hi:
	if cnt % 2 == 0:
		ans.append(lo)
		lo += 1
	else:
		ans.append(hi)
		hi -= 1
	cnt += 1
print(*ans)


n = int(input())
k = 1
z = n
f = 1
while n:
	n -= 1
	if f == 1:
		print(k, end=' ')
		k += 1
		f = 0
	else:
		print(z, end=' ')
		z -= 1
		f = 1


import sys
input = sys.stdin.readline
right = int(input())
left = 1
while left < right:
	print(left, right, end=' ')
	left += 1
	right -= 1
if left == right:
	print(left)


def solve(n):
	if n == 2:
		print(1, 2)
	elif n == 1:
		print(1)
	else:
		count = 0
		for i in range(n // 2):
			temp = count
			count += 1
			print(count, n - temp, end=' ')
		if n % 2 != 0:
			print(n // 2 + 1)
n = int(input())
solve(n)


def solve():
	n = int(input())
	j = 0
	i = 1
	k = n
	s = ''
	if n % 2 == 0:
		while j < n:
			s = s + str(k) + ' ' + str(i) + ' '
			k -= 1
			i += 1
			j += 2
	else:
		while j < n - 1:
			s = s + str(k) + ' ' + str(i) + ' '
			i += 1
			k -= 1
			j += 2
		s += str(i)
	print(s)
	return
try:
	solve()
except:
	pass


n = int(input())
l = 1
r = n
for i in range(n):
	if not i & 1:
		print(l, end=' ')
		l += 1
	else:
		print(r, end=' ')
		r -= 1


n = int(input())
begin = (n + 1) // 2
current = begin
d = 0
sign = -1
plan = []
while current > 0 and current <= n:
	plan.append(str(current))
	d += 1
	sign *= -1
	current += sign * d
print(' '.join(plan))


def main():
	n = int(input())
	l = 1
	r = n
	while l < r:
		print(f'{l} {r}', end=' ')
		l += 1
		r -= 1
	else:
		if l == r:
			print(f'{l}')
main()


from __future__ import division, print_function
import math
import os
import sys
from fractions import *
from sys import *
from io import BytesIO, IOBase
from itertools import *
from collections import *
M = 10 ** 9 + 7
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def fsep():
	return map(float, inp().split())

def inpu():
	return int(inp())

def regularbracket(t):
	p = 0
	for i in t:
		if i == '(':
			p += 1
		else:
			p -= 1
		if p < 0:
			return False
	else:
		if p > 0:
			return False
		else:
			return True

def binarySearchCount(arr, n, key):
	left = 0
	right = n - 1
	count = 0
	while left <= right:
		mid = int((right + left) / 2)
		if arr[mid] <= key:
			count = mid + 1
			left = mid + 1
		else:
			right = mid - 1
	return count

def reverse1(string):
	pp = ''
	for i in string[::-1]:
		pp += i
	if pp == string:
		return True
	return False

def reverse2(list1):
	l = []
	for i in list1[::-1]:
		l.append(i)
	if l == list1:
		return True
	return False

def mex(list1):
	p = max(list1) + 1
	for i in range(len(list1)):
		if list1[i] != i:
			p = i
			break
	return p

def sumofdigits(n):
	n = str(n)
	s1 = 0
	for i in n:
		s1 += int(i)
	return s1

def perfect_square(n):
	s = math.sqrt(n)
	if s == int(s):
		return True
	return False

def roman_number(x):
	if x > 15999:
		return
	value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
	symbol = ['F', 'MF', 'M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
	roman = ''
	i = 0
	while x > 0:
		div = x // value[i]
		x = x % value[i]
		while div:
			roman += symbol[i]
			div -= 1
		i += 1
	return roman

def soretd(s):
	for i in range(1, len(s)):
		if s[i - 1] > s[i]:
			return False
	return True

def countRhombi(h, w):
	ct = 0
	for i in range(2, h + 1, 2):
		for j in range(2, w + 1, 2):
			ct += (h - i + 1) * (w - j + 1)
	return ct

def countrhombi2(h, w):
	return h * h // 4 * (w * w // 4)

def binpow(a, b):
	if b == 0:
		return 1
	else:
		res = binpow(a, b // 2)
	if b % 2 != 0:
		return res * res * a
	else:
		return res * res

def binpowmodulus(a, b, m):
	a %= m
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a = a * a % m
		b >>= 1
	return res

def coprime_to_n(n):
	result = n
	i = 2
	while i * i <= n:
		if n % i == 0:
			while n % i == 0:
				n //= i
			result -= result // i
		i += 1
	if n > 1:
		result -= result // n
	return result

def prime(x):
	if x == 1:
		return False
	else:
		for i in range(2, int(math.sqrt(x)) + 1):
			if x % i == 0:
				return False
		else:
			return True

def luckynumwithequalnumberoffourandseven(x, n, a):
	if x >= n and str(x).count('4') == str(x).count('7'):
		a.append(x)
	elif x < 1000000000000.0:
		luckynumwithequalnumberoffourandseven(x * 10 + 4, n, a)
		luckynumwithequalnumberoffourandseven(x * 10 + 7, n, a)
	return a

def luckynuber(x, n, a):
	p = set(str(x))
	if len(p) <= 2:
		a.append(x)
	if x < n:
		luckynuber(x + 1, n, a)
	return a

def interact(type, x):
	if type == 'r':
		inp = input()
		return inp.strip()
	else:
		print(x, flush=True)

def findTrailingZeros(n):
	count = 0
	while n >= 5:
		n //= 5
		count += n
	return count

def mergeSort(arr):
	if len(arr) > 1:
		mid = len(arr) // 2
		L = arr[:mid]
		R = arr[mid:]
		mergeSort(L)
		mergeSort(R)
		i = j = k = 0
		while i < len(L) and j < len(R):
			if L[i] < R[j]:
				arr[k] = L[i]
				i += 1
			else:
				arr[k] = R[j]
				j += 1
			k += 1
		while i < len(L):
			arr[k] = L[i]
			i += 1
			k += 1
		while j < len(R):
			arr[k] = R[j]
			j += 1
			k += 1
res = set()

def solven(p, l, a, b, n):
	if p > n or l > 10:
		return
	if p > 0:
		res.add(p)
	solven(p * 10 + a, l + 1, a, b, n)
	solven(p * 10 + b, l + 1, a, b, n)

def subsetsUtil(A, subset, index, d):
	print(*subset)
	s = sum(subset)
	d.append(s)
	for i in range(index, len(A)):
		subset.append(A[i])
		subsetsUtil(A, subset, i + 1, d)
		subset.pop(-1)
	return d

def subsetSums(arr, l, r, d, sum=0):
	if l > r:
		d.append(sum)
		return
	subsetSums(arr, l + 1, r, d, sum + arr[l])
	subsetSums(arr, l + 1, r, d, sum)
	return d

def print_factors(x):
	factors = []
	for i in range(1, x + 1):
		if x % i == 0:
			factors.append(i)
	return factors

def calc(X, d, ans, D):
	if len(X) == 0:
		return
	i = X.index(max(X))
	ans[D[max(X)]] = d
	Y = X[:i]
	Z = X[i + 1:]
	calc(Y, d + 1, ans, D)
	calc(Z, d + 1, ans, D)

def factorization(n, l):
	c = n
	if prime(n) == True:
		l.append(n)
		return l
	for i in range(2, c):
		if n == 1:
			break
		while n % i == 0:
			l.append(i)
			n = n // i
	return l

def good(b):
	l = []
	i = 0
	while len(b) != 0:
		if b[i] < b[len(b) - 1 - i]:
			l.append(b[i])
			b.remove(b[i])
		else:
			l.append(b[len(b) - 1 - i])
			b.remove(b[len(b) - 1 - i])
	if l == sorted(l):
		return True
	return False

def generate(st, s):
	if len(s) == 0:
		return
	if s not in st:
		st.add(s)
		for i in range(len(s)):
			t = list(s).copy()
			t.remove(s[i])
			t = ''.join(t)
			generate(st, t)
	return

def main():
	n = inpu()
	l = []
	for i in range(n):
		if len(l) >= n:
			break
		l.append(i + 1)
		if len(l) >= n:
			break
		l.append(n - i)
		if len(l) >= n:
			break
	print(*l)
main()


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect, insort
from time import perf_counter
from fractions import Fraction
import copy
from copy import deepcopy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass

def pmat(A):
	for ele in A:
		print(*ele, end='\n')
n = L()[0]
A = [i for i in range(1, n + 1)]
i = 0
j = n - 1
for k in range(n):
	if k % 2 == 0:
		print(A[i], end=' ')
		i += 1
	else:
		print(A[j], end=' ')
		j -= 1
print()
endtime = time.time()


n = int(input())
res = []
sign = 1
current = 0
for i in range(n):
	current = current + (n - i) * sign
	res.append(str(current))
	sign *= -1
print(' '.join(res))


from collections import Counter
n = int(input())
curr = 1
dirc = 1
print(curr, end=' ')
for jump in range(n - 1, 0, -1):
	curr = curr + dirc * jump
	print(curr, end=' ')
	dirc *= -1


import sys
N = int(input())
id = 0
ans = [0 for _ in range(N)]
for i in range(0, N - 1, 2):
	ans[i] = id + 1
	ans[i + 1] = N - id
	id = id + 1
if N % 2 == 1:
	ans[N - 1] = N // 2 + 1
for i in ans:
	sys.stdout.write(str(i) + ' ')
print()


import sys
import math
n = int(sys.stdin.readline())
v = []
x = 1
y = n
for i in range(n):
	if i % 2 == 0:
		v.append(str(x))
		x += 1
	else:
		v.append(str(y))
		y -= 1
print(' '.join(v))


(l, r) = (1, int(input()))
while l < r:
	print(l, r, end=' ')
	l += 1
	r -= 1
if l == r:
	print(l)


n = int(input())
i = 1
j = n
t = True
while i <= j:
	if t:
		print(i, end=' ')
		i = i + 1
	else:
		print(j, end=' ')
		j = j - 1
	t = not t


n = int(input())
(i, j) = (1, n)
while i <= j:
	if i < j:
		print(i, j, end=' ')
	else:
		print(i, end=' ')
	i += 1
	j -= 1


from math import *
import sys
input = sys.stdin.readline
global flag

def inp():
	return int(input())

def st():
	return input().rstrip('\n')

def lis():
	return list(map(int, input().split()))

def ma():
	return map(int, input().split())
t = 1

def pos(su, le):
	if su >= 0 and su <= 9 * le:
		return 1
	return 0
while t:
	t -= 1
	n = inp()
	i = 1
	j = n
	while i <= j:
		print(i, end=' ')
		i += 1
		if i > j:
			break
		print(j, end=' ')
		j -= 1


(l, r) = map(int, [1] + input().split())
while r - l > 0:
	print(l, r, end=' ')
	l += 1
	r -= 1
if l == r:
	print(l)


import sys
from math import log2, floor, ceil, sqrt
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
n = int(ri())
l = 1
r = n
if n == 1:
	print(1)
else:
	arr = [l, r]
	turn = 0
	l += 1
	r -= 1
	while l <= r:
		if turn == 1:
			arr.append(r)
			r -= 1
		else:
			arr.append(l)
			l += 1
		turn ^= 1
	print(*arr)


n = int(input())
res = []
isLeft = True
for _ in range(n):
	if isLeft:
		res.append(_ // 2 + 1)
		isLeft = False
	else:
		res.append(n - _ // 2)
		isLeft = True
print(*res)


n = int(input())
arr = []
for i in range(1, n + 1):
	arr.append(i)
l = 0
r = n - 1
t = 1
while l <= r:
	if t % 2 == 1:
		t += 1
		print(arr[l], end=' ')
		l += 1
	else:
		t += 1
		print(arr[r], end=' ')
		r -= 1


import time, math as mt, bisect as bs, sys
from sys import stdin, stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
pi = 3.141592653589793

def II():
	return int(stdin.readline())

def IO():
	return stdin.readline()

def IP():
	return map(int, stdin.readline().split())

def L():
	return list(map(int, stdin.readline().split()))

def P(x):
	return stdout.write(str(x) + '\n')

def PI(x, y):
	return stdout.write(str(x) + ' ' + str(y) + '\n')

def lcm(a, b):
	return a * b // gcd(a, b)

def gcd(a, b):
	if a == 0:
		return b
	elif b == 0:
		return a
	if a > b:
		return gcd(a % b, b)
	else:
		return gcd(a, b % a)

def readTree():
	v = int(input())
	adj = [set() for i in range(v + 1)]
	for i in range(v - 1):
		(u1, u2) = In()
		adj[u1].add(u2)
		adj[u2].add(u1)
	return (adj, v)

def bfs(adj, v):
	visited = [False] * (v + 1)
	q = deque()
	while q:
		pass

def sieve():
	li = [True] * 1000001
	(li[0], li[1]) = (False, False)
	for i in range(2, len(li), 1):
		if li[i] == True:
			for j in range(i * i, len(li), i):
				li[j] = False
	prime = []
	for i in range(1000001):
		if li[i] == True:
			prime.append(i)
	return prime

def setBit(n):
	count = 0
	while n != 0:
		n = n & n - 1
		count += 1
	return count
mx = 10 ** 7
spf = [mx] * (mx + 1)

def SPF():
	spf[1] = 1
	for i in range(2, mx + 1):
		if spf[i] == mx:
			spf[i] = i
			for j in range(i * i, mx + 1, i):
				if i < spf[j]:
					spf[j] = i
	return
mod = 10 ** 9 + 7

def solve():
	n = II()
	diff = n - 1
	curr = 1
	print(curr, end=' ')
	while abs(diff) >= 1:
		curr += diff
		print(curr, end=' ')
		if diff > 0:
			diff = -1 * (abs(diff) - 1)
		else:
			diff = abs(diff) - 1
	return
t = 1
for i in range(t):
	solve()