output_description: Print n integers in a line with spaces in between. The i-th integer should be
  b_i.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      n
      a_1 a_2 ... a_n
attempt: # -*- coding: utf-8 -*-
  
  #############
  # Libraries #
  #############
  
  import sys
  input = sys.stdin.readline
  
  import math
  #from math import gcd
  import bisect
  from collections import defaultdict
  from collections import deque
  from functools import lru_cache
  
  
  #############
  # Constants #
  #############
  
  MOD = 10**9+7
  INF = float('inf')
  
  #############
  # Functions #
  #############
  
  ######INPUT######
  def I(): return int(input().strip())
  def S(): return input().strip()
  def IL(): return list(map(int,input().split()))
  def SL(): return list(map(str,input().split()))
  def ILs(n): return list(int(input()) for _ in range(n))
  def SLs(n): return list(input().strip() for _ in range(n))
  def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
  def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
  
  ######OUTPUT######
  def P(arg): print(arg); return
  def Y(): print("Yes"); return
  def N(): print("No"); return
  def E(): exit()
  def PE(arg): print(arg); exit()
  def YE(): print("Yes"); exit()
  def NE(): print("No"); exit()
  
  #####Shorten#####
  def DD(arg): return defaultdict(arg)
  
  
  #####Inverse#####
  def inv(n): return pow(n, MOD-2, MOD)
  
  ######Combination######
  kaijo_memo = []
  def kaijo(n):
    if(len(kaijo_memo) > n):
      return kaijo_memo[n]
    if(len(kaijo_memo) == 0):
      kaijo_memo.append(1)
    while(len(kaijo_memo) <= n):
      kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
    return kaijo_memo[n]
  
  gyaku_kaijo_memo = []
  def gyaku_kaijo(n):
    if(len(gyaku_kaijo_memo) > n):
      return gyaku_kaijo_memo[n]
    if(len(gyaku_kaijo_memo) == 0):
      gyaku_kaijo_memo.append(1)
    while(len(gyaku_kaijo_memo) <= n):
      gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
    return gyaku_kaijo_memo[n]
  
  def nCr(n,r):
    if(n == r):
      return 1
    if(n < r or r < 0):
      return 0
    ret = 1
    ret = ret * kaijo(n) % MOD
    ret = ret * gyaku_kaijo(r) % MOD
    ret = ret * gyaku_kaijo(n-r) % MOD
    return ret
  
  ######Factorization######
  def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
      if temp%i==0:
        cnt=0
        while temp%i==0: 
          cnt+=1 
          temp //= i
        arr.append([i, cnt])
    if temp!=1:
      arr.append([temp, 1])
    if arr==[]:
      arr.append([n, 1])
    return arr
  
  #####MakeDivisors######
  def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
      if n % i == 0:
        divisors.append(i)
        if i != n // i: 
          divisors.append(n//i)
    return divisors
  
  #####GCD#####
  def gcd(a, b):
      while b:
          a, b = b, a % b
      return a
  
  #####LCM#####
  def lcm(a, b):
      return a * b // gcd (a, b)
  
  #####BitCount#####
  def count_bit(n):
    count = 0
    while n:
      n &= n -1
      count += 1
    return count
  
  #####ChangeBase#####
  def base_10_to_n(X, n):
    if X//n:
      return base_10_to_n(X//n, n)+[X%n]
    return [X%n]
  
  def base_n_to_10(X, n):
    return sum(int(str(X)[-i])*n**i for i in range(len(str(X))))
  
  #####IntLog#####
  def int_log(n, a):
    count = 0
    while n>=a:
      n = n//a
      count += 1
    if a**count == n:
      return count
    else:
      return count+1
  
  #############
  # Main Code #
  #############
  
  N = I()
  A = IL()
  
  iti = A[::2]
  ni = A[1::2]
  
  if N % 2:
    print(*((ni[::-1]+iti)[::-1]),sep=" ")
  else:
  print(*(ni[::-1]+iti),sep=" ")
  
problem_description: Statement
  
  You are given an integer sequence of length n, a_1, ..., a_n. Let us consider
  performing the following n operations on an empty sequence b.
  
  The i-th operation is as follows:
  
    1. Append a_i to the end of b.
    2. Reverse the order of the elements in b.
  
  Find the sequence b obtained after these n operations.
samples: [{"input": "4\n    1 2 3 4", "output": "4 2 1 3\n    \n\n  * After step 1 of the first operation, b becomes: 1.\n  * After step 2 of the first operation, b becomes: 1.\n  * After step 1 of the second operation, b becomes: 1, 2.\n  * After step 2 of the second operation, b becomes: 2, 1.\n  * After step 1 of the third operation, b becomes: 2, 1, 3.\n  * After step 2 of the third operation, b becomes: 3, 1, 2.\n  * After step 1 of the fourth operation, b becomes: 3, 1, 2, 4.\n  * After step 2 of the fourth operation, b becomes: 4, 2, 1, 3.\n\nThus, the answer is `4 2 1 3`.\n\n* * *"}, {"input": "3\n    1 2 3", "output": "3 1 2\n    \n\nAs shown above in Sample Output 1, b becomes 3, 1, 2 after step 2 of the third\noperation. Thus, the answer is `3 1 2`.\n\n* * *"}, {"input": "1\n    1000000000", "output": "1000000000\n    \n\n* * *"}, {"input": "6\n    0 6 7 6 7 0", "output": "0 6 6 0 7 7"}]