Harryxun/sft_time huggingface dataset:
### BUGGY CODE ###

import sys 

N = int(input())
A = list(map(int, input().split()))


if N == 1:
    print(A[0])
    sys.exit()

mae = []
usiro = []

#0の時に前 1の時に後ろ
Flag = 0

for i in reversed(range(0,N,1)):
    
    if Flag == 0: # 前の時
        mae.append(str(A[i]))
        mae.append(" ")
        Flag = 1
    else:
        usiro.insert(0,str(A[i]))
        usiro.insert(0,str(" "))
        Flag = 0

moziretu = (mae + usiro)
#del moziretu[((len(moziretu))//2)]
moziretu = ''.join(moziretu)
print(moziretu)
  
  




### FIXED CODE ###

import sys 
from collections import deque
N = int(input())
A = list(map(int, input().split()))


if N == 1:
    print(A[0])
    sys.exit()

mae = deque()
usiro = deque()

#0の時に前 1の時に後ろ
Flag = 0

for i in reversed(range(0,N,1)):
    
    if Flag == 0: # 前の時
        mae.append(str(A[i]))
        mae.append(" ")
        Flag = 1
    else:
        usiro.insert(0,str(A[i]))
        usiro.appendleft(" ")
        Flag = 0

moziretu = (mae + usiro)
del moziretu[((len(moziretu))//2)]
moziretu = ''.join(moziretu)
print(moziretu)
### BUGGY CODE ###

R,G,B,N=map(int,input().split())

tmp=0
for i in range(N//R+1):
  for j in range((N-R*i)//G+1):
    if (R*i+G*j)<=N and (N-(R*i+G*j))%B==0:
      tmp+=1
print(tmp)

### FIXED CODE ###

R,G,B,N=map(int,input().split())

tmp=0
for i in range(N//R+1):
  for j in range((N-R*i)//G+1):
    if (N-(R*i+G*j))%B==0:
      tmp+=1
print(tmp)
### BUGGY CODE ###

N = int(input())
S = input()
temp_min =10**15
for i in range(1,N):
    temp = S[0:i-1]
    temp2 = S[i:N]
    temp3 = temp.count("W")+temp2.count("E")
    if temp_min > temp3:
        temp_min = temp3
print(temp_min)

### FIXED CODE ###

N = int(input())
S = input()

count_E = S[1:].count("E")
ans = count_E
for i in range(1,N):
    if S[i-1] == "W":
        count_E += 1
    if S[i] == "E":
        count_E -= 1
    if ans >count_E:
        ans = count_E
print(ans)
### BUGGY CODE ###

from math import gcd
def INT(): return int(input())

 
K = INT()
sum = 0
 
for n in range(K):
  for m in range(K):
    for l in range(K):
      sum += gcd(n+1, gcd(m+1, l+1))
 
print(sum)

### FIXED CODE ###

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
 
K = INT()
sum = 0
 
for n in range(K):
  for m in range(K):
    for l in range(K):
      sum += gcd(n+1, gcd(m+1, l+1))
 
print(sum)
### BUGGY CODE ###

n=int(input())
c=[]
for _ in range(n):
    a=int(input())
    c.append(a)
cb=set(c)
ca=[]
for item in cb:
    if c.count(item) % 2 == 1:
        ca.append(item)
print(len(ca))

### FIXED CODE ###

import collections
n=int(input())
a=[int(input()) for _ in range(n)]
c = collections.Counter(a)
ans=0
for k,v in c.items():
    if v % 2 != 0:
        ans += 1
print(ans)
### BUGGY CODE ###

n=int(input())
L=list(map(int,input().split()))
L.sort(reverse = True)
ans = 0
for i in range(n):
    for j in range(i+1,n):
        cnt = 0
        start=j+1
        goal=n
        while goal!=start:
            half = (start + goal)//2
            if L[i] < L[j] + L[half]:
                start = half + 1
                cnt = max(half-j,cnt)
            else:
                goal = half
        ans += cnt
print(ans)

### FIXED CODE ###

n=int(input())
L=list(map(int,input().split()))
L.sort(reverse = True)
ans = 0
for i in range(n):
    for j in range(i+1,n):
        cnt = 0
        start=j+1
        goal=n
        while goal!=start:
            half = (start + goal)//2
            if L[i] < L[j] + L[half]:
                start = half + 1
                cnt = max(half-j,cnt)
            else:
                goal = half
        ans += cnt
print(ans)
### BUGGY CODE ###

n = int(input())
p = 10**9 + 7
dp=[[[0]*(2) for i in range(2)] for i in range(n+1)]
dp[0][0][0]=1

for i in range(n):
  dp[i+1][1][1] += (dp[i][1][1] * 10 + dp[i][0][1]+ dp[i][1][0])
  dp[i+1][1][1] %= p
  dp[i+1][1][0] += (dp[i][1][0] * 9 + dp[i][0][0])
  dp[i+1][1][0] %= p
  dp[i+1][0][1] += (dp[i][0][1] * 9 + dp[i][0][0])
  dp[i+1][0][1] %= p
  dp[i+1][0][0] += (dp[i][0][0] * 8)
  dp[i+1][0][0] %= p
print(dp[n][1][1])

### FIXED CODE ###

n = int(input())
p = 10**9 + 7
dp=[[0]*(2) for i in range(2)]
dp[0][0]=1

for i in range(n):
  nextDP = [[0]*(2) for i in range(2)]
  nextDP[1][1] += (dp[0][1] + dp[1][0] + dp[1][1] * 10) % p
  nextDP[1][0] += (dp[1][0] * 9 + dp[0][0]) % p
  nextDP[0][1] += (dp[0][1] * 9 + dp[0][0]) % p
  nextDP[0][0] += (dp[0][0] * 8) % p
  dp = nextDP
print(dp[1][1] % p)
### BUGGY CODE ###

import sys
import numpy as np

N, M = input().split()

N = int(N)
M = int(M)

A = np.zeros([N])
A = np.array(input().split(),dtype=np.int64)

BC = np.zeros([2,M])

for i in range(M):
    BC[:,i] = input().split()

# Cの大きさでBCを並び替え
BC = BC[:,np.argsort(BC[1,:])[::-1]]

# Aを並び替え
A = np.sort(A)

for i in range(M):
    for j in range(int(BC[0,i])):
        if A[0] > BC[1,i]:
            break

        if A[0+j] <= BC[1,i]:
            A[0+j] = BC[1,i]

    A = np.sort(A)


print(np.sum(A))

### FIXED CODE ###

N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
BC = [list(map(int, input().split())) for _ in range(M)]

# n番目の要素でソートsort
BC = sorted(BC, reverse=True, key=lambda x: x[1])

m = A[0]
D = []
for b, c in BC:
    if c > m:
        _ = [D.append(c) for i in range(b)]
    else:
        continue
    if len(D) > N:
        break

D.append(0)

for i, d in enumerate(D):
    if i >= N:
        break
    if A[i] < d:
        A[i] = d
    else:
        break

print(sum(A))
### BUGGY CODE ###

N, X = map(int, input().split())
cities = [int(i) for i in input().split()]
cities.sort()
dist = [int(abs(i-X)) for i in cities]
dist.sort()

if N==1:
    print(max(dist))
else:
    m = min(dist)
    dist.remove(m)
    dist_2 = [int(i%m) for i in dist]
    dist_3 = [m]
    for l in range (len(dist_2)):
        if dist_2[l]!=0:
            dist_3.append(dist_2[l])
    D = max(dist_3)
    for i in reversed(range(1, D+1)): #最大公約数を1から順に考える
        for j in range(len(dist_3)): #全ての数を割ってみる
            if dist_3[j]%i != 0:
                flag = False
                break
            else:
                flag = True
        if flag:
            D = i
            break
    print(D)

### FIXED CODE ###

N, X = map(int, input().split())
cities = [int(i) for i in input().split()]
cities.sort()
dist = [int(abs(i-X)) for i in cities]
dist.sort()
 
if N==1:
    print(max(dist))
else:
    while len(dist)>0:
        m = min(dist)
        dist = [int(i%m) for i in dist]
        dist.sort()
        while len(dist)>0 and dist[0]==0:
            dist.remove(0)
        if len(dist)==0:
            break
        else:
            dist.append(m)
    print(m)
### BUGGY CODE ###

import sys

MOD = 998244353


class Bit:
    def __init__(self, n):
        self.size = n
        self.tree = [0] * (n + 1)

    def sum(self, i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i & -i
        return s

    def add(self, i, x):
        while i <= self.size:
            self.tree[i] += x
            i += i & -i


def main():
    input = sys.stdin.buffer.readline
    n, k = map(int, input().split())
    lr = [tuple(map(int, input().split())) for _ in range(k)]
    dp = Bit(n)
    dp.add(1, 1)
    for i in range(2, n + 1):
        for l, r in lr:
            if i - l < 1:
                continue
            if i - r < 2:
                dp.add(i, dp.sum(i - l) % MOD)
            else:
                dp.add(i, (dp.sum(i - l) - dp.sum(i - r - 1)) % MOD)
    print((dp.sum(n) - dp.sum(n - 1)) % MOD)


if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys

MOD = 998244353


class Bit:
    def __init__(self, n):
        self.size = n
        self.tree = [0] * (n + 1)

    def sum(self, i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i & -i
        return s

    def add(self, i, x):
        while i <= self.size:
            self.tree[i] += x
            i += i & -i


def main():
    input = sys.stdin.buffer.readline
    n, k = map(int, input().split())
    lr = [tuple(map(int, input().split())) for _ in range(k)]
    dp = Bit(n)
    dp.add(1, 1)
    for i in range(2, n + 1):
        for l, r in lr:
            if i - l < 1:
                continue
            if i - r < 2:
                dp.add(i, dp.sum(i - l) % MOD)
            else:
                dp.add(i, (dp.sum(i - l) - dp.sum(i - r - 1)) % MOD)
    print((dp.sum(n) - dp.sum(n - 1)) % MOD)


if __name__ == "__main__":
    main()
### BUGGY CODE ###

N = int(input())
# Nは奇数
A = [int(i) for i in input().split()]

for i in range(A[0]+1):
  answer_list = []
  answer_list.append(i)
  answer = i
  for j in A:
    if (j - answer) < 0:
      break
    answer = j - answer
    answer_list.append(answer)
  if answer_list[0] == answer_list[-1] and len(answer_list) == N+1:
    print(' '.join([str(i*2) for i in answer_list[:N]]))
    exit()

### FIXED CODE ###

N = int(input())
# Nは奇数
A = [int(i) for i in input().split()]

answer = (sum(A) - 2 * sum([A[i] for i in range(N) if i % 2 != 0])) // 2
answer_list = []
answer_list.append(answer)
for j in A:
  if (j - answer) < 0:
    break
  answer = j - answer
  answer_list.append(answer)
if answer_list[0] == answer_list[-1] and len(answer_list) == N+1:
  print(' '.join([str(i*2) for i in answer_list[:N]]))
  exit()
### BUGGY CODE ###

N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
if K >= sum(A):
  print(0)
  exit()
A.sort(reverse=True)
F.sort()
from math import gcd
def lcm(x, y):
  return (x*y)//gcd(x, y)

f_lcm = 1
for k in range(N):
  f_lcm = lcm(f_lcm, F[k])

portion = [f_lcm//F[k] for k in range(N)]


#print('A:', A)
#print('F:', F)
#print('portion:', portion)
lot = [0 for _ in range(N)]


sa = sum(A) - K
sp = sum(portion)
for k in range(N):
  point = sa*portion[k]//sp
  if point > A[k]:
    lot[k] += A[k]*F[k]
    A[k] = 0
  else:
    lot[k] += point *F[k]
    A[k] -= point
res = sum(A) - K
#print(lot)
#print(A)
#print(res)

foo = []
for k in range(N):
  if A[k] == 0:
    continue
  else:
    foo.append((lot[k]+F[k], A[k], k))

from heapq import heapify, heappop, heappush
heapify(foo)
while res>0:
  res -= 1
  item = heappop(foo)
  lot[item[2]] = item[0]
  if item[1] == 1:
    continue
  else:
    heappush(foo, (item[0]+F[item[2]], item[1]-1, item[2]))
  #print(foo)
print(max(lot))

### FIXED CODE ###

from math import ceil
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
if K >= sum(A):
  print(0)
  exit()
A.sort(reverse=True)
F.sort()
lot = []
for k in range(N):
  lot.append((A[k]*F[k], k))
lot.sort(key =  lambda x:x[0],reverse=True)
high = lot[0][0]
#print('A:', A)
#print('F:', F)
#rint(lot)
def binary_search(high):
  low = 0
  mid = (low + high) //2
  while low < high:
    final = False
    mid = (low + high) //2
    #print(low, high, mid)
    if low == high-1:
      final = True
    #print(low, high, mid)
    res = K
    flag = True
    for k in range(N):
      if res < 0:
        break
      else:
        if lot[k][0] <= mid:
          break
        else:
          res -= ceil((lot[k][0]-mid)/F[lot[k][1]])
          continue
    if res < 0:
      flag = False
    #print(flag)
    if flag:
      high = mid
    else:
      if final:
        mid += 1
      low = mid
    #print(low, high, mid)
  #return None
  return mid

print(binary_search(high))
### BUGGY CODE ###

N, K = map(int, input().split())
p = list(map(int, input().split()))

max_val = 0
max_idx = 0
tmp = 0
for i in range(1,N-K+2):
  if i == 1:
    tmp = sum(p[i-1:i-1+K])
  else:
    tmp = tmp - p[i-2] + p[i-2+K]
  if tmp > max_val:
    max_val = tmp
    max_idx = i

expect = 0.0
for i in range(max_idx, max_idx+K):
  tmp = 0.0
  for j in range(1,p[i-1]+1):
    tmp += j
  expect += tmp/p[i-1]
print(expect)

### FIXED CODE ###

N, K = map(int, input().split())
p = list(map(int, input().split()))

max_val = 0
max_idx = 0
tmp = 0
for i in range(1,N-K+2):
  if i == 1:
    tmp = sum(p[i-1:i-1+K])
  else:
    tmp = tmp - p[i-2] + p[i-2+K]
  if tmp > max_val:
    max_val = tmp
    max_idx = i

p = p[max_idx-1:max_idx-1+K]
p.sort()
prev_tmp = 0.0
expect = 0.0
for i in range(len(p)):
  tmp = 0.0
  if i == 0:
    for j in range(1,p[i]+1):
      tmp += j
    expect += tmp/p[i]
    prev_tmp = tmp
  else:
    tmp = prev_tmp
    for j in range(p[i-1]+1,p[i]+1):
      tmp += j
    expect += tmp/p[i]
    prev_tmp = tmp
print(expect)
### BUGGY CODE ###

N = int(input())
A = [int(input()) for _ in range(N)]

now = 0
count = 0
while True:
    count += 1
    if A[now] == 1:
        print(-1)
        break

    if A[now] == 2:
        print(count)
        break

    now = A[now] - 1


### FIXED CODE ###

N = int(input())
A = [int(input()) for _ in range(N)]

now = 0
count = 0
while True:
    if count >= N:
        print(-1)
        break

    if now == 1:
        print(count)
        break

    now = A[now] - 1
    count += 1
### BUGGY CODE ###

from collections import Counter, defaultdict
a = defaultdict(int)
a[0] += 1
s = input()[::-1]
for i in range(1, len(s)+1):
    a[int(s[:i][::-1])%2019] += 1

def comb(a):
    return a*(a-1)//2

ans = 0
for x in a.values():
    if x >= 2:
        ans += comb(x)
print(ans)

### FIXED CODE ###

from collections import Counter, defaultdict
a = defaultdict(int)
a[0] += 1
s = input()[::-1]
cur = 0
for i, x in enumerate(s):
    cur += (int(x)*pow(10, i, 2019))%2019
    cur %= 2019
    a[cur] += 1

def comb(a):
    return a*(a-1)//2

ans = 0
for x in a.values():
    if x >= 2:
        ans += comb(x)
print(ans)
### BUGGY CODE ###

s = input()
print_checker = ''

if len(s) == 2:
    if s[0] == s[1]:
        print(1, 2, sep=' ')
        print_checker += '*'
    else:
        print(-1, -1, sep=' ')
        print_checker += '*'  
else:
    for a in range(3, len(s)):
        if print_checker != '':
            break
        else:
            for b in range(len(s)-a+1):
                s_check = ''
                for c in range(a):
                    s_check += s[b+c]
            
                s_dict = {}
                for d in range(len(s_check)):
                    if s_check[d] not in s_dict:
                        s_dict[s_check[d]] = 1
                    else:
                        s_dict[s_check[d]] += 1

                if max(s_dict.values()) > len(s_check) / 2:
                    print(b+1, b+c+1)
                    print_checker += '*'
                    break
                else:
                    continue


if print_checker == '':
    print(-1, -1, sep=' ')

### FIXED CODE ###

s = input()

checker = ''

if len(s) == 2:
    if s[0] == s[1]:
        print(1, 2)
        checker += '*'
    else:
        print(-1, -1)
        checker += '*'


if checker == '':
    for a, b in zip(range(len(s)-1), range(1,len(s))):
        if s[a] == s[b]:
            print(a+1, b+1)
            checker += '*'
            break

if checker == '':
    for a, c in zip(range(len(s)-2), range(2, len(s))):
        if s[a] == s[c]:
            print(a+1, c+1)
            checker += '*'
            break

if checker == '':
    print(-1, -1)
### BUGGY CODE ###

import numpy as np
H,W = map(int,input().split())
S = [list(input()) for _ in range(H)]
L = np.zeros((H,W),dtype=np.int)
R = np.zeros((H,W),dtype=np.int)
U = np.zeros((H,W),dtype=np.int)
D = np.zeros((H,W),dtype=np.int)
for i in range(H):
    for j in range(W):
        if S[i][j] == ".":
            L[i][j] = L[i][j-1]+1
        if S[-i-1][-j-1] == ".":
            R[-i-1][-j-1] = R[-i-1][-j]+1
        if S[i][j] == ".":
            U[i][j] = U[i-1][j]+1
        if S[-i-1][-j-1] == ".":
            D[-i-1][-j-1] = D[-i][-j-1]+1
print(np.max(L+R+U+D)-3)

### FIXED CODE ###

import numpy as np
H,W = map(int,input().split())
S = np.array([list(input()) for _ in range(H)])
S = np.where(S=='.',1,0)


L = np.zeros((H,W),dtype=np.int)
R = np.zeros((H,W),dtype=np.int)
U = np.zeros((H,W),dtype=np.int)
D = np.zeros((H,W),dtype=np.int)

for i in range(W):
    L[:,i] = (L[:,i-1]+1)*S[:,i]
    R[:,-i-1] = (R[:,-i]+1)*S[:,-i-1]
for j in range(H):
    U[j,:] = (U[j-1,:]+1)*S[j,:]
    D[-j-1,:] = (D[-j,:]+1)*S[-j-1,:]

print(np.max(L+R+U+D)-3)
### BUGGY CODE ###

A,B = map(int,input().split())
li=[]
for i in range(A,B+1):
	li.append(format(i,"b"))
bin_sum=0
for i in li:
	bin_sum+=int(i)
	bin_sum=int(str(bin_sum).replace("2","0"))

print(int(str(bin_sum),2))

### FIXED CODE ###

import sys
import time
#from collections import deque, Counter, defaultdict
#from fractions import gcd
#import bisect
#import heapq
import math
start=time.time()
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
inf = 10**18
MOD = 1000000007
ri = lambda : int(input())
rs = lambda : input().strip()
rl = lambda : list(map(int, input().split()))
a,b = rl()
c=a%4
d=b%4
ans=0
for i in range(4-c):
    ans^=a+i
for i in range(d+1):
    ans^=b-i
print(ans)
### BUGGY CODE ###

from sys import stdin

def main():

    S = stdin.readline().rstrip() 
    Q = int(input())
    rev = 0
    for _ in range(Q):
        q = stdin.readline()

        if q[0] == "1":
            rev = (rev+1)%2
        else:
            if q[2] == "1":
                if rev == 0:
                    S = "{}{}".format(q[4], S)
                else:
                    S = "{}{}".format(S, q[4])
            else:
                if rev ==0:
                    S = "{}{}".format(S, q[4])
                else:
                    S = "{}{}".format(q[4], S)
    if rev == 1:
        S = S[::-1]

    print(S)

main()

### FIXED CODE ###

from sys import stdin

def main():
    S = list(stdin.readline().rstrip())
    Q = int(input())
    rev = 0
    head = []
    tail = []

    for _ in range(Q):
        q = stdin.readline()
        if q[0] == "1":
            rev = (rev+1)%2
        else:
            if q[2] == "1":
                if rev == 0:
                    head.append(q[4])
                else:
                    tail.append(q[4])
            else:
                if rev ==0:
                    tail.append(q[4])
                else:
                    head.append(q[4])

    if rev == 0:
        ans = "".join(head[::-1] + S + tail)
    else:
        ans = "".join(tail[::-1] + S[::-1] + head)
    
    print(ans)
    """
    S = stdin.readline().rstrip() 
    Q = int(input())
    rev = 0
    for _ in range(Q):
        q = stdin.readline()

        if q[0] == "1":
            rev = (rev+1)%2
        else:
            if q[2] == "1":
                if rev == 0:
                    S = "{}{}".format(q[4], S)
                else:
                    S = "{}{}".format(S, q[4])
            else:
                if rev ==0:
                    S = "{}{}".format(S, q[4])
                else:
                    S = "{}{}".format(q[4], S)
    if rev == 1:
        print(S[::-1])
    else:
        print(S)
    """
main()
### BUGGY CODE ###

from collections import defaultdict
R, C, K = map(int, input().split())
item = {}
for _ in range(K):
    r, c, v = map(int, input().split())
    item[(r, c)] = v

dp = [[[0] * 4 for _ in range(3010)] for _ in range(3010)]
for r in range(1, R+1):
    for c in range(1, C+1):
        prer = max(dp[r-1][c])
        dp[r][c][0] = max(prer, dp[r][c-1][0])
        dp[r][c][1] = max(prer, dp[r][c-1][1])
        dp[r][c][2] = max(prer, dp[r][c-1][2])
        dp[r][c][3] = max(prer, dp[r][c-1][3])
        if item.get((r, c)):
            dp[r][c][1] = max(dp[r][c][1], max(prer, dp[r][c-1][0]) + item[(r,c)])
            dp[r][c][2] = max(dp[r][c][2], max(prer, dp[r][c-1][1]) + item[(r,c)])
            dp[r][c][3] = max(dp[r][c][3], max(prer, dp[r][c-1][2]) + item[(r,c)])

print(max(dp[R][C]))


### FIXED CODE ###

R, C, K = map(int, input().split())
item = {}
for _ in range(K):
    r, c, v = map(int, input().split())
    item[(r, c)] = v

dp = [[0] * 4 for _ in range(3010)]
ndp = [[0] * 4 for _ in range(3010)]
for r in range(1, R+1):
    for c in range(1, C+1):
        prer = max(dp[c])
        ndp[c][0] = max(prer, ndp[c-1][0])
        ndp[c][1] = max(prer, ndp[c-1][1])
        ndp[c][2] = max(prer, ndp[c-1][2])
        ndp[c][3] = max(prer, ndp[c-1][3])
        if item.get((r, c)):
            ndp[c][1] = max(ndp[c][1], max(prer, ndp[c-1][0]) + item[(r,c)])
            ndp[c][2] = max(ndp[c][2], max(prer, ndp[c-1][1]) + item[(r,c)])
            ndp[c][3] = max(ndp[c][3], max(prer, ndp[c-1][2]) + item[(r,c)])
    dp = ndp
    ndp = [[0] * 4 for _ in range(3010)]

#print(dp)
print(max(dp[C]))
### BUGGY CODE ###

n=int(input())
ans =0
L =[0]*n

for i in range(1,n+1):
    for j in range(1,int((n**0.5+1))//3+1):
        for k in range(j,int((n**0.5+1))//3+2):
            for l in range(k,int((n**0.5+1))//3+3):
                if j**2 + k **2 + l**2 + j*k + k*l + l*j == i and j == k == l:
                    L[i-1] += 1
                if j**2 + k **2 + l**2 + j*k + k*l + l*j == i and j == k and j!=l:
                    L[i-1] += 3
                if j**2 + k **2 + l**2 + j*k + k*l + l*j == i and j != k and k==l:
                    L[i-1] += 3
                if j**2 + k **2 + l**2 + j*k + k*l + l*j == i and j != k and j!=l and k!=l:
                    L[i-1] += 6
for m in range(n):
    print(L[m])

### FIXED CODE ###

N=int(input())
r=[0]*10000
for i in range(1,101):
    for j in range(1,101):
        for k in range(1,101):
            v = i*i + j*j + k*k + i*j + i*k + k*j
            if v <= 10000:
                r[v-1] += 1
for i in range(N):
    print(r[i])
### BUGGY CODE ###

q = int(input())

for k in range(q):
    x = input()
    y = input()
    lcs = [0]*(len(x)+1)
    for i in range(len(y)):
        w1 = y[i]
        lcs_2 = lcs[:]
        for j in range(len(x)):
            if x[j] == w1:
                lcs[j+1] = lcs_2[j] + 1  
            elif lcs[j+1] < lcs[j]:
                lcs[j+1] = lcs[j]
    print(lcs[-1])

### FIXED CODE ###

q = int(input())
 
def lcss(x,y):
     
    lcs = [0]*(len(x)+1)
    for i in range(len(y)):
        w1 = y[i]
        lcs_2 = lcs[:]
        for j in range(len(x)):
            if x[j] == w1:
                lcs[j+1] = lcs_2[j] + 1  
            elif lcs[j+1] < lcs[j]:
                lcs[j+1] = lcs[j]
    return lcs[-1]
 
for i in range(q):
    x = input()
    y = input()
    print(lcss(x,y))
### BUGGY CODE ###

N = int(input())
P_list = list(map(int,input().split()))

cnt = 0
for i in range(1,N+1):
  ans_list = P_list[:i]
  if min(ans_list) == P_list[i-1]:
    cnt += 1

print(cnt)

### FIXED CODE ###

N = int(input())
P_list = list(map(int,input().split()))
M = P_list[0]
cnt = 1

for i in range(N):
  if M > P_list[i]:
    cnt += 1
    M = P_list[i]

print(cnt)
### BUGGY CODE ###

N = int(input())
L = [i for i in range(1, N+1)]
print(sum(L)-max(L))    

### FIXED CODE ###

N = int(input())
if N % 2 == 0:
    print(N*(N//2)-N//2)
else:
    print(N*(N//2))