Harryxun/stf_run huggingface dataset:
from fractions import gcd
n, m = map(int, input().split())
a = list(map(int, input().split()))

def lcm(a, b):
    return int(a*b / gcd(a, b))
"""
ak の2を除く公約数の組み合わせ一覧のうち、M以下のものを上げれば良い？
もしakが0が含まれると、0個
"""

l = a[0] // 2
for a_ in a[1:]:
    l = lcm(l, a_ // 2)
ans = (m // l)
if ans == 0:
    print(ans)
else:
    print(ans//2 + 1)

### FIXED CODE ###

from fractions import gcd
n, m = map(int, input().split())
a = list(map(int, input().split()))

def lcm(a, b):
    return a*b // gcd(a, b)
"""
akが偶数だから、bk=2akとして、
bk × (2p + 1)を満たすpが存在すれば良い
2p+1は奇数のため、Xとbkの2の素因数は一致しなければならない
akに含まれる最大の2^kを探す。
"""
if len(a) == 1: lcm_all = a[0]//2
else: lcm_all = lcm(a[0]//2, a[1]//2)
amax = 0
for i in range(1, n):
    lcm_all = lcm(lcm_all, a[i]//2)
    amax = max(amax, a[i]//2)

f = True
if lcm_all > m:
    f = False
for i in range(n):
    if n == 1: break
    if (lcm_all//(a[i]//2))%2 == 0:
        # akの2の約数の数がそろわないので、どんな奇数を掛けても共通のXを作れない
        f = False
if f:
    # amaxの奇数倍でmを超えないもの
    ans = (m // lcm_all + 1)//2
    print(ans)
else:
    print(0)
L = list(input())
w = int(input())
i = 0
while i<=len(L):
  print(L[i],end="")
  i+=w

### FIXED CODE ###

L = list(input())
w = int(input())
i = 0
while i<len(L):
  print(L[i],end="")
  i+=w
import functools
import fractions


N = int(input())
A = list(map(int, input().split()))
A = list(set(A))
ans = [functools.reduce(fractions.gcd, A)]
if len(A) == 1:
    print(A[0])
    exit()
else:
    for i in A:
        b = sorted(A)
        b.remove(i)
        if a.coount(i) == 1:
            ans.append(functools.reduce(fractions.gcd, b))
print(max(ans))

### FIXED CODE ###

import functools
import fractions


N = int(input())
a = list(map(int, input().split()))
A = list(set(a))
ans = [functools.reduce(fractions.gcd, A)]
if len(A) == 1:
    print(A[0])
    exit()
else:
    for i in A:
        b = sorted(A)
        b.remove(i)
        if a.count(i) == 1:
            ans.append(functools.reduce(fractions.gcd, b))
print(max(ans))
from sys import argv

debug = "a" in argv
n = int(input())
ls = []
la = ls.append
for i in range(1, n + 1):
    s = input().split()
    la((i, s[0], int(s[1])))
if debug:
    print(f"ls: {ls}")
ls = sorted(ls, key=lambda x: x[2], reverse=1)
ls = sorted(ls, key=lambda x: x[1])
if debug:
    print(f"ls(sorted): {ls}")
if debug:
    print("debug end")
for x in ls:
    print(x[0])

### FIXED CODE ###

from sys import argv

debug = "a" in argv
n = int(input())
ls = []
la = ls.append
for i in range(1, n + 1):
    s = input().split()
    la((i, s[0], int(s[1])))
if debug:
    print("ls:",ls)
ls = sorted(ls, key=lambda x: x[2], reverse=1)
ls = sorted(ls, key=lambda x: x[1])
if debug:
    print("ls(sorted):",ls)
if debug:
    print("debug end")
for x in ls:
    print(x[0])
a,b=map(int,input().split())
if a==b
    print("Yes")
else:
    print("No")

### FIXED CODE ###

a,b=map(int,input().split())
if a==b:
    print("Yes")
else:
    print("No")
a,b,t = map(int, input().split())
print(((T+0.5) // a)*b)

### FIXED CODE ###

a,b,t = map(int, input().split())
ans = ((t+0.5) // a)*b
print(int(ans))
n = input()
set_n = set(raw_input().split())
q = input()
set_q = set(raw_input().split()
answer = (set_n & set_q)
print len(answer)

### FIXED CODE ###

n = input()
set_n = set(raw_input().split())
q = input()
set_q = set(raw_input().split())
print len(set_n & set_q)
N = int(input())
li = list(map(int,input().split()))

li.sort()
while len(li) > 1:
    a = li.pop()
    b = li.pop()
    if a % b == 1:
        li[0] = 1
        break
    if a % b != 0:
        li.append(a % b)
    li.append(b)
    li.sort()
print(li[0])

### FIXED CODE ###

from fractions import gcd
N = int(input())
li = set(map(int,input().split()))
li = list(li)

ans = li[0]
for i in range(1,len(li)):
    ans = gcd(ans,li[i])
    if ans == 1: break

print(ans)
A, B, M = map(int, input().split())

a = list(map(int, input().split()))
b = list(map(int, input().split()))

amin = min(a)
bmin = min(b)

ans = amin + bmin

for i in range(M):
  x, y, c = map(int, input().split())
  ans = min( ans , a[x-1] + b[x-1] - c )

print(ans)

### FIXED CODE ###

A, B, M = map(int, input().split())

a = list(map(int, input().split()))
b = list(map(int, input().split()))

amin = min(a)
bmin = min(b)

ans = amin + bmin

for i in range(M):
  x, y, c = map(int, input().split())
  ans = min( ans , a[x-1] + b[y-1] - c )

print(ans)
from collections import defaultdict
A,B = map(int,input().split())

def count(n,k):
    n = bin(n)[2:]
    n = '0'+n
    res = 0
    if n[-k-1]=='1':
        if k==0:
            res += 1
        else:
            res += (int(n[-1])+1)%2
    if k == 0:
        res = (res+int(n[-2]))%2
    return res

def f(n):
    d = defaultdict(lambda:0)
    for k in range(len(bin(n)[2:])):
        d[k] = count(n,k)
    return d

d_a = f(A-1)
d_b = f(B)
ans = ''
for i in range(40):
    ans = str((d_a[i]+d_b[i])%2) + ans
ans = int(ans,2)
print(ans)

### FIXED CODE ###

from collections import defaultdict
A,B = map(int,input().split())

def count(n,k):
    n = bin(n)[2:]
    n = '0'+n
    res = 0
    if n[-k-1]=='1':
        if k==0:
            res += 1
        else:
            res += (int(n[-1])+1)%2
    if k == 0:
        res = (res+int(n[-2]))%2
    return res

def f(n):
    if n < 0:
        n = 0
    d = defaultdict(lambda:0)
    for k in range(len(bin(n)[2:])):
        d[k] = count(n,k)
    return d

d_a = f(A-1)
d_b = f(B)
ans = ''
for i in range(40):
    ans = str((d_a[i]+d_b[i])%2) + ans
ans = int(ans,2)
print(ans)
n = 5
Si = n(n+1)/2
lst = list(map(int,input().split()))
Sr = sum(lst)
print(Si-Sr)

### FIXED CODE ###

n = 5
Si = n*(n+1)/2
lst = list(map(int,input().split()))
Sr = sum(lst)
print(int(Si-Sr))
print(char(ord(input())+1))

### FIXED CODE ###

print(chr(ord(input())+1))
import sys
#入力管理
lines, rows = map(int, input().split())
mapmap = []

for i in range(lines):
    mapmap.append(list(input()))

#最初の黒点探し
for i in range(lines):
    for j in range(rows):
        if mapmap[i][j] == '#':
            start_flag = True
            break
#則終了

if start_flag == False:
    print('No')
    sys.exit()

startl, startr = i, j

#動き
move_x = [1, -1, 0, 0]
move_y = [0, 0, 1, -1]
Stack = [[startl, startr]]

#探索開始
while Stack:
   x, y= Stack.pop()#今現在の位置
   #現在位置を変換
   mapmap[x][y] = '.'

   for i in range(len(move_x)):
       nx = x + move_x[i]
       ny = y + move_y[i]

       if 0 <= nx and nx < lines and 0 <= ny and ny < rows:
           if mapmap[nx][ny] == '#':
               Stack.append([nx, ny])


#黒点探し
for i in range(lines):
    for j in range(rows):
        if mapmap[i][j] == '#':
            print('No')
            sys.exit()

print('Yes')


    

### FIXED CODE ###

import sys

line_size, row_size = map(int, input().split())
mapmap = []#地図初期化

for i in range(line_size):
    mapmap.append(list(input()))

#探索
def Start_check(mapmap, px, py):
    start_flg = False
    move_x = [1, -1, 0, 0]
    move_y = [0, 0, 1, -1]
    for i in range(4):#動ける範囲で探索
        nx = px + move_x[i]
        ny = py + move_y[i]
        if 0 <= nx and nx < line_size and 0 <= ny and ny < row_size:
            if mapmap[nx][ny] == '#':#もし黒塗りなら
                start_flg = True
    
    if start_flg == False:
        print('No')
        sys.exit()

#Main
count = 0#探索回数（塗り絵した回数）
for i in range(line_size):
    for j in range(row_size):
        if mapmap[i][j] == '#':
            Start_check(mapmap, i, j)
            count += 1

#何もしなかった場合
print('Yes')
a, b = map(int,input().split())
print(max(0, a-2b))

### FIXED CODE ###

a, b = map(int,input().split())
print(max(0, a-2*b))
s,t = map(input().split())
print(s+t)

### FIXED CODE ###

s,t = map(str,input().split())
print(t+s)
# 2019-11-21 01:26:03(JST)
import sys
import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r, insort_left as in_l
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np 

def is_palindrome_in(s):
    s = s.replace('x', '')
    if list(s) == list(reversed(s)):
        return True
    else:
        return False

def main():
    s = sys.stdin.readline().rstrip()
    
    if not is_palindrome_in(s):
        print(-1)
    else:
        s = collections.deque(s)
        count = 0
        i, j = 0, 0
        while i < len(s) - 1 - j:
            if s[i] == 'x':
                if s[-1-j] != 'x':
                    s.insert(len(s)-j, 'x')
                    count += 1
            elif s[-1-j] == 'x':
                s.insert(i, 'x')
                count += 1
            
            i += 1
            j += 1

        print(count)


if __name__ == "__main__":
    main()


### FIXED CODE ###

# 2019-11-21 01:26:03(JST)
import sys
import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r, insort_left as in_l
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np 

def is_palindrome_in(s):
    s = s.replace('x', '')
    if list(s) == list(reversed(s)):
        return True
    return False

def main():
    s = sys.stdin.readline().rstrip()
    
    if not is_palindrome_in(s):
        print(-1)
        sys.exit()
    
    s = collections.deque(s)
    
    count = 0
    while len(s) > 1:
        if s[0] == 'x':
            if s[-1] == 'x':
                s.popleft(); s.pop()
            else:
                s.popleft()
                count += 1
        else:
            if s[-1] != 'x':
                s.popleft(); s.pop()
            else:
                s.pop()
                count += 1

    print(count)

if __name__ == "__main__":
    main()
n = int(input())
L = list(map(int, input().split()))

mul = 3 if L[-1] == n-1 else 6
MOD = 1000000007

ans = 1
available = []
for elm in L:
    if elm == 0:
        available.append(elm)
    else:
        ans *= available.count(elm-1)
        available.remove(elm-1)
        available.append(elm)
        ans = ans % MOD

ans = (ans * mul) % MOD
print(ans)


### FIXED CODE ###

n = int(input())
L = list(map(int, input().split()))

mul = 3 if L[-1] == n-1 else 6
MOD = 1000000007

ans = 1
zero_counter = 0
available = []
for elm in L:
    if elm == 0:
        zero_counter += 1
        if zero_counter > 3:
            ans = 0
            break
        available.append(elm)
    else:
        counter = available.count(elm-1)
        if counter == 0:
            ans = 0
            break
        ans *= counter
        available.remove(elm-1)
        available.append(elm)
        ans = ans % MOD

ans = (ans * mul) % MOD
print(ans)
n = int(input())

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

for A in range(n):
    if A%3==0 or A%5==0:
        print("APPROVED")
    else:
        print("DENIED")

### FIXED CODE ###

a,b,c=map(int,input().split())

if a==b and a!=c:
    print("Yes")
elif a==c and a!=b:
    print("Yes")
elif b==c and b!=a:
    print("Yes")
else:
    print("No")
n, k, q = map(int, input().split())

adict = {i + 1: k for i in range(n)}

answer = [int(input()) for _ in range(q)]

for k, v in adict.items():
    adict[k] = v - (q - answer.count(k))

    if adict[k] > 0:
        print('Yes')
    else:
        print('No')

### FIXED CODE ###

d = {
    'Sunny': 'Cloudy',
    'Cloudy': 'Rainy',
    'Rainy': 'Sunny'
}

i = input()

print(d[i])
a, b = map(int, input().split())
if a > b
  print("{} > {}".format(a, b))
elif a < b
  print("{} < {}".format(a, b))
elif a == b
  print("{} == {}".format(a, b))
   

### FIXED CODE ###

a, b = map(int, input().split())

if a > b:
  print("a > b")
elif a < b:
  print("a < b")
elif a == b:
  print("a == b")
N, X = map(int, input().split())
x = list(map(int, input().split()))
x.append(X)
x.sort()
d = 10 ** 9

for i in range(N+1):
    d = min(d, x[i+1] - x[i])

print(d)

### FIXED CODE ###

from fractions import gcd

N, X = map(int, input().split())
x = list(map(int, input().split()))

g = abs(max(x) - X)
for i in range(N):
    g = gcd(abs(x[i] - X), g)

print(g)
n=int(input())
t=[int(input()) for _ in range(5)]
if n//min(t)<1:
    n//min(t)=1
print(n//min(t) +4)

### FIXED CODE ###

n=int(input())
t=[int(input()) for _ in range(5)]
k=(n-1)//min(t)
print(k+5)
N = int(input())
lst = []
for i in range(N):
  city, score = map(int, input().split())
  lst.append((city, score, i+1))

lst.sort(key=lambda x: x[1], reverse=True)
lst.sort(key=lambda x: x[0])
for tup in lst:
  c, s, i = tup
  print(i)

### FIXED CODE ###

from sys import stdin

N = int(input())
lst = []
for i in range(N):
    city, score = stdin.readline().split()
    lst.append((city, int(score), i + 1))

lst.sort(key=lambda x: x[1], reverse=True)
lst.sort(key=lambda x: x[0])
for tup in lst:
    c, s, i = tup
    print(i)
from sys import stdin
import sys

N, K = [int(x) for x in stdin.readline().rstrip().split()]
A = list(map(int, input().split()))
B = [i for i in range(1, N+1)]
d = dict(zip(B, A))
t = [0 for i in range(N)]
d1 = dict(zip(B, t))
temp = 1
cnt = 0
ans = []
for i in range(K):
    d1[d[temp]] = d1.get(d[temp], 0)+1
    if d1.get(d[temp], 0) == 2:
        cnt += 1
        ans.append(d[temp])
        # print(i, d[temp])
    if d1.get(d[temp], 0) == 3:
        break
    temp = d[temp]
    if i == K-1:
        print(temp)
        sys.exit()
cnt1 = 0
x = 1/cnt1
for i, v in enumerate(d1):
    if v == 1:
        cnt1 += 1
# print(cnt, cnt1, d1, temp, ans)
k = K-1-cnt1
print(ans[k % cnt])


### FIXED CODE ###

from sys import stdin
import sys

N, K = [int(x) for x in stdin.readline().rstrip().split()]
A = list(map(int, input().split()))
B = [i for i in range(1, N+1)]
d = dict(zip(B, A))
t = [0 for i in range(N)]
d1 = dict(zip(B, t))
temp = 1
cnt = 0
ans = []
for i in range(K):
    d1[d[temp]] = d1.get(d[temp], 0)+1
    if d1.get(d[temp], 0) == 2:
        cnt += 1
        ans.append(d[temp])
        # print(i, d[temp])
    if d1.get(d[temp], 0) == 3:
        break
    temp = d[temp]
    if i == K-1:
        print(temp)
        sys.exit()
cnt1 = 0
for i, v in enumerate(d1):
    if d1[v] == 1:
        cnt1 += 1
# print(cnt, cnt1, d1, temp, ans)
k = K-1-cnt1
print(ans[k % cnt])
n,k=map(int,input().split())
xs=[0]+list(map(int,input().split()))
from itertools import accumulate
As=list(accumulate(xs))
r = 0
for i in range(k+1):
    for j in range(i, k+1):
        x = i, j-i, k-j
        m = As[i] + As[n] - As[n-j+i]
        #m = m1 - sum(sorted(z for z in (xs[:i]+xs[n-j+i+1:]) if z < 0)[:k-j])
#        if m > r:
#            print(x, m, m1)
        r = max(r, m)
print(r)


### FIXED CODE ###

n,k=map(int,input().split())
xs=[0]+list(map(int,input().split()))
from itertools import accumulate
As=list(accumulate(xs))
r = 0
for i in range(k+1):
    for j in range(i, k+1):
        x = i, j-i, k-j
        if j > n:
            continue
        m1 = As[i] + As[n] - As[n-j+i]
        m = m1 - sum(sorted(z for z in (xs[:i]+xs[n-j+i+1:]) if z < 0)[:k-j])
#        if m > r:
#            print(x, m, m1)
        r = max(r, m)
print(r)
import sys

sys.setrecursionlimit(20000)

n, q = [int(x) for x in input().split()]

tree = [[] for _ in range(n + 1)]
cnt = [0] * (n + 1)

for _ in range(n - 1):
    a, b = [int(x) for x in input().split()]
    tree[a].append(b)

def walk(p, x):
    cnt[p] += x
    for n in tree[p]:
        walk(n, x)

for _ in range(q):
    p, x = [int(x) for x in input().split()]
    walk(p, x)

for i in range(1, n + 1):
    print(cnt[i], end=" ")


### FIXED CODE ###

from sys import stdin, setrecursionlimit

setrecursionlimit(1000000)


def main():
    def read_tree(n):
        parents = [0 for _ in range(n + 1)]
        for _ in range(n - 1):
            a, b = [int(x) for x in input().split()]
            parents[b] = a
        return parents

    n, q = [int(x) for x in input().split()]

    parents = read_tree(n)
    cnt = [0] * (n + 1)

    for _ in range(q):
        p, x = [int(x) for x in input().split()]
        cnt[p] += x
    
    for i in range(1, n + 1):
        cnt[i] += cnt[parents[i]]

    for i in range(1, n + 1):
        print(cnt[i], end=" ")


main()
N, x = map(int, input().split())
if N <= 3:
    if x != N:
        print("No")
    else:
        exit(1)

else:
    if abs(N - x) > N - 3:
        print("No")
    else:
        exit(1)


### FIXED CODE ###

N, x = map(int, input().split())
if N == 2:
    if x != N:
        print("No")
        exit(0)
else:
    if abs(N - x) > N - 2:
        print("No")
        exit(0)
print("Yes")

if N == 2:
    for i in range(3):
        print(i+1)
else:
    left = []
    right = []
    if x < 2 * N - 2:
        ans = [x+2, x-1, x, x+1]
        s = [i for i in range(1, 2*N) if i < x - 1 or i > x+2]
        for i in range((2*N - 5) // 2):
            print(s.pop())
        for i in range(4):
            print(ans[i])
        for i in range(((2*N - 5) // 2) + 1):
            print(s.pop())

    else:
        ans = [x-2, x+1, x, x-1]
        s = [i for i in range(1, 2*N) if i < x - 2 or i > x+1]
        for i in range((2*N - 5) // 2):
            print(s.pop())
        for i in range(4):
            print(ans[i])
        for i in range(((2*N - 5) // 2) + 1):
            print(s.pop())
a = [64, 32, 16, 8, 4, 2, 1]
N = int(input())
 
for i in a:
  if i < N:
    print(i)
    return

### FIXED CODE ###

a = [64, 32, 16, 8, 4, 2, 1]
N = int(input())
 
for i in a:
  if i <= N:
    print(i)
    break
n = int(input())
s = list(input())
x = 0
for i in range(n):
    a = s[0:i]
    b = s[i:]
    x = max(x, len(set(a) & set(b)))

print(x)

### FIXED CODE ###

a, b = map(int, input().split())
calcs = [a + b, a - b, a * b]
print(max(calcs))
h,w,d = map(int,input().split())
d //= 2
c1 = ('R','Y')
c2 = ('G','B')

l1 = []
i = 0
m = 0
while i < w:
  l1.append(c1[m])
  i+=1
  if i%d == 0:
    m = 1-m

l2 = []
i = 0
m = 0
while i < w:
  l2.append(c2[m])
  i+=1
  if i%d == 0:
    m = 1-m

c1 = ''.join(l1)
c2 = ''.join(l2)

for i in range(h):
  if i%(2*d) < d:
    print(c1)
  else:
    print(c2)

### FIXED CODE ###

h,w,d = map(int,input().split())
c = ('R','Y','G','B')

from itertools import product
for i in range(h):
  line = []
  for j in range(w):
    x = (i-j)%(2*d) >= d
    y = (i+j)%(2*d) >= d
    line.append(c[2*x+y])
  print(''.join(line))
N, M, C = map(int, input().split())
Blis = [int(x) for x in input().split()]
Alis = []*M
k = 0
for i in range(N):
  Alis[i] = [int(x) for x in input().split()]
for i in range(N):
  total = 0
  for j in range(M):
    total = total + (Alis[i][j])*(Blis[i][j])
  total = total + C
  if total > 0:
    k = k + 1
print(k)   

### FIXED CODE ###

N, M, C = map(int, input().split())
Blis = [int(x) for x in input().split()]
k = 0
for i in range(N):
  Alis = [int(x) for x in input().split()]
  total = 0
  for j in range(M):
    total = total + (Alis[j])*(Blis[j])
  total = total + C
  if total > 0:
    k = k + 1
print(k)
N,T=map(int,input().split())
ls=[int(input()) for _ in range(N)]
ans=10**18
for i in ls:
  if i[1] <= T:
    ans = min(ans,i[0])
if ans < 10**18:
  print(ans)
else:
  print('TLE')


### FIXED CODE ###

N,T=map(int,input().split())
ls=[list(map(int,input().split())) for _ in range(N)]
ans=10**18
for i in ls:
  if i[1] <= T:
    ans = min(ans,i[0])
if ans < 10**18:
  print(ans)
else:
  print('TLE')
import math
from functools import reduce

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

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

res = 0
tmp = reduce(lcm,a)-1
for i in a:
    res += tmp % i
print(res)

### FIXED CODE ###

from fractions import gcd
from functools import reduce

def lcm(x, y):
    return (x * y) // gcd(x, y)

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

res = 0
tmp = reduce(lcm,a)-1
for i in a:
    res += tmp % i
print(res)
N = int(input())
 d = list(map(int, input().split()))
""" 
d = [9, 1, 4, 4, 6, 7]
#N = 8
N = 6
#d = [9, 1, 14, 5, 5, 4, 4, 14]
d = [9, 1, 4, 4, 6, 7]
 """
# prob
# [number,value]
prob = []
cnt = 0
for i in d:
    prob.append([cnt, i])
    cnt += 1

""" print(prob)
print(sorted(prob, key=lambda x: x[1]))
 """
sorted_d = sorted(prob, key=lambda x: x[1])

d_max = sorted_d[N-1][1]
d_min = sorted_d[0][1]
#print(d_min, d_max)

cnt = 0
for i in range(N):
    """ print(sorted_d[0:i])
    print(sorted_d[i:])
 """
    if len(sorted_d[0:i]) == len(sorted_d[i:]):
        """ print("True")
        print(sorted_d[i][1])
        print(sorted_d[i-1][1])
        print(sorted_d[i][1] - sorted_d[i-1][1])
         """
        cnt += sorted_d[i][1] - sorted_d[i-1][1]
    # print("------")

print(cnt)


### FIXED CODE ###

N = int(input())
d = list(map(int, input().split()))
""" 
d = [9, 1, 4, 4, 6, 7]
#N = 8
N = 6
#d = [9, 1, 14, 5, 5, 4, 4, 14]
d = [9, 1, 4, 4, 6, 7]
 """
# prob
# [number,value]
prob = []
cnt = 0
for i in d:
    prob.append([cnt, i])
    cnt += 1

""" print(prob)
print(sorted(prob, key=lambda x: x[1]))
 """
sorted_d = sorted(prob, key=lambda x: x[1])

#print(d_min, d_max)
cnt = 0
# if len(sorted_d[0:i]) == len(sorted_d[i:]):
cnt += sorted_d[int(N/2)][1] - sorted_d[int(N/2-1)][1]

print(cnt)
import collections
import heapq
n = int(raw_input())
ais = [0] + map(int, raw_input().split()) 
#print ais
res = [0 for __ in range(n +1)]
for u in range(n, 0, -1):
	c = u*2
	cumul = 0
	while(c <= n):
		cumul += res[c]
		c += u
	if ais[u] != (cumul % 2): 
		res[u] = 1
s = sum(res)
print s
if s:
	print ' '.join([str(i) for i in range(len(res)) if res[i] == 1])


### FIXED CODE ###

print 3 * (int(raw_input()) ** 2 )
X = list(map(int, input().split()))
for i in range(len(X)):
  if X[i-1] = 0:
    print(i)

### FIXED CODE ###

X = list(map(int, input().split()))
print(X.index(0)+1)
s=int(input())
print('ABC'+s)


### FIXED CODE ###

s=int(input())
print('ABC'+str(s))