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

import sys
sys.setrecursionlimit(200000)

n = int(input())
l = list(map(int, input().split(" ")))
 
def dp(i, curr_cost):
	if n -1 == i:
		return curr_cost
	one = dp(i+1, curr_cost + abs(l[i] - l[i+1])) if n - 1 >= i + 1 else 9999999
	two = dp(i+2, curr_cost + abs(l[i] - l[i+2])) if n - 1 >= i + 2 else 9999999	
	return one if one < two else two
 
print(dp(0, 0))

### FIXED CODE ###

import sys

n = int(input())
l = list(map(int, input().split(" ")))
dp= [0]*n
dp[1] = abs(l[1] - l[0])

for i in range(2, n):
	one = dp[i - 1] + abs(l[i] - l[i-1])
	two = dp[i - 2] + abs(l[i] - l[i-2])	
	dp[i] = min([one, two])

print(dp[n-1])
### BUGGY CODE ###

n = int(input())
a = [0]+list(map(int,input().split()))+[0]
for i in range(1,n+1):
    ans = 0
    b = a[:i]+a[i+1:]
    for j in range(len(b)-1):
        ans += abs(b[j]-b[j+1])
    print(ans)

### FIXED CODE ###

n = int(input())
a = [0]+list(map(int,input().split()))+[0]
cost = sum([abs(a[i-1]-a[i]) for i in range(1,n+2)])
for i in range(1,n+1):
    print(cost-abs(a[i]-a[i+1])-abs(a[i-1]-a[i])+abs(a[i-1]-a[i+1]))
### BUGGY CODE ###

import sys

sys.setrecursionlimit(10**9)

class UnionFind:
    def __init__(self,n):
        super().__init__()
        self.par = [-1]*n
        self.tsize = [1]*n

    
    def root(self,x):
        return x if self.par[x] == -1 else self.root(self.par[x])

    def unite(self, x, y):
        x_r = self.root(x)
        y_r = self.root(y)
        if x_r != y_r:
            #update size
            self.tsize[y_r] += self.tsize[x_r]
            #update parent (y_r is root)
            self.par[x_r] = y_r

    def isSame(self,x,y):
        return self.root(x) == self.root(y)

    def size(self,x):
        return self.tsize[self.root(x)]


def main():
    n,m = tuple([int(t)for t in input().split()])

    bridge = [tuple([int(t)-1 for t in input().split()])for _ in [0]*m]
    bridge = bridge[::-1]

    uf = UnionFind(n)
    ans = [n*(n-1)//2]
    for a_i,b_i in bridge:
        if not uf.isSame(a_i,b_i):
            ans.append(ans[-1]-uf.size(a_i)*uf.size(b_i))
            uf.unite(a_i,b_i)
        else:
            ans.append(ans[-1])
    ans.pop()
    for a in ans[::-1]:
        print(a)



if __name__ == "__main__":
    main()

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**9)
class UnionFind:
    def __init__(self,n):
        super().__init__()
        self.par = [-1]*n
        self.rank = [0]*n
        self.tsize = [1]*n

    
    def root(self,x):
        if self.par[x] == -1:
            return x 
        else:
            self.par[x] = self.root(self.par[x])
            return self.par[x]

    def unite(self, x, y):
        x_r = self.root(x)
        y_r = self.root(y)
        
        if self.rank[x_r]>self.rank[y_r]:
            self.par[y_r] = x_r

        elif self.rank[x_r]<self.rank[y_r]:
            self.par[x_r] = y_r

        elif x_r != y_r:
            self.par[y_r] = x_r
            self.rank[x_r] += 1

        if x_r != y_r:
            size = self.tsize[x_r]+self.tsize[y_r]
            self.tsize[x_r] = size
            self.tsize[y_r] = size

    def isSame(self,x,y):
        return self.root(x) == self.root(y)

    def size(self,x):
        return self.tsize[self.root(x)]


def main():
    n,m = tuple([int(t)for t in input().split()])

    bridge = [tuple([int(t)-1 for t in input().split()])for _ in [0]*m]
    bridge = bridge[::-1]

    uf = UnionFind(n)
    ans = [n*(n-1)//2]
    for a_i,b_i in bridge:
        if not uf.isSame(a_i,b_i):
            ans.append(ans[-1]-uf.size(a_i)*uf.size(b_i))
            uf.unite(a_i,b_i)
        else:
            ans.append(ans[-1])
    ans.pop()
    for a in ans[::-1]:
        print(a)



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

# encoding: "utf-8"

from collections import defaultdict

class Stdin:
    @staticmethod
    def read_line(converter=str):
        return [converter(x) for x in input().split()]
    
    @staticmethod
    def read_lines(n, converter=str):
        result = list()
        for _ in range(n):
            result.append(Stdin.read_line(converter))
        return result
    
    @staticmethod
    def convert(data, converter):
        assert(len(data) == len(converter))
        return tuple(map(lambda x, f: f(x), data, converter))

    @staticmethod
    def convert_lines(datas, n, converter):
        return [converter(data, n, converter) for data in datas]


def first_count_and_pop(xs):
    cnt = 0
    fst = xs[0]
    cnt = xs.count(fst)
    # for x in xs:
    #     if x != fst:
    #         break
    #     cnt += 1
    return (cnt, xs[cnt:])    
    

def main():
    _ = input()
    xs = Stdin.read_line(converter=int)
    xs.sort()
    ys = defaultdict(int)
    while xs:
        key = xs[0]
        cnt, xs = first_count_and_pop(xs)
        ys[key] += cnt
        ys[key-1] += cnt
        ys[key+1] += cnt

    print(max(ys.values()))

# def main_():
#     input()
#     xs = Stdin.read_line(converter=int)
#     xs.sort()
#     counts = list()
#     for i in range(100000):
#         if not xs:
#             counts.extend([0] * (100000 - len(counts)))
#             break     
#         elif i == xs[0]:
#             cnt, xs = first_count_and_pop(xs)
#             counts.append(cnt)
#         else:
#             counts.append(0)
#     m = 0
#     for i in range(0, 100000):
#         if i == 0:
#             temp = counts[i] + counts[i+1]
#         elif i == 100000 - 1:
#             temp = counts[i-1] + counts[i]
#         else:
#             temp = counts[i-1] + counts[i] + counts[i+1]
#         if m < temp:
#             m = temp
#     print(m)

if __name__ == "__main__":
    main()

### FIXED CODE ###

input()
a_list = [int(s) for s in input().split()]

count = [0]*100002

for a in a_list:
    count[a] += 1
    count[a+1] += 1
    count[a+2] += 1
    
print(max(count))
### BUGGY CODE ###

N, Q = [int(x) for x in input().split()]
S = input()
lr = [[int(x) for x in input().split()] for _ in range(Q)]
for l, r in lr:
    cnt = 0
    for i in range(r-l):
        cnt += (S[l-1+i] == 'A' and S[l+i] == 'C')
    print(cnt)


### FIXED CODE ###

N, Q = [int(x) for x in input().split()]
S = input()
lr = [[int(x)-1 for x in input().split()] for _ in range(Q)]
lst = [0] * N
for i in range(N-1):
    lst[i+1] = lst[i] + (S[i] == 'A' and S[i+1] == 'C')
for l, r in lr:
    print(lst[r]-lst[l])
### BUGGY CODE ###

n,m = map(int,input().split())

in_p = []
in_y = []
p = []

for _ in range(n):
    p.append([])

for i in range(m):
    a,b = map(int,input().split())
    in_p.append(a)
    in_y.append(b)
    p[a-1].append(b)  

for i in range(n):
    p[i].sort()

for i in range(m):
    year=str(in_p[i]).zfill(6)
    a = p[in_p[i]-1].index(in_y[i]) + 1
    num=str(a).zfill(6)
    print("{0}{1}".format(year,num))



### FIXED CODE ###

import copy

n,m = map(int,input().split())

cnt = [0]*(10**5+4)

yy = []
yp = []
for _ in range(m):
    a,b = map(int,input().split())
    a,b = b,a
    yy.append([a,0])
    yp.append([a,b])

inlist = copy.deepcopy(yp)
yp.sort()
yy = dict(yy)

for i in range(m):
    cnt[yp[i][1]]+=1
    yy[yp[i][0]] = cnt[yp[i][1]]

for key,value in inlist:
    print("{:06}{:06}".format(value,yy[key]))
### BUGGY CODE ###

n,x,m = map(int, input().split())

amari = [x]
cnt = 0
p = 0

for i in range(n-1):
	a = amari[-1]**2 % m
	if a in amari:
		p = amari.index(a)
		cnt = i+1-p
		break
	else:
		amari.append(a)

if cnt == 0:
	print(sum(amari))
	
else:
	n -= len(amari)
	a = n // cnt
	b = n % cnt
	print(sum(amari)+a*sum(amari[p:])+sum(amari[p:(p+b)]))

### FIXED CODE ###

n,x,m = map(int, input().split())

amari = [x]
amariset = {x}
cnt = 0
p = 0

for i in range(n-1):
	a = amari[-1]**2 % m
	if a in amariset:
		p = amari.index(a)
		cnt = i+1-p
		break
	else:
		amari.append(a)
		amariset.add(a)

if cnt == 0:
	print(sum(amari))
	
else:
	n -= len(amari)
	a = n // cnt
	b = n % cnt
	print(sum(amari)+a*sum(amari[p:])+sum(amari[p:(p+b)]))
### BUGGY CODE ###

n = int(input())
a = list(map(int, input().split()))
f = [i for i in range(1, n+1)]

for i in f:
    print(a.index(i)+1, end=' ')

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
z = list(range(1, n+1))
az = list(zip(a, z))
az.sort()
for i in az:
    print(i[1], end=' ')
### BUGGY CODE ###

N = int(input())
A = [int(x) for x in input().split(' ')]

order = []

for attendance in range(N):
    order.append(str(A.index(attendance + 1) + 1))

print(" ".join(order))

### FIXED CODE ###

N = int(input())
A = [int(x) for x in input().split(' ')]

order = sorted(range(len(A)), key=lambda k: A[k])
order = [str(x + 1) for x in order]

print(" ".join(order))
### BUGGY CODE ###

import sys
f = sys.stdin

def q(t,s,e,func):
    if s == e:
        return t[s]
    else:
        return func(q(t,s,(s+e)//2,func),q(t,(s+e)//2 + 1,e,func))

_, d = map(int, f.readline().split())

b = []
for line in f:
    xi, yi, bi = map(int, line.split())
    b.append((bi,xi,yi))
b = sorted(b)
x = tuple(xi for _,xi,_ in b)
y = tuple(yi for _,_,yi in b)

max_size = i = j = 0
while j < len(b) - 1:
    for k in range(j,-1,-1):
        if b[k][0] + d < b[j][0]:
            break
        i = k
    for k in range(i,len(b)):
        if b[i][0] + d < b[k][0]:
            break
        j = k

    max_size = max(max_size,(q(x,i,j,max) - q(x,i,j,min)) * (q(y,i,j,max) - q(y,i,j,min)))
    j+=1
    
print(max_size)

### FIXED CODE ###

import math
def segmentTree(dat, f, sentinel):
        pad = 2 ** math.ceil(math.log(len(dat),2))
        dat = [0] * pad + dat + [sentinel] * (pad - len(dat))
        for i in range(pad - 1, 0, -1):
            dat[i] = f(dat[i * 2],dat[i * 2 + 1])
        return dat

def get_lr(b,d):
    l = r = 0
    while r < len(b):
        while b[l] + d < b[r]:
            l += 1
        for r in range(r,len(b)):
            if b[l] + d < b[r]:
                r -= 1
                break
        r += 1
        yield l,r
        l += 1
    
import sys
f = sys.stdin

_, d = map(int, f.readline().split())

xyb = []
for line in f:
    xyb.append(tuple(map(int, line.split())))
from operator import itemgetter
xyb.sort(key=itemgetter(2))

x = [xybi[0] for xybi in xyb]
y = [xybi[1] for xybi in xyb]
b = [xybi[2] for xybi in xyb]

xmax = segmentTree(x,max,sentinel = 0)
xmin = segmentTree(x,min,sentinel = 2000000)
ymax = segmentTree(y,max,sentinel = 0)
ymin = segmentTree(y,min,sentinel = 2000000)


pad = len(xmax) // 2
max_size = 0
def create_index(l,r):
    index = []
    ia = index.append
    while l < r:
        if r & 1:
            r -= 1
            ia(r)
        if l & 1:
            ia(l)
            l += 1
        l >>= 1
        r >>= 1
    return index

for l,r in get_lr(b,d):
    l += pad 
    r += pad
    index = create_index(l,r)

    now_xmax = max(xmax[i] for i in index)
    now_ymax = max(ymax[i] for i in index)
    if max_size < now_xmax * now_ymax:
        max_size = max(max_size,((now_xmax - min(xmin[i] for i in index)) * (now_ymax - min(ymin[i] for i in index))))
print(max_size)
### BUGGY CODE ###

n, m = map(int, input().split())
node = [[] for _ in range(n + 1)]
for i in range(m):
    a, b = map(int, input().split())
    node[a].append(b)
    node[b].append(a)

q = int(input())
node_color = [0 for _ in range(n + 1)]
for j in range(q):
    v, d, c = map(int, input().split())

    now = [v]
    paint = {v}
    for dist in range(d):
        buff = []
        for k in now:
            paint |= set(node[k])
            buff.extend(node[k])
        now = buff

    for l in paint:
        node_color[l] = c

for m in range(n):
    print(node_color[m + 1])


### FIXED CODE ###

n, m = map(int, input().split())
node = [[] for _ in range(n + 1)]
for i in range(m):
    a, b = map(int, input().split())
    node[a].append(b)
    node[b].append(a)

q = int(input())
node_color = [0 for _ in range(n + 1)]
vdc = [list(map(int, input().split())) for _ in range(q)]

vdc = vdc[::-1]
painted = set()
visited = [[0] * 11 for _ in range(n + 1)]


def dfs(now, dist, color):
    if dist < 0:
        return
    if visited[now][dist]:
        return

    visited[now][dist] += 1
    if not node_color[now]:
        node_color[now] = color

    for x in node[now]:
        dfs(x, dist - 1, color)


for i in vdc:
    v, d, c = i
    dfs(v, d, c)

for m in range(n):
    print(node_color[m + 1])
### BUGGY CODE ###

N,M=map(int,input().split())
LR=[]
for i in range(M):
  a=list(map(int,input().split()))
  LR.append(a)
ans=0
for i in range(1,N+1):
  count=0
  for j in range(M):
    if LR[j][0]<=i<=LR[j][1]:
      count+=1
  if count==M:
    ans+=1
print(ans)

### FIXED CODE ###

N,M=map(int,input().split())
L,R=[],[]

for i in range(M):
  l,r=map(int,input().split())
  L.append(l)
  R.append(r)
L.sort(reverse=True)
R.sort()

if R[0]>=L[0]:
  print(R[0]-L[0]+1)
else:
  print(0)
### BUGGY CODE ###

S = input()
mod = 13
mp = 10**9+7
n = len(S)
dp = [[0]*13 for i in range(n+1)]
dp[-1][0] = 1
d = 1
for i in range(n):
    s = S[-i-1]
    if s=="?":
        for k in range(10):
            for j in range(13):
                l = (k*d + j)%mod
                if dp[i-1][j] !=0:
                    dp[i][l] +=dp[i-1][j]
                    dp[i][l] %=mp
    else:
        for j in range(13):
            l = (int(s)*d + j)%mod
            if dp[i-1][j] !=0:
                dp[i][l] = dp[i-1][j]
    d = d*10 %mod
print(dp[n-1][5])


### FIXED CODE ###

S = input()
mod = 13
mp = 10**9+7
n = len(S)
dp = [[0]*13 for i in range(n+1)]
dp[-1][0] = 1
d = 1
for i in range(n):
    s = S[-i-1]
    if s=="?":
        for k in range(10):
            for j in range(13):
                l = (k*d + j)%mod
                if dp[i-1][j] !=0:
                    dp[i][l] +=dp[i-1][j]
                    dp[i][l] %=mp
    else:
        for j in range(13):
            l = (int(s)*d + j)%mod
            if dp[i-1][j] !=0:
                dp[i][l] = dp[i-1][j]
    d = d*10 %mod
print(dp[n-1][5])
### BUGGY CODE ###

nums = int(input())
ary = list(range(nums))

for i in range(nums):
    ary[i] = int(input())
x = 0
count = 0
ary.sort()

while x < nums:
    check = ary.count(ary[x])
    if check % 2 == 1:
        count += 1
        x += check-1
    elif check > 0:
        x += check-1
    x += 1
print(count)

### FIXED CODE ###

nums = int(input())
ary = list(range(nums))
check_number = [0 for i in range(nums+2)]
for i in range(nums):
    ary[i] = int(input())

ary.sort()
check = 0
count = 0
result = 0
x = 0
for i in ary :
    if check == i:
        check_number[x] += 1
    else:
        check = i
        x += 1
        check_number[x] = 1

for i in check_number:
    if i % 2 == 1:
        result += 1
print (result)
### BUGGY CODE ###

from collections import Counter

def sol():
    N = int(input())
    A = list(map(int, input().split()))
    P = set(A)
    cnt = Counter(A)

    def divisors(n):
        divisors = []
        R = int(n**(0.5)) + 1
        for i in range(1, R):
            if n % i == 0:
                divisors.append(i)
                if i != n // i:
                    divisors.append(n // i)
        return divisors

    ans = 0
    for a in P:
        if cnt[a] > 1:
            continue
        for d in divisors(a):
            if d != a and d in P:
                break
        else:
            ans += 1

    print(ans)

sol()

### FIXED CODE ###

from collections import Counter
N = int(input())
A = list(map(int, input().split()))
cntA = Counter(A)

A.sort()
V = set()

ans = 0
mx = max(A)
for a in A:
    if a in V:
        continue
    if cntA[a] == 1:
        ans += 1

    p = a
    while p <= mx:
        V.add(p)
        p += a

print(ans)
### BUGGY CODE ###

N,M = map(int,input().split())

allhiyatoi = []
for i in range(N):
    temp = list(map(int,input().split()))
    allhiyatoi.append(temp)

allhiyatoi.sort()

reward = 0
fin = []
for i in range(M+1):
    today = 0
    todaypos = -1
    for j,hiya in enumerate(allhiyatoi):
        if hiya[0]>i:
            break
        if j in fin:
            continue

        if today<hiya[1]:
            today = hiya[1]
            todaypos = j

    reward += today
    if todaypos!=-1:
        fin.append(todaypos)


print(reward)

### FIXED CODE ###

from heapq import heappush, heappop
 
N,M = map(int,input().split())

allhiyatoi = [[] for j in range(M+1)]
for i in range(N):
    temp = list(map(int,input().split()))
    if temp[0] > M:
        continue
    allhiyatoi[temp[0]].append(temp[1])
 
reward = 0
Q = []
for i in allhiyatoi:
    for j in i:
        heappush(Q,j*-1)
    if len(Q) == 0:
        continue
    reward -= (heappop(Q))

print(reward)
### BUGGY CODE ###

import numpy as np
import copy

def main():
    data0 = np.array(list(input()))
    data1 = np.array(list(input()))

    flag = True
    data_tmp = data0
    for c0, c1 in zip(data0, data1):
        if list(data0 == c0) == list(data1 == c1):
            data0 = data0[data0 != c0]
            data1 = data1[data1 != c1]
        else:
            flag = False

    if flag:
        print('Yes')
    else:
        print('No')



def swap(data, c0, c1):
    data_tmp = copy.copy(data)
    data_tmp[data == c0] = c1
    data_tmp[data == c1] = c0
    return data_tmp

if __name__ == "__main__":
    main()


### FIXED CODE ###

def main():
    data0 = input()
    data1 = input()

    flag = True
    data_tmp = data0
    count = 0
    len_data = len(data0)
    while True:
        if data0 == "":
            break

        data0 = data0.replace(data0[0], "")
        data1 = data1.replace(data1[0], "")

        if len(data0) != len(data1):
            print('No')
            exit()

    print('Yes')

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

n = int(input())

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

def solve(num, next_list):
    left = len(next_list)-1
    right = 0
    if num <= next_list[right]:
        right = -1
    elif num <= next_list[left]:
        mid = (left+right)//2
        while mid != right:
            if num <= next_list[mid]:
                left = mid
            else:
                right = mid
            mid = (left+right)//2
    else:
        right = left
    return right

b_bt = []
c_bt = []
for i in range(n):
    b_bt.append(solve(b[i], a)+1)
    c_bt.append(solve(c[i], b))
result = 0

for i in range(n):
    if c_bt[i] >= 0:
        result += sum(b_bt[:c_bt[i]+1])
print(result)

### FIXED CODE ###

import bisect

n = int(input())

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

result = 0
for i in range(n):
    x = bisect.bisect_left(a, b[i])
    y = n - bisect.bisect_right(c, b[i])
    result += x*y


print(result)
### BUGGY CODE ###


count = 0

def merge_sort(arr):
	merge_sort_(arr, 0, len(arr) - 1)

def merge_sort_(arr, floor, ceiling):
	if floor < ceiling:
		mid = int(floor + (ceiling - floor) / 2)
		merge_sort_(arr, floor, mid)
		merge_sort_(arr, mid + 1, ceiling)
		merge(arr, floor, mid, ceiling)

def merge(arr, floor, mid, ceiling):
	global count
	temp_arr = [0] * len(arr)
	for i in range(floor, ceiling + 1):
		temp_arr[i] = arr[i]
	
	i = floor
	j = mid + 1
	k = floor
	while k <= ceiling:
		count += 1
		if j > ceiling or (i <= mid and temp_arr[i] <= temp_arr[j]):
			arr[k] = temp_arr[i]
			i += 1
		else:
			arr[k] = temp_arr[j]
			j += 1
		k += 1
		
n = int(input())
arr = list(map(int, input().split()))
merge_sort(arr)
for i in range(n):
	print(arr[i], end="")
	if i != n - 1:
		print(" ", end="")
print()
print(count)




### FIXED CODE ###

import sys
count = 0

def merge_sort(arr):
	merge_sort_(arr, 0, len(arr))

def merge_sort_(arr, left, right):
	if left + 1 < right:
		mid = int(left + (right - left) / 2)
		merge_sort_(arr, left, mid)
		merge_sort_(arr, mid, right)
		merge(arr, left, mid, right)

def merge(arr, left, mid, right):
	global count
	
	n1 = mid - left
	n2 = right - mid
	
#	L = [0] * (n1 + 1)
#	R = [0] * (n2 + 1)
#	for i in range(n1):
#		L[i] = arr[left + i]
#	for i in range(n2):3
#		R[i] = arr[mid + i]
#	L[n1] = R[n2] = sys.maxsize
	
	L = arr[left:left + n1]
	R = arr[mid:mid + n2]
	L.append(sys.maxsize)
	R.append(sys.maxsize)

	i = j = 0
	for k in range(left, right):
		count += 1
		if L[i] <= R[j]:
			arr[k] = L[i]
			i += 1
		else:
			arr[k] = R[j]
			j += 1

n = int(input())
arr = list(map(int, input().split()))
merge_sort(arr)
print(" ".join(map(str, arr)))
#for i in range(n):
#	print(arr[i], end="")
#	if i != n - 1:
#		print(" ", end="")
#print()
print(count)
### BUGGY CODE ###


from sys import stdin
input = stdin.readline

a,b,n = map(int,input().split())
maxpoint = 0

if b > n  :
    tmp = int((a * n) / b)  - a * int(n/b) 
    maxpoint = max(tmp,maxpoint)

else:
    for i in reversed(range(n+1)):
        tmp = int((a * i) / b)  - a * int(i/b) 
        if b > 1:
            if i % (b-1) == 0 :
                maxpoint = max(tmp,maxpoint)
                print(maxpoint) 
                exit()
        elif b == 1:
            print(0)
            exit()
        maxpoint = max(tmp,maxpoint)

print(maxpoint)


### FIXED CODE ###

from sys import stdin
input = stdin.readline
 
a,b,n = map(int,input().split())
maxpoint = 0
 
if b > n  :
    tmp = int((a * n) / b)  - a * int(n/b) 
    maxpoint = max(tmp,maxpoint)
else:
    k = int(n/b)*b -1
    maxpoint =  int((a * k) / b)  - a * int(k/b) 
    if b == 1:
        maxpoint = 0
 
print(maxpoint)