Problem:
Score : 300 points

Problem 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:

Append a_i to the end of b.

Reverse the order of the elements in b.

Find the sequence b obtained after these n operations.

Constraints

1 \leq n \leq 2\times 10^5

0 \leq a_i \leq 10^9

n and a_i are integers.

Input

Input is given from Standard Input in the following format:

n
a_1 a_2 ... a_n

Output

Print n integers in a line with spaces in between.
The i-th integer should be b_i.

Sample Input 1

4
1 2 3 4

Sample Output 1

4 2 1 3

After step 1 of the first operation, b becomes: 1.

After step 2 of the first operation, b becomes: 1.

After step 1 of the second operation, b becomes: 1, 2.

After step 2 of the second operation, b becomes: 2, 1.

After step 1 of the third operation, b becomes: 2, 1, 3.

After step 2 of the third operation, b becomes: 3, 1, 2.

After step 1 of the fourth operation, b becomes: 3, 1, 2, 4.

After step 2 of the fourth operation, b becomes: 4, 2, 1, 3.

Thus, the answer is 4 2 1 3.

Sample Input 2

3
1 2 3

Sample Output 2

3 1 2

As shown above in Sample Output 1, b becomes 3, 1, 2 after step 2 of the third operation. Thus, the answer is 3 1 2.

Sample Input 3

1
1000000000

Sample Output 3

1000000000

Sample Input 4

6
0 6 7 6 7 0

Sample Output 4

0 6 6 0 7 7

Solution in C (GCC 5.4.1) (judge verdict: Runtime Error)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct double_end_queue *deque;
typedef struct element
{
    long number;
} ElementType;
struct double_end_queue
{
    ElementType item;
    deque front;
    deque rear;
};
typedef struct control
{
    deque head;
    deque tail;
}* deque_con;
deque_con create_deque(deque_con p)
{
    printf("head:%p\ntail:%p\n",p->head,p->tail);
    do{
            p->head=(deque)malloc(sizeof(struct double_end_queue));
    }while(p->head==NULL);
    printf("head:%p\ntail:%p\n",p->head,p->tail);
    do
    {
        p->tail=(deque)malloc(sizeof(struct double_end_queue));
    }while(p->tail==NULL);
    printf("head:%p\ntail:%p\n",p->head,p->tail);
    p->head->rear=p->tail;
    p->tail->front=p->head;
    p->head->front=p->tail->rear=NULL;
    return p;
}
int IsEmpty(deque_con s)
{
    if(s->head->rear==s->tail)
        return 1;
    else return 0;
}
deque_con Enter_deque(deque_con dq,ElementType item)
{
    deque new_dq=(deque)malloc(sizeof(struct double_end_queue));
    new_dq->item=item;
    new_dq->front=dq->tail->front;
    new_dq->rear=NULL;
    dq->tail->front=new_dq;
    return dq;
}
ElementType Out_stack(deque_con dq)
{
    ElementType temp;
    deque p,t;
    if(dq->head->rear==dq->tail)
    {
        temp.number=-1;
        return temp;
    }
    t=p=dq->tail->front;
    t=t->front;
    t->rear=dq->tail;
    dq->tail->front=t;
    temp=p->item;
    free(p);
    return temp;
}
long number[200000];
void deal()
{
    int i,n;
    ElementType temp;
    deque_con v_1,v_2,result;
    v_1=create_deque(v_1);
    v_2=create_deque(v_2);
    while(scanf("%d",&n)!=EOF)
    {
        for(i=0; i<n; i++)
        {
            scanf("%ld",&temp.number);
            if(!IsEmpty(v_1))
                v_1=Enter_deque(v_1,temp);
            else
                v_2=Enter_deque(v_2,temp);
            //·­×ª¹ý³Ì
            if(!IsEmpty(v_1))
            {
                while(!IsEmpty(v_1))
                {
                    temp=Out_stack(v_1);
                    v_2=Enter_deque(v_2,temp);
                }
            }
            else
            {
                while(!IsEmpty(v_2))
                {
                    temp=Out_stack(v_2);
                    v_1=Enter_deque(v_1,temp);
                }
            }
        }
    }
    if(!IsEmpty(v_1))
    {
        result=v_1;
    }else result=v_2;
    for(i=0;i<n;i++)
    {
        temp=Out_stack(result);
        number[i]=temp.number;
    }
    for(i=n;i>=0;i--)
    {
        printf("%ld ",number[i]);
    }
}
int main()
{
    deal();
    return 0;
}