#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int n, k, i;
  int m[1000];
  int x[40];
  int s[20];
  scanf("%d", &n);
  if (n == 1) {
    i = 0;
    do {
      scanf("%d", &m[i]);
      i++;
    } while (m[i - 1] % 2 == 0);
    printf("\n%d", m[i - 1]);
  } else {
    k = 0;
    do {
      i = 0;
      do {
        scanf("%d", &m[i]);
        i++;
      } while (m[i - 1] % 2 == 0);
      s[k] = m[i - 1];
      k++;
    } while (k != n);
    if (n % 2 != 0) {
      for (i = 0; k - i > 2; i++, k--) {
        x[i] = s[i] - s[k - 1];
        printf("\n%d", x[i]);
      }
      x[i] = s[k - i];
      printf("\n%d", x[i]);
    } else {
      for (i = 0; k - i > 0; i++, k--) {
        x[i] = s[i] - s[k - 1];
        printf("\n%d", x[i]);
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10a0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec8(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
cmpl   $0x1,-0x8(%rbp)
jne    11ba <main+0x9a>
movl   $0x0,-0x10(%rbp)
movslq -0x10(%rbp),%rax
lea    -0xfb0(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe95(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xfb0(%rbp,%rax,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1153 <main+0x33>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xfb0(%rbp,%rax,4),%esi
lea    0xe50(%rip),%rdi
call   1030 <printf@plt>
jmp    1364 <main+0x244>
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movslq -0x10(%rbp),%rax
lea    -0xfb0(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe20(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xfb0(%rbp,%rax,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11c8 <main+0xa8>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xfb0(%rbp,%rax,4),%ecx
movslq -0xc(%rbp),%rax
mov    %ecx,-0x10a0(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    11c1 <main+0xa1>
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     12f1 <main+0x1d1>
movl   $0x0,-0x10(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
cmp    $0x2,%eax
jle    12bb <main+0x19b>
movslq -0x10(%rbp),%rax
mov    -0x10a0(%rbp,%rax,4),%ecx
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
cltq
sub    -0x10a0(%rbp,%rax,4),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x1050(%rbp,%rax,4)
movslq -0x10(%rbp),%rax
mov    -0x1050(%rbp,%rax,4),%esi
lea    0xd61(%rip),%rdi
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1259 <main+0x139>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
cltq
mov    -0x10a0(%rbp,%rax,4),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x1050(%rbp,%rax,4)
movslq -0x10(%rbp),%rax
mov    -0x1050(%rbp,%rax,4),%esi
lea    0xd19(%rip),%rdi
call   1030 <printf@plt>
jmp    135f <main+0x23f>
movl   $0x0,-0x10(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
cmp    $0x0,%eax
jle    135a <main+0x23a>
movslq -0x10(%rbp),%rax
mov    -0x10a0(%rbp,%rax,4),%ecx
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
cltq
sub    -0x10a0(%rbp,%rax,4),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x1050(%rbp,%rax,4)
movslq -0x10(%rbp),%rax
mov    -0x1050(%rbp,%rax,4),%esi
lea    0xcc2(%rip),%rdi
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    12f8 <main+0x1d8>
jmp    135f <main+0x23f>
jmp    1364 <main+0x244>
xor    %eax,%eax
add    $0x10a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x1000,%rsp
lea    0xecb(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1040 <scanf@plt>
cmpl   $0x1,0xc(%rsp)
jne    117c <main+0x5c>
lea    0x60(%rsp),%rbx
lea    0xeae(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <scanf@plt>
mov    (%rbx),%esi
add    $0x4,%rbx
test   $0x1,%sil
je     1160 <main+0x40>
jmp    1261 <main+0x141>
mov    $0x1,%ecx
xor    %eax,%eax
lea    0x60(%rsp),%rbp
lea    0xe72(%rip),%r14
nop
mov    %rax,%r12
mov    %ecx,%r15d
mov    %rbp,%rbx
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <scanf@plt>
mov    (%rbx),%eax
add    $0x4,%rbx
test   $0x1,%al
je     11a0 <main+0x80>
mov    %eax,0x10(%rsp,%r12,4)
lea    0x1(%r12),%rax
mov    0xc(%rsp),%edx
lea    0x1(%r15),%ecx
cmp    %rdx,%rax
jne    1190 <main+0x70>
test   $0x1,%dl
jne    1202 <main+0xe2>
movslq %eax,%rbp
mov    $0x1,%ebx
lea    0xe20(%rip),%r14
mov    0xc(%rsp,%rbx,4),%esi
sub    0xc(%rsp,%rbp,4),%esi
add    $0xffffffffffffffff,%rbp
mov    %r14,%rdi
call   1030 <printf@plt>
lea    0x1(%rbx),%rax
cmp    %rbx,%rbp
mov    %rax,%rbx
jg     11e0 <main+0xc0>
jmp    126d <main+0x14d>
test   $0xfffffffe,%r12d
je     125b <main+0x13b>
movslq %eax,%r12
movslq %r15d,%rax
lea    (%rsp,%rax,4),%r15
add    $0xc,%r15
xor    %ebp,%ebp
lea    0x10(%rsp),%rbx
lea    0xdd9(%rip),%r14
nopw   0x0(%rax,%rax,1)
mov    (%rbx),%esi
add    $0xffffffffffffffff,%r12
sub    (%r15),%esi
mov    %r14,%rdi
call   1030 <printf@plt>
add    $0x1,%ebp
movslq %ebp,%rcx
mov    %r12,%rax
sub    %rcx,%rax
add    $0xfffffffffffffffc,%r15
add    $0x4,%rbx
cmp    $0x2,%rax
jg     1230 <main+0x110>
cltq
mov    0x10(%rsp,%rax,4),%esi
lea    0xd98(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1000,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [4 x i8] c"\0A%d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [1000 x i32]
%6 = alloca [40 x i32]
%7 = alloca [20 x i32]
store i32 0, i32* %1
%8 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
%9 = load i32, i32* %2
%10 = icmp eq i32 %9, 1
br i1 %10, label %11, label %34
11: ; preds = %0
store i32 0, i32* %4
br label %12
12: ; preds = %19, %11
%13 = load i32, i32* %4
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds [1000 x i32], [1000 x i32]* %5, i64 0, i64 %14
%16 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %15)
%17 = load i32, i32* %4
%18 = add nsw i32 %17, 1
store i32 %18, i32* %4
br label %19
19: ; preds = %12
%20 = load i32, i32* %4
%21 = sub nsw i32 %20, 1
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds [1000 x i32], [1000 x i32]* %5, i64 0, i64 %22
%24 = load i32, i32* %23
%25 = srem i32 %24, 2
%26 = icmp eq i32 %25, 0
br i1 %26, label %12, label %27
27: ; preds = %19
%28 = load i32, i32* %4
%29 = sub nsw i32 %28, 1
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [1000 x i32], [1000 x i32]* %5, i64 0, i64 %30
%32 = load i32, i32* %31
%33 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %32)
br label %147
34: ; preds = %0
store i32 0, i32* %3
br label %35
35: ; preds = %62, %34
store i32 0, i32* %4
br label %36
36: ; preds = %43, %35
%37 = load i32, i32* %4
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [1000 x i32], [1000 x i32]* %5, i64 0, i64 %38
%40 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %39)
%41 = load i32, i32* %4
%42 = add nsw i32 %41, 1
store i32 %42, i32* %4
br label %43
43: ; preds = %36
%44 = load i32, i32* %4
%45 = sub nsw i32 %44, 1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [1000 x i32], [1000 x i32]* %5, i64 0, i64 %46
%48 = load i32, i32* %47
%49 = srem i32 %48, 2
%50 = icmp eq i32 %49, 0
br i1 %50, label %36, label %51
51: ; preds = %43
%52 = load i32, i32* %4
%53 = sub nsw i32 %52, 1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [1000 x i32], [1000 x i32]* %5, i64 0, i64 %54
%56 = load i32, i32* %55
%57 = load i32, i32* %3
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [20 x i32], [20 x i32]* %7, i64 0, i64 %58
store i32 %56, i32* %59
%60 = load i32, i32* %3
%61 = add nsw i32 %60, 1
store i32 %61, i32* %3
br label %62
62: ; preds = %51
%63 = load i32, i32* %3
%64 = load i32, i32* %2
%65 = icmp ne i32 %63, %64
br i1 %65, label %35, label %66
66: ; preds = %62
%67 = load i32, i32* %2
%68 = srem i32 %67, 2
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %115
70: ; preds = %66
store i32 0, i32* %4
br label %71
71: ; preds = %95, %70
%72 = load i32, i32* %3
%73 = load i32, i32* %4
%74 = sub nsw i32 %72, %73
%75 = icmp sgt i32 %74, 2
br i1 %75, label %76, label %100
76: ; preds = %71
%77 = load i32, i32* %4
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [20 x i32], [20 x i32]* %7, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = load i32, i32* %3
%82 = sub nsw i32 %81, 1
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [20 x i32], [20 x i32]* %7, i64 0, i64 %83
%85 = load i32, i32* %84
%86 = sub nsw i32 %80, %85
%87 = load i32, i32* %4
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 %88
store i32 %86, i32* %89
%90 = load i32, i32* %4
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 %91
%93 = load i32, i32* %92
%94 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %93)
br label %95
95: ; preds = %76
%96 = load i32, i32* %4
%97 = add nsw i32 %96, 1
store i32 %97, i32* %4
%98 = load i32, i32* %3
%99 = add nsw i32 %98, -1
store i32 %99, i32* %3
br label %71
100: ; preds = %71
%101 = load i32, i32* %3
%102 = load i32, i32* %4
%103 = sub nsw i32 %101, %102
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [20 x i32], [20 x i32]* %7, i64 0, i64 %104
%106 = load i32, i32* %105
%107 = load i32, i32* %4
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 %108
store i32 %106, i32* %109
%110 = load i32, i32* %4
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 %111
%113 = load i32, i32* %112
%114 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %113)
br label %146
115: ; preds = %66
store i32 0, i32* %4
br label %116
116: ; preds = %140, %115
%117 = load i32, i32* %3
%118 = load i32, i32* %4
%119 = sub nsw i32 %117, %118
%120 = icmp sgt i32 %119, 0
br i1 %120, label %121, label %145
121: ; preds = %116
%122 = load i32, i32* %4
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [20 x i32], [20 x i32]* %7, i64 0, i64 %123
%125 = load i32, i32* %124
%126 = load i32, i32* %3
%127 = sub nsw i32 %126, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [20 x i32], [20 x i32]* %7, i64 0, i64 %128
%130 = load i32, i32* %129
%131 = sub nsw i32 %125, %130
%132 = load i32, i32* %4
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 %133
store i32 %131, i32* %134
%135 = load i32, i32* %4
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [40 x i32], [40 x i32]* %6, i64 0, i64 %136
%138 = load i32, i32* %137
%139 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %138)
br label %140
140: ; preds = %121
%141 = load i32, i32* %4
%142 = add nsw i32 %141, 1
store i32 %142, i32* %4
%143 = load i32, i32* %3
%144 = add nsw i32 %143, -1
store i32 %144, i32* %3
br label %116
145: ; preds = %116
br label %146
146: ; preds = %145, %100
br label %147
147: ; preds = %146, %27
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [4 x i8] c"\0A%d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [1000 x i32]
%3 = alloca [20 x i32]
%4 = bitcast i32* %1 to i8*
%5 = bitcast [1000 x i32]* %2 to i8*
%6 = bitcast [20 x i32]* %3 to i8*
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%8 = load i32, i32* %1
%9 = icmp eq i32 %8, 1
br i1 %9, label %10, label %18
10: ; preds = %0, %10
%11 = phi i64 [ %14, %10 ], [ 0, %0 ]
%12 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 %11
%13 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %12)
%14 = add nuw i64 %11, 1
%15 = load i32, i32* %12
%16 = and i32 %15, 1
%17 = icmp eq i32 %16, 0
br i1 %17, label %10, label %79
18: ; preds = %0, %28
%19 = phi i64 [ %30, %28 ], [ 0, %0 ]
br label %20
20: ; preds = %20, %18
%21 = phi i64 [ %24, %20 ], [ 0, %18 ]
%22 = getelementptr inbounds [1000 x i32], [1000 x i32]* %2, i64 0, i64 %21
%23 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %22)
%24 = add nuw i64 %21, 1
%25 = load i32, i32* %22
%26 = and i32 %25, 1
%27 = icmp eq i32 %26, 0
br i1 %27, label %20, label %28
28: ; preds = %20
%29 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %19
store i32 %25, i32* %29
%30 = add nuw i64 %19, 1
%31 = load i32, i32* %1
%32 = zext i32 %31 to i64
%33 = icmp eq i64 %30, %32
br i1 %33, label %34, label %18
34: ; preds = %28
%35 = and i32 %31, 1
%36 = icmp eq i32 %35, 0
br i1 %36, label %37, label %40
37: ; preds = %34
%38 = shl i64 %30, 32
%39 = ashr exact i64 %38, 32
br label %67
40: ; preds = %34
%41 = and i64 %19, 4294967294
%42 = icmp eq i64 %41, 0
br i1 %42, label %61, label %43
43: ; preds = %40
%44 = shl i64 %30, 32
%45 = ashr exact i64 %44, 32
br label %46
46: ; preds = %43, %46
%47 = phi i64 [ %45, %43 ], [ %51, %46 ]
%48 = phi i64 [ 0, %43 ], [ %56, %46 ]
%49 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %48
%50 = load i32, i32* %49
%51 = add nsw i64 %47, -1
%52 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %51
%53 = load i32, i32* %52
%54 = sub nsw i32 %50, %53
%55 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %54)
%56 = add nuw nsw i64 %48, 1
%57 = shl i64 %56, 32
%58 = ashr exact i64 %57, 32
%59 = sub nsw i64 %51, %58
%60 = icmp sgt i64 %59, 2
br i1 %60, label %46, label %61
61: ; preds = %46, %40
%62 = phi i64 [ %30, %40 ], [ %59, %46 ]
%63 = shl i64 %62, 32
%64 = ashr exact i64 %63, 32
%65 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %64
%66 = load i32, i32* %65
br label %79
67: ; preds = %37, %67
%68 = phi i64 [ %39, %37 ], [ %72, %67 ]
%69 = phi i64 [ 0, %37 ], [ %77, %67 ]
%70 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = add nsw i64 %68, -1
%73 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %72
%74 = load i32, i32* %73
%75 = sub nsw i32 %71, %74
%76 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %75)
%77 = add nuw nsw i64 %69, 1
%78 = icmp sgt i64 %72, %77
br i1 %78, label %67, label %82
79: ; preds = %10, %61
%80 = phi i32 [ %66, %61 ], [ %15, %10 ]
%81 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %80)
br label %82
82: ; preds = %67, %79
ret i32 0
}