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

import sys
import math
from collections import deque
import heapq
import itertools
from decimal import Decimal
import bisect
from operator import itemgetter
MAX_INT = int(10e18)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

def combi(n, r):
  r = min(r, n-r)
  numer = denom = 1
  for i in range(1, r+1):
    numer = numer * (n+1-i) %mod
    denom = denom * i %mod
  return numer * pow(denom, mod-2, mod) %mod

def tami(n, r):
  if r == 0:
    res = kaizyou[n]
    return res %mod
  elif r == 1:
    res = kaizyou[n-1] * (n-1)
    return res %mod
  else:
    return (tami(n-1, r-1) + tami(n-1, r-2) )%mod

N,M = IL()

kaizyou = [0,1]
for i in range(2,N+1):
  kaizyou.append(kaizyou[-1]*i %mod)

ans = 0
for i in range(max(0, 2*N-M), N+1):
  ans += ((combi(N, i) * combi(M-N, N-i) ) %mod * tami(N, i)) %mod
print((((combi(M, N) * kaizyou[N]) %mod) * ans) %mod)

### FIXED CODE ###

import sys
import time
import math
from collections import deque
import heapq
import itertools
from decimal import Decimal
import bisect
from operator import itemgetter
MAX_INT = int(10e18)
MIN_INT = -MAX_INT
mod = 1000000000+7
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

import functools
@functools.lru_cache(maxsize=None)
def factrial_memo(n):
  fact = [1, 1]
  for i in range(2, n + 1):
    fact.append((fact[-1] * i) % mod)
  return fact

def permutation(n,r): #nPr
  return fact[n]*pow(fact[n-r],mod-2,mod)%mod
  
def combination(n,r): #nCr
  return permutation(n,r)*pow(fact[r],mod-2,mod)%mod

def homogeneous(n,r): #nHr
  return combination(n+r-1,r)%mod

N,M = IL()

fact = factrial_memo(10**6)

s = 0
for k in range(1,N+1):
  s += combination(N, k) * permutation(M-k, N-k) * (-1)**(k-1)
ans = (permutation(M, N)**2 - s*permutation(M, N)) %mod
print(ans)
### BUGGY CODE ###

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import time
import sys
import io
import re
import math
import itertools
import collections
import bisect
#sys.stdin=file('input.txt')
#sys.stdout=file('output.txt','w')
#10**9+7
mod=1000000007
#mod=1777777777
pi=3.141592653589
IS=float('inf')
xy=[(1,0),(-1,0),(0,1),(0,-1)]
bs=[(-1,-1),(-1,1),(1,1),(1,-1)]
def niten(a,b): return abs(a-b) if a>=0 and b>=0 else  a+abs(b) if a>=0 else abs(a)+b if b>=0 else abs(abs(a)-abs(b))
def gcd(a,b): return a if b==0 else gcd(b,a%b)
def lcm(a,b): return a*b/gcd(a,b)
def euclid_dis(x1,y1,x2,y2): return ((x1-x2)**2+(y1-y2)**2)**0.5
def choco(xa,ya,xb,yb,xc,yc,xd,yd): return 1 if abs((yb-ya)*(yd-yc)+(xb-xa)*(xd-xc))<1.e-10 else 0

#n=int(raw_input())
h,w,n=map(int,raw_input().split())
ans=[0]*10
b=[[0 for i in range(w)] for j in range(h)]
for i in range(n):
    y,x=map(int,raw_input().split())
    b[y-1][x-1]=1
for i in range(h-2):
    for j in range(w-2):
        tmp=(b[i][j]+b[i+1][j]+b[i+2][j]+b[i][j+1]+b[i+1][j+1]+b[i+2][j+1]+b[i][j+2]+b[i+1][j+2]+b[i+2][j+2])
        ans[tmp]+=1
for i in ans:
    print i

### FIXED CODE ###

def sol():
    import sys
    input=sys.stdin.readline
    h,w,n=map(int,input().split())
    d={}
    for i in range(n):
        y,x=map(int,input().split())
        if (y,x) in d:
            d[(y,x)]+=1
        else:
            d[(y,x)]=1
        if y+1<=h and (y+1,x) in d:
            d[(y+1,x)]+=1
        elif y+1<=h:
            d[(y+1,x)]=1
        if y+2<=h and (y+2,x) in d:
            d[(y+2,x)]+=1
        elif y+2<=h:
            d[(y+2,x)]=1
 
        if x+1<=w and (y,x+1) in d:
            d[(y,x+1)]+=1
        elif x+1<=w:
            d[(y,x+1)]=1
        if x+2<=w and (y,x+2) in d:
            d[(y,x+2)]+=1
        elif x+2<=w:
            d[(y,x+2)]=1
        if x+1<=w and y+1<=h and (y+1,x+1) in d:
            d[(y+1,x+1)]+=1
        elif x+1<=w and y+1<=h:
            d[(y+1,x+1)]=1
        if x+2<=w and y+1<=h and (y+1,x+2) in d:
            d[(y+1,x+2)]+=1
        elif x+2<=w and y+1<=h:
            d[(y+1,x+2)]=1
        if x+1<=w and y+2<=h and (y+2,x+1) in d:
            d[(y+2,x+1)]+=1
        elif x+1<=w and y+2<=h:
            d[(y+2,x+1)]=1
        if x+2<=w and y+2<=h and (y+2,x+2) in d:
            d[(y+2,x+2)]+=1
        elif x+2<=w and y+2<=h:
            d[(y+2,x+2)]=1
    ans=[0]*10
    for i in d:
        if i[0]>2 and i[1]>2:
            ans[d[i]]+=1
 
    ans[0]=h*w-sum(ans)-w*2-h*2+4
    for i in ans:
        print(i)
        
if __name__=="__main__":
    sol()
### BUGGY CODE ###

import numpy as np

n = int(input())
s = [0]*n
c = [0]*n
A = [0]*n
k = 0

for i in range(n):
	s[i] = input()

s.sort()    
    
for i in range(n): 
	c[i] = s.count(s[i])

M = max(c)

for i in range(n):
	if c[k] == M:
		print(s[k])
		k += M-1
	k += 1
	if k >= n:
		break

### FIXED CODE ###

n = int(input())
s = [0]*n
c = [1]*n
A = [0]*n
k = 0

for i in range(n):
	s[i] = input()

s.sort()    
    
for i in range(n-1): 
	if s[i] == s[i+1]:
		c[i+1] += c[i]
      
M = max(c)

for i in range(n):
	if c[i] == M:
		print(s[i])
### BUGGY CODE ###

import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    H, N = map(int, input().split())
    AB = [tuple(map(int, input().split())) for _ in range(N)]

    MAX_V = 10**9+1
    dp = [MAX_V] * (H+1)
    dp[0] = 0
    for a, b in AB:
        for i in range(1, H+1):
            if i - a >= 0:
                v = dp[i-a] + b
            else:
                v = b
            if dp[i] > v:
                dp[i] = v

    print(dp[H])

if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    H, N = map(int, input().split())
    AB = [tuple(map(int, input().split())) for _ in range(N)]

    dp = [10**9+1] * (H+1)
    dp[0] = 0
    for a, b in AB:
        for i in range(1, H+1):
            if i - a >= 0:
                v = dp[i-a] + b
            else:
                v = b
            if dp[i] > v:
                dp[i] = v

    print(dp[H])

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

n = int(input())
ans = 0
arr = []

for i in range(n):
    tmp = input()
    if tmp not in arr:
        ans += 1
        arr.append(tmp)

print(ans)

### FIXED CODE ###

n = int(input())
ans = 0
arr = []

for i in range(n):
    arr.append(input())

arr = set(arr)

print(len(arr))
### BUGGY CODE ###

#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math

import itertools

#import bisect

import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]



def main():
    n,k=map(int,input().split())
    p=list(map(int,input().split()))
    temp=0
    max=0
    maxi=0
    for i in range(n-k+1):
        temp=sum(p[i:i+k])
        if temp>max:
            max=temp
            maxi=i
    total=0
    for i in range(maxi,maxi+k):
        total+=(1+p[i])/2

    print(total)

if __name__ == "__main__":
    main()

### FIXED CODE ###

#import sys
MOD = 10 ** 9 + 7
INFI = 10**10
#input = sys.stdin.readline
import math

import itertools

#import bisect

import copy
from functools import lru_cache

def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

#    h,w,a,b = map(int, input().split())
#    c = [[0 for j in range(n)] for i in range(n)]



def main():
    n,k=map(int,input().split())
    p=list(map(int,input().split()))
    temp=0
    max=sum(p[0:k])
    maxi=0
    temp=max
    if n>=2:
        for i in range(1,n-k+1):
            temp-=p[i-1]
            temp+=p[i+k-1]
            if temp>max:
                max=temp
                maxi=i
    total=(max+k)/2
#    for i in range(maxi,maxi+k):
 #       total+=(1+p[i])

    print(total)

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

import numpy as np
from numba import njit
n = int(input())
a = np.array(list(map(int,input().split())),np.int32)

@njit(cache=True)
def solve():
    m = np.zeros(10**6 + 1)
    for i in a:
        if m[i] == 1:
            m[i] = 2
            continue
        m[::i] += 1
    ans = 0
    for i in a:
        if m[i] == 1:
            ans += 1
    print(ans)

solve()

### FIXED CODE ###

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

ma = max(a)
m = [0]*(ma + 1)

for i in a:
    if m[i] == 1:
        m[i] = 2
        continue
    for j in range(i,ma+1,i):
        m[j]+=1
ans = 0
for i in a:
    if m[i] == 1:
        ans += 1
print(ans)
### BUGGY CODE ###

import sys
from collections import deque

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    H, W, n = map(int, input().split())
    AB = set(tuple(tuple(map(lambda x: int(x) - 1, input().split())) for _ in range(n)))

    d = ((1, 1), (1, 0), (1, -1), (0, 1), (0, 0), (0, -1), (-1, 1), (-1, 0), (-1, -1))
    total = (H - 2) * (W - 2)
    res = [0] * 10
    used = set()
    for a, b in AB:
        if (a, b) in used:
            continue
        que = deque([(a, b)])
        while que:
            h, w = que.popleft()
            if (h, w) in used:
                continue
            used.add((h, w))
            cnt = 0
            flg = True
            for dh, dw in d:
                next_h, next_w = h + dh, w + dw
                if next_h < 0 or next_h >= H or next_w < 0 or next_w >= W:
                    flg = False
                else:
                    if (next_h, next_w) in AB:
                        cnt += 1
                    if (next_h, next_w) not in used:
                        que.append((next_h, next_w))
            if flg:
                res[cnt] += 1
    t = total - sum(res)
    res[0] += t
    print(*res, sep="\n")


if __name__ == '__main__':
    resolve()


### FIXED CODE ###

import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    H, W, n = map(int, input().split())
    AB = set(tuple(tuple(map(lambda x: int(x) - 1, input().split())) for _ in range(n)))

    d = ((1, 1), (1, 0), (1, -1), (0, 1), (0, 0), (0, -1), (-1, 1), (-1, 0), (-1, -1))
    target = set()
    res = [0] * 10
    for h, w in AB:
        cnt = 0
        flg = True
        for dh, dw in d:
            next_h, next_w = h + dh, w + dw
            if next_h < 0 or next_h >= H or next_w < 0 or next_w >= W:
                flg = False
            if (next_h, next_w) in AB:
                cnt += 1
            else:
                target.add((next_h, next_w))
        if flg:
            res[cnt] += 1

    for h, w in target:
        cnt = 0
        for dh, dw in d:
            next_h, next_w = h + dh, w + dw
            if next_h < 0 or next_h >= H or next_w < 0 or next_w >= W:
                break
            if (next_h, next_w) in AB:
                cnt += 1
        else:
            res[cnt] += 1

    total = (H - 2) * (W - 2)
    res[0] = total - sum(res)
    print(*res, sep="\n")


if __name__ == '__main__':
    resolve()
### BUGGY CODE ###

n = int(raw_input())
S = map(int, raw_input().strip().split(' '))
q = int(raw_input())
T = map(int, raw_input().strip().split(' '))

def binary_search(S,k):
    if len(S) == 1 and S[0] != k: return False
    p = len(S)/2
    if S[p] == k: return True
    else:
        return binary_search(S[:p],k) | binary_search(S[p:],k)

c = 0
for t in T:
    if binary_search(S,t): c += 1
print c

### FIXED CODE ###

def search(a, x):
    n = len(a)
    hi = n-1
    lo = 0
    while hi >= lo:
        med = (hi+lo)/2
        if a[med] == x:
            return True
        elif a[med] > x:
            hi = med-1
        else:
            lo = med+1
    return False

n = int(raw_input())
S = map(int, raw_input().split(' '))
q = int(raw_input())
T = map(int, raw_input().split(' '))

found = 0
for x in T:
    if search(S, x):
        found += 1

print found
### BUGGY CODE ###

N=int(input())
H=list(map(int,input().split()))
H.append(0)
h1=0
h2=0
a=0
for i in range(N-1):
    if a==1:
        break
    h1=H[i+1]-H[i]
    if h1<-1:
        a=1
    elif h1==-1:
        for j in range(1,N-i):
            h2=H[i]-H[i+j]
            if h2>=2:
                a=1
                break
if a==0:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

N=int(input())
H=list(map(int,input().split()))
a=0
for i in range(N-1)[::-1]:
    if H[i]>H[i+1]:
        H[i]-=1
for i in range(N-1):
    if H[i]>H[i+1]:
        a=1
        break
if a==0:
    print("Yes")
else:
    print("No")
### BUGGY CODE ###

n = int(input())
s = [input() for _ in range(n)]
s2 = [0 for _ in s]

for j, si in enumerate(s):
    counter = [0 for _ in range(26)]
    for c in si:
        i = ord(c) - 0x61
        counter[i] += 1
    rep = 0
    for i in range(26):
        rep += counter[i] * (1<<(i*4))
    s2[j] = rep

pair = 0
for i in range(n):
    for j in range(i+1, n):
        if s2[i] == s2[j]:
            pair += 1

print(pair)


### FIXED CODE ###

n = int(input())
s = [input() for _ in range(n)]
s2 = [0 for _ in s]
# l = [0 for _ in range(1<<(26*4))]
s2 = {}

for j, si in enumerate(s):
    counter = [0 for _ in range(26)]
    for c in si:
        i = ord(c) - 0x61
        counter[i] += 1
    rep = 0
    for i in range(26):
        rep += counter[i] * (1<<(i*4))
    # s2[j] = rep
    # l[rep] += 1
    if rep not in s2.keys():
        s2[rep] = 1
    else:
        s2[rep] += 1

pair = 0
"""
for i in range(n):
    for j in range(i+1, n):
        if s2[i] == s2[j]:
            pair += 1
"""
from math import factorial
for i in s2.values():
    if i > 1:
        pair += i * (i-1) // 2 

print(pair)
### BUGGY CODE ###

import fractions
K=int(input())
ans=0
 
for n in range(1,K+1):
    for m in range(1,K+1):
        for l in range(1,K+1):
            gcd=fractions.gcd(n,m)
            gcd=fractions.gcd(gcd,l)
            
            ans+=gcd
   
print(ans)

### FIXED CODE ###


import math
K=int(input())
ans=0
A=0

for n in range(1,K+1):
    for m in range(1,K+1):
        x=math.gcd(n,m)
        for l in range(1,K+1):
            A=math.gcd(x,l)    
            ans+=A
            
print(ans)
### BUGGY CODE ###

def divs(p):
  divs = []
  for i in range(1,int(p**.5)+1):
    if p%i==0:
      if p%i**N==0:
        divs.append(i)
      if i != p//i and p%(p//i)**N==0:
        divs.append(p//i)
  return divs  

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

divs = sorted(divs(P))
if len(divs) == 0:print(1)
else:print(divs[-1])

### FIXED CODE ###

def primes(n):
  ps = {}
  while n%2==0:
    n//=2
    if 2 not in ps:
      ps[2] = 1
    else:
      ps[2] += 1
  
  for i in range(3,int(n**.5)+1,2):
    while n%i==0:
      n//=i
      if i not in ps:
        ps[i] = 1
      else:
        ps[i] += 1
  
  if n!=1:
    ps[n] = 1
  
  return ps
  
N,P = map(int,input().split())
if N==1:
  print(P)
  exit()
ps = primes(P)
ans = 1
for p, num in ps.items():
  if num>=N:
    ans *= p**(num//N)
print(ans)
### BUGGY CODE ###

s = input()
K = int(input())

word_list = []
for i in range(len(s)):
    for j in range(i+1, len(s)+1):
        word_list.append(s[i:j])
    
word_set = set(word_list)
L = list(word_set)
L.sort()
print(L[K-1])

### FIXED CODE ###

s = input()
K = int(input())

L = []
for i in range(len(s)):
    L.append(s[i])
    
L.sort()
cnt = 0
for i in range(len(L)):
    if L[i] == L[0]:
        cnt += 1

word_list = []
idx = 0
if len(s) >= 20:
    if cnt <= 5:
        while idx < len(s):
            if s[idx] == L[0] or s[idx] == L[cnt]:
                for j in range(1, K+1):
                    word_list.append(s[idx:idx+j])
            idx += 1
    else:
        while idx < len(s):
            if s[idx] == L[0]:
                for j in range(1, K+1):
                    word_list.append(s[idx:idx+j])
            idx += 1
else:
    for i in range(len(s)):
        for j in range(i+1, len(s)+1):
            word_list.append(s[i:j])
    
word_set = set(word_list)
word_list = list(word_set)
word_list.sort()
print(word_list[K-1])
### BUGGY CODE ###

N, W = map(int, input().split())
dp = [0 for i in range(W+1)]

for i in range(N):
  wi, vi = map(int, input().split())
  for w in range(W, wi-1, -1):
    if dp[w-wi]+vi <= dp[w]:
      continue
    dp[w] = dp[w-wi]+vi

print(dp[W])


### FIXED CODE ###

import sys
input = sys.stdin.readline
 
def main():
    N,W = map(int,input().split())
    dp = [-1 for _ in range(W+1)]
    dp[W] = 0
    for _ in range(N):
        nm,nv = [int(a) for a in input().split()]
        for j in range(nm,W+1):
            a = nm
            if dp[j] == -1:
                continue
            if dp[j-a] < dp[j] + nv:
                dp[j-a] = dp[j] + nv
    print(max(dp))
 
if __name__ == "__main__":
    main()
### BUGGY CODE ###

S=input()
N=len(S)

l=[]

if N < 4:
    ans=0
else:
    ans = 0
    for i in range(N-3):
        for j in range(i+3,N):
            s=S[i:j+1]
            if s in l:
                ans +=1
            elif (int(s))%2019==0:
                ans +=1
                l.append(s)
print(ans)

### FIXED CODE ###

S=input()

N=len(S)
d={}
for i in range(2019):
    d[i]=0

d[0] = 1

mod=0
dig=1

for i in range(N):
    #s=S[N-1-i:]
    #d[int(s)%2019]+=1
    mod += dig * int(S[N-1-i])
    mod %= 2019
    d[mod] += 1
    dig *= 10
    dig %= 2019


ans = 0
for k in d.keys():
    v = d[k]
    if v > 1:
        ans += v*(v-1)//2
print(ans)
### BUGGY CODE ###

import sys
import math
input = sys.stdin.readline

def main():
    n = int(input())
    a = list(map(int, input().split()))
    
    sc = False
    key = a[0]
    for i in range(1, n):
        key = math.gcd(key, a[i])
    
    if key == 1:
        sc = True
    
    key = a[0]
    pc = True
    for i in range(1, n):
        if math.gcd(key, a[i]) > 1:
            pc = False
            break
        key *= a[i]
    
    if pc:
        print("pairwise coprime")
    elif sc:
        print("setwise coprime")
    else:
        print("not coprime")
        
    
    
    
    
if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys
import math
input = sys.stdin.readline

from collections import Counter

class Osa_k:
    def __init__(self, n):
        self.n = n
        self.min_factor = [int(x) for x in range(n+1)]
        
        self.is_prime = [True] * (self.n + 1)
        self.is_prime[0] = False
        self.is_prime[1] = False
        for j in range(4, self.n+1, 2):
            self.is_prime[j] = False
            self.min_factor[j] = 2
        for i in range(3, int(self.n**0.5) + 1, 2):
            if not self.is_prime[i]:
                continue
            for j in range(i * 2, self.n + 1, i):
                self.is_prime[j] = False
                if self.min_factor[j] >= i:
                    self.min_factor[j] = i
    
    def calulate(self, x):
        ans = []
        while x > 1:
            key = self.min_factor[x]
            while x%key == 0:
                ans.append(key)
                x //= key
        counter = set(ans)
        return counter
        

def main():
    n = int(input())
    a = list(map(int, input().split()))
    a.sort()
    key = a[0]
    sc = False
    for i in range(1, n):
        key = math.gcd(key, a[i])
    
    if key == 1:
        sc = True
    
    
    pc = True
    osak = Osa_k(10**6+1)
    
    sub = set()
    
    judge = dict()
    for i in range(n):
        key = osak.calulate(a[i])
        for v in key:
            if v in judge:
                pc = False
            judge[v] = 1
            
    
    if pc:
        print("pairwise coprime")
    elif sc:
        print("setwise coprime")
    else:
        print("not coprime")

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

n, k = [int(i) for i in input().split()]
an = [int(i) for i in input().split()]

def xor(j):
  s = 0
  for i in an:
    s += int(bin(j ^ i), 2)
  return s

result = 0
for i in range(k+1):
  s = xor(i)
  if s > result:
    result = s
    
print(result)





### FIXED CODE ###

n ,k = map(int, input().split())
an = list(map(int, input().split()))
result = 0
def keta(i):
  return len(bin(i)[2:])

for j in range(keta(k), 0, -1):
  cnt = 0
  b = 1 << j-1
  for a in an:
    if a & b != 0:
      cnt += 1
  
  if len(an) - cnt > cnt and k >= b:
    result += b
    k -= b
wanted = 0
for a in an:
  wanted += result ^ a
  
print(wanted)
### BUGGY CODE ###

N = int(input())
A = sorted([int(input()) for i in range(N)])
ans1 = [A[N-1]]
ans2 = [A[0]]

f = 0
f2 = 1
b = N - 2
b2 = N - 1
s = True
while f <= b:
    if s:
        ans1.append(A[f])
        f += 1
        if f <= b:
            ans1.insert(0, A[f])
            f += 1

        ans2.append(A[b2])
        b2 -= 1
        if f2 <= b2:
            ans2.insert(0, A[b2])
            b2 -= 1
    else:
        ans1.append(A[b])
        b -= 1
        if f <= b:
            ans1.insert(0, A[b])
            b -= 1

        ans2.append(A[f2])
        f2 += 1
        if f2 <= b2:
            ans2.insert(0, A[f2])
            f2 += 1            
    s = not s


a1 = a2 = 0
for i in range(N-1):
    a1 += abs(ans1[i] - ans1[i+1])
    a2 += abs(ans2[i] - ans2[i+1])

print(max(a1,a2))

### FIXED CODE ###

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

a = [0] * N
b = [0] * N
j = 1

for i in range(N-1):    
    a[i] += -j
    a[i+1] += j
    b[i] += j
    b[i+1] += -j    
    j = -j

a.sort()
b.sort()
s1 = sum([i*j for i,j in zip(a, A)])
s2 = sum([i*j for i,j in zip(b, A)])
print(max(s1,s2))