Harryxun/stf_run huggingface dataset:
s = input()
#l = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
l = []
roll = ord('z')-ord('a')

for i in range(roll):
    l.append(0)

for i in range(len(s)):
    num = ord(s[i])
    l[num-97] += 1
    #print(num)

for i in range(roll):
    if l[i]%2 != 0:
        print("No")
        break
else:
    print("Yes")


### FIXED CODE ###

s = input()
#l = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
l = []
roll = ord('z')-ord('a')+1

for i in range(roll):
    l.append(0)

for i in range(len(s)):
    num = ord(s[i])
    l[num-97] += 1
    #print(num)

for i in range(roll):
    if l[i]%2 != 0:
        print("No")
        break
else:
    print("Yes")
S = input()
if '7' in S:
  print('Yes')
else
  print('No')


### FIXED CODE ###

S = input()
if '7' in S:
  print('Yes')
else:
  print('No')
import sys
 
n,m = map(int, input().split())
sc = [list(map(int, input().split())) for i in range(m)]
 
sc.sort()
ans = 0
d = 0
s = 0
 
if n != 1 and sc[0] == [1, 0]:
  print('-1')
  sys.exit()

if n != 1 and sc[0][0] != 1:
  ans += 10**(n-1)
 
for i in sc:
  if i[0] != d:
    d = i[0]
    s = i[1]
    ans += s * (10 ** (n-d))
  else:
    if i[1] != s:
      print('-1')
      sys.exit()
 
print(ans)

### FIXED CODE ###

import sys

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

num = ['-'] * n

for i in range (m):
  s,c = map(int, input().split())
  if num[s-1] != '-' and num[s-1] != c:
    print('-1')
    sys.exit()
  else:
    num[s-1] = c

if n > 1:
  if num[0] == 0:
    print('-1')
    sys.exit()
  elif num[0] == '-':
    num[0] = 1 
  
for i in range(n):
  if num[i] == '-':
    num[i] = '0'
  else:
    num[i] = str(num[i])

print(''.join(num))
while True:
   a, op, b = input().split()
   a = int(a)
   b = int(b)
   if op == "+":
	   print(a + b)
   elif op == "-":
	   print(a - b)
   elif op == "*":
	   print(a * b)
   elif op == "/":
	   print(a // b)

### FIXED CODE ###

while True:
   a, op, b = input().split()
   a = int(a)
   b = int(b)
   if op == "+":
	   print(a + b)
   elif op == "-":
	   print(a - b)
   elif op == "*":
	   print(a * b)
   elif op == "/":
	   print(a // b)
   elif op == "?":
   	   break
s = input()

print(s[0] + 1)

### FIXED CODE ###

s = input()

print(chr(ord(s[0]) + 1))
import math
r=int(input())
pi=math.pi
print('{} {}'.format(r**2*pi,r*2*pi))


### FIXED CODE ###

import math
r=float(input())
pi=math.pi
print('{} {}'.format(r**2*pi,r*2*pi))
K = int(input())
A = int(input())
B = int(input())
""" K=7
A=500
B=600 """



num=A
while num <= B:
    num += 1
    if num%K == 0:
        print("OK") 
        break
    if num==B:
        print("NG")
        break



### FIXED CODE ###

k=int(input())
a,b= map(int, input().split())
q=0
 
for i in range(1,1000):
  if a<=k*i and k*i<=b:
    print('OK')
    q=1
    break
 
if q==0:
  print('NG')
a=int(input().split())
print(a[0]/a[1])

### FIXED CODE ###

a=input().split()
b=int(a[0])/int(a[1])
c=float(b)
print(round(c,5))
#1行に1つと
#1行に複数行の読み込み方

n = int(input())
a = list(map(int, input().split()))
sum = 0
minus_count = 0
zero_flag = 0
min_ind = 0

for i in range(n):
	if a[i] < 0:
		minus_count += 1
	if a[i] == 0:
		zero_flag = 1

if zero_flag ==1:
	for i in range(n):
		sum += abs(a[i])
elif minus_count % 2 == 0:
	for i in range(n):
		sum += abs(a[i])
else:
	for i in range(n):
	min_ind = a[a.index(min(a))]
		sum += abs(a[i])
		sum -= abs(a[min_ind])

print(sum)

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
new_a = []
sum = 0
minus_count = 0
zero_flag = 0
min_a = 0

for i in range(n):
	new_a.append(abs(a[i]))

for i in range(n):
	if a[i] < 0:
		minus_count += 1
	if a[i] == 0:
		zero_flag = 1

if zero_flag == 1:
	for i in range(n):
		sum += abs(a[i])
elif minus_count % 2 == 0:
	for i in range(n):
		sum += abs(a[i])
else:
	for i in range(n):
		sum += new_a[i]
	sum = sum - min(new_a) * 2

print(sum)
l = list(input().split())
c = 0
for i in l:
 l[c] = int(i)
 c+=1

k = min(l[3],l[4])
money = min((l[0]+l[1])*k, l[2]*2*k)

if l[3]>l[4]:
 m = l[3]-l[4]
 money += min(l[0], l[2]*2)*m
else:
 m = l[4]-l[3]
 money += min(l[1], l[2]*2)*m

print(money)

### FIXED CODE ###

l = list(input())
m =700
for i in range(3):
 if l[i] == 'o':
  m += 100

print(m)
ef div_make(n):
    divisor =[]
    n=int(n)
    for i in range(1,int(n**0.5)+1):
        if n%i==0:
            divisor.append([i,n//i])
    return divisor

a=int(input())

lst=[]
for i in div_make(a):
    lst.append(i[0]+i[1])
ans=0
ans=min(lst)-2
print(ans)

### FIXED CODE ###

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

a=int(input())

lst=[]
for i in div_make(a):
    lst.append(i[0]+i[1])
ans=0
ans=min(lst)-2
print(ans)
#フィボナッチ数列か…
#c問題も解けないのか…
#典型問題なんだろうな
#踏めない段の分は除いて考えれば良い
n,m=input().split()
n,m=int(n),int(m)
ax=[int(input()) for i in range(m)]
bx=[1,1]
if ax[0]==1:
    bx[1]=0
for i in range(2,n+1):
    if i in ax:
        bx.append(0)
    else:
        bx.append((bx[i-2]+bx[i-1])%1000000007)
print(bx)


### FIXED CODE ###

#フィボナッチ数列か…
#c問題も解けないのか…
#典型問題なんだろうな
#踏めない段の分は除いて考えれば良い
n,m=input().split()
n,m=int(n),int(m)
ax=[1]*(n+1)
for i in range(m):
    ax[int(input())]=0
bx=[1,1]
for i in range(2,n+1):
    if ax[i-1]==1:
        f1=bx[i-1]
    else:
        f1=0
    if ax[i-2]==1:
        f2=bx[i-2]
    else:
        f2=0
    bx.append((f1+f2)%(10**9+7))

print(bx[n])
N,M,K = map(int,input().split())

par = [i for i in range(N+1)]

# 木の根を求める
def root(x):
    if par[x] == x:
        return x
    else:
        par[x] = root(par[x])
        return par[x]

# xとyが同じ集合に属するか否か
def bool_same(x,y):
    return root(x) == root(y)

# xとyの属する集合を併合
def unite(x,y):
    x = root(x)
    y = root(y)
    if x != y:
        par[x] = y

AB = [list(map(int,input().split())) for i in range(M)]
CD = [list(map(int,input().split())) for i in range(K)]

for i in range(M):
    a,b = AB[i]
    unite(a,b)

for i in range(N+1):
    root(i)

member = [0 for i in range(N+1)]

for p in par:
    member[p] += 1

ans = [member[par[i]]-1 for i in range(N+1)]

for i in range(M):
    a,b = AB[i]
    if bool_same(a,b):
        ans[a] -= 1
        ans[b] -= 1
for i in range(K):
    c,d = CD[i]
    if bool_same(c,d):
        ans[c] -= 1
        ans[d] -= 1
print(' '.join(map(str,ans[1:])))


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)

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

par = [i for i in range(N+1)]

# 木の根を求める
def root(x):
    if par[x] == x:
        return x
    else:
        par[x] = root(par[x])
        return par[x]

# xとyが同じ集合に属するか否か
def bool_same(x,y):
    return root(x) == root(y)

# xとyの属する集合を併合
def unite(x,y):
    x = root(x)
    y = root(y)
    if x != y:
        par[x] = y

AB = [list(map(int,input().split())) for i in range(M)]
CD = [list(map(int,input().split())) for i in range(K)]

for i in range(M):
    a,b = AB[i]
    unite(a,b)

member = [0 for i in range(N+1)]

for i in range(1,N+1):
    member[root(i)] += 1

ans = [member[par[i]]-1 for i in range(N+1)]

for i in range(M):
    a,b = AB[i]
    if bool_same(a,b):
        ans[a] -= 1
        ans[b] -= 1

for i in range(K):
    c,d = CD[i]
    if bool_same(c,d):
        ans[c] -= 1
        ans[d] -= 1

print(*ans[1:])
n = str(input())
if n[-1] in ['2', '4', '5', '7', '9']:
    how_to_read = 'hon'
elif n[-1] in ['0', '1', '6', '8':
    how_to_read = 'pon'
else:
    how_to_read = 'bon'
    
print(how_to_read)

### FIXED CODE ###

n = str(input())
if n[-1] in ['2', '4', '5', '7', '9']:
    how_to_read = 'hon'
elif n[-1] in ['0', '1', '6', '8']:
    how_to_read = 'pon'
else:
    how_to_read = 'bon'
    
print(how_to_read)
import sys
# 整数の入力
N,M=list(map(int, input().split()))
p=[]
q=0
for i in range(0,M):
  p.append(list(map(int, input().split())))
for i in range(0,M):
  q+=p[i][0]-p[i][1]
if q[i]%2==1:
  print("NO")
else:
  print("YES")

### FIXED CODE ###

import sys
# 整数の入力
N,M=list(map(int, input().split()))
p=[]
for i in range(0,N):
  p.append(0)
for i in range(0,M):
  count=list(map(int, input().split()))
  p[count[0]-1]+=1
  p[count[1]-1]+=1
for i in range(0,M):
  if p[i]%2==1:
    print("NO")
    sys.exit()
print("YES")
n,*a=map(int,open(0).read().split())
a.sort()
for i in a:
    s *= i
    if s > 1e18:
        print(-1)
        exit()
print(s)

### FIXED CODE ###

n,*a=map(int,open(0).read().split())
s=1
if 0 in a:
    print(0)
    exit()
for i in a:
    s*=i
    if  s > 1e18:
        print(-1)
        exit()
print(s)
edges, vertices = map(int, input().split())
dp = [None for _ in range(edges+1)]

nodes = [[] for _ in range(edges+1)]

for i in range(vertices):
    start, end = map(int, input().split())
    nodes[end -1].append(start-1)


def find(arr):
    if not len(arr):
        return 0
    for x in arr:
        if dp[x] is None:
            dp[x] = find(nodes[x])
    return 1 + max(dp[x] for x in arr)



print(nodes) 
for i in range(edges):
    dp[i] = find(nodes[i])

print(max(dp))


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)
edges, vertices = map(int, input().split())
dp = [None for _ in range(edges)]

nodes = [[] for _ in range(edges)]

for i in range(vertices):
    start, end = map(int, input().split())
    nodes[end -1].append(start-1)

def find(arr):
    if not len(arr):
        return 0
    for x in arr:
        if dp[x] is None:
            dp[x] = find(nodes[x])
    return 1 + max(dp[x] for x in arr)

for i in range(edges):
    dp[i] = find(nodes[i])

print(max(dp))
s = str(input())

if len(s) == len(set(s)):
    print(-1, -1)
else:
    for i in range(1, len(s)):
        if s[i - 1] != s[i] and s[i] == s[i + 1]:
            print(i, i + 2)
            break

### FIXED CODE ###

s = input()
n = len(s)

for i in range(n - 1):
    if s[i] == s[i + 1]:
        print(i + 1, i + 2)
        exit()

for i in range(n - 2):
    if s[i] == s[i + 2]:
        print(i + 1, i + 3)
        exit()

print(-1, -1)
N, K, Q = map(int,input().split())

if K > Q:
    ans = ["Yes" for i in range(N)]
print(ans)
exit()

T = [0 for i in range(N)]
t = Q - K

for i in range(Q):
    a = int(input())
    T[a] += 1

for i in range(N):
    if T[i] > t:
         print("Yes")
    else:
        print("No")

### FIXED CODE ###

N, K, Q = map(int,input().split())

if K > Q:
	for i in range(N):
		print("Yes")
	exit()

T = [0 for i in range(N)]
t = Q - K

for i in range(Q):
    a = int(input())
    T[a-1] += 1

for i in range(N):
    if T[i] > t:
         print("Yes")
    else:
        print("No")
x, a, b = map(int, input().split())
if x < b - a:
  print("dangerous")
elif x <= b - a:
  print("delicious")
else:
  primt("safe")

### FIXED CODE ###

x, a, b = map(int, input().split())
if a >= b:
    print('delicious')
elif a + x >= b:
    print('safe')
else:
    print('dangerous')
n=int(input())
a=list(map(int,input().split()))
ct=0
 
M=max(a)
min=min(a)

if m>=10**8:
  print(0)
else:
  for i in range(100):
    if 2**i>M:
      x=i
      break
  L=[]
  for j in range(2**x-1):
    L.append(0)
  
  for j2 in range(n):
    L[a[j2]-1]+=1
  
  for k in range(x,1,-1):
    l1=L[0:2**(k-1)-1]
    l2=L[2**(k-1):2**k]
    l2.reverse()
    ct+=int(L[2**(k-1)-1]/2)
    for m in range(len(l1)):
      if l1[m]>=1 and l2[m]>=1:
        ct+=min(l1[m],l2[m])
        l1[m]-=min(l1[m],l2[m])
        l2[m]-=min(l1[m],l2[m])
    L=l1
  ct+=int(L[0]/2)
  print(ct)

### FIXED CODE ###

import math
import bisect
n=int(input())
a=list(map(int,input().split()))
a.sort()
b=[]
for i in range(1,50):
  b.append(2**i)
ct=0
check=[1]*n
for i in range(n-1,-1,-1):
  if a[i]==1:
    break
  if check[i]==1 and a[i] not in b:
    check[i]=0
    x=math.floor(math.log2(a[i]))
    x=b[x]-a[i]
    y=bisect.bisect_left(a,x)
    z=bisect.bisect_right(a,x)
    t=bisect.bisect_left(check[y:z],1)+y
    if t!=z:
      check[t]=0
      ct+=1

ctb=0
w=1
for i in range(n):
  if a[i] in b or a[i]==1:
    if a[i]==w:
      if check[i]==1:
        ctb+=1
    else:
      ct+=ctb//2
      w=a[i]
      if check[i]==1:
        ctb=1
      else:
        ctb=0
  else:
    ct+=ctb//2
    ctb=0
ct+=ctb//2

print(ct)
edges, vertices = map(int, input().split())
dp = [None for _ in range(edges)]

nodes = [[] for _ in range(edges)]

for i in range(vertices):
    start, end = map(int, input().split())
    nodes[end -1].append(start-1)


def find(arr):
    if not len(arr):
        return 0
    for x in arr:
        if dp[x] is None:
            dp[x] = find(nodes[x])
    return 1 + max(dp[x] for x in arr)

for i in range(edges):
    dp[i] = find(nodes[i])

print(max(dp))

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)
edges, vertices = map(int, input().split())
dp = [None for _ in range(edges)]

nodes = [[] for _ in range(edges)]

for i in range(vertices):
    start, end = map(int, input().split())
    nodes[end -1].append(start-1)

def find(arr):
    if not len(arr):
        return 0
    for x in arr:
        if dp[x] is None:
            dp[x] = find(nodes[x])
    return 1 + max(dp[x] for x in arr)

for i in range(edges):
    dp[i] = find(nodes[i])

print(max(dp))
a = int(input())
b = int(input())
c = a + b
if c % 2 == 1:
    print('IMPOSSIBLE')
else:
    print(int(c / 2))

### FIXED CODE ###

a, b = map(int, input().split())
c = a + b
if c % 2:
    print('IMPOSSIBLE')
else:
    print(int(c / 2))
import sympy.ntheory.modular

N = int(input())
N *= 2
K = [[1, N]]
for i in range(2, max(int(N**0.5)+2, 2)):
    if N % i == 0:
        K.append([i, N//i])

ans = float("inf")
for i in range(len(K)):
    a, b = K[i]
    x = sympy.ntheory.modular.crt([a, b], [0, -1])
    if x is None:
        pass
    else:
        ans = min(ans, x[0])

print(ans)

### FIXED CODE ###

import math
def extgcd(a, b):
    """
    ax + by = gcd(a,b) = d となる (x,y,d) を返す
    """
    if b == 0:
        return (1, 0, a)
    q, r = a // b, a % b
    x, y, d = extgcd(b, r)
    s, t = y, x - q * y
    return s, t, d

def inv_mod(a, N):
    """
    ax = 1 mod N となる x を返す
    """
    return extgcd(a, N)[0]

def CRT(a_1, a_2, m_1, m_2):
    """
    x = a_1 mod m_1, x = a_2 mod m_2 となる x を返す
    """
    y = (a_2 - a_1) * inv_mod(m_1, m_2) % m_2
    return a_1 + m_1 * y

N = int(input())
N *= 2
K = [[1, N]]
for i in range(2, max(int(N**0.5)+1, 2)):
    if N % i == 0:
        K.append([i, N//i])

ans = float("inf")
for i in range(len(K)):
    a, b = K[i]
    if math.gcd(a, b) == 1:
        P = CRT(0, -1, a, b)
        if P != 0:
            ans = min(P, ans)
        Q = CRT(0, -1, b, a)
        if Q != 0:
            ans = min(Q, ans)

print(ans)
n=int(input())
cnt=0
for i in range(n):
  for j in range(5):
    if 10**j=<i<10**(j+1):
      J=j
      break
  if J%2==0:
    cnt+=1
print(cnt)
 
  
  

### FIXED CODE ###

n=int(input())
cnt=0
for i in range(1,n+1):
  for j in range(6):
    if 10**j<=i<10**(j+1):
      J=j
      break
  if J%2==0:
    cnt+=1
print(cnt)
a = list(input())
if a[0] = "9" or a[1] = "9":
  print(Yes)
else:
  print(No)
  

### FIXED CODE ###

a = list(input())
if a[0] == "9" or a[1] == "9":
  print("Yes")
else:
  print("No")
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor, inf
from sys import setrecursionlimit

import heapq
import itertools
import operator


def get_int():
    return int(input())


def get_str():
    return input().strip()


def get_int_list():
    return [int(i) for i in input().split()]


def get_char_list():
    return list(input().strip())


COST = {
    1: 2,
    2: 5,
    3: 5,
    4: 4,
    5: 5,
    6: 6,
    7: 3,
    8: 7,
    9: 6
}


# inputs
N, M = 0, 0
A = [0]


def hoge():
    d = dict()
    def labeler(label, iter):
        enumerate()


def set_inputs():
    global N, M, A
    N, M = get_int_list()
    A = get_int_list()


@lru_cache(maxsize=None)
def dp(i):
    if i < 0:
        return -inf
    elif i == 0:
        return 0
    return max(dp(i - COST[a]) + 1 for a in A)


def main():
    setrecursionlimit(100000)
    set_inputs()

    candidates = sorted(A, reverse=True)
    ret = []
    n = N
    for i in range(dp(N)):
        for a in candidates:
            cond = True
            if i == dp(N) - 1:
                cond = COST[a] == n
            if dp(n - COST[a]) == dp(n) - 1 and cond:
                ret.append(a)
                n -= COST[a]
                break
    print(''.join(str(r) for r in ret))


if __name__ == '__main__':
    main()


### FIXED CODE ###

from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor
from sys import setrecursionlimit

import heapq
import itertools
import operator


inf = float('inf')


def get_int():
    return int(input())


def get_str():
    return input().strip()


def get_int_list():
    return [int(i) for i in input().split()]


def get_char_list():
    return list(input().strip())


COST = {
    1: 2,
    2: 5,
    3: 5,
    4: 4,
    5: 5,
    6: 6,
    7: 3,
    8: 7,
    9: 6
}


# inputs
N, M = 0, 0
A = [0]


def hoge():
    d = dict()
    def labeler(label, iter):
        enumerate()


def set_inputs():
    global N, M, A
    N, M = get_int_list()
    A = get_int_list()


@lru_cache(maxsize=None)
def dp(i):
    if i < 0:
        return -inf
    elif i == 0:
        return 0
    return max(dp(i - COST[a]) + 1 for a in A)


def main():
    setrecursionlimit(100000)
    set_inputs()

    candidates = sorted(A, reverse=True)
    ret = []
    n = N
    for i in range(dp(N)):
        for a in candidates:
            cond = True
            if i == dp(N) - 1:
                cond = COST[a] == n
            if dp(n - COST[a]) == dp(n) - 1 and cond:
                ret.append(a)
                n -= COST[a]
                break
    print(''.join(str(r) for r in ret))


if __name__ == '__main__':
    main()
a, b = map(int, input().split())
print(int(a*b))

### FIXED CODE ###

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

ans = 0
r = 4
for i in range(4):
    if i != 1:
        ans += A * int(B[i]) * (10 ** (r))
        r -= 1

print(ans // 10000)
def main():
    from collections import deque
    mod = 10**9+7
    N = int(input())
    G = [[] for _ in range(N)]
    for _ in range(N-1):
        x, y = map(int, input().split())
        G[x-1].append(y-1)
        G[y-1].append(x-1)
    que = deque([0])
    children = [[] for _ in range(N)]
    while que:
        v = que.pop()
        for nv in G[v]:
            if children[nv]:
                continue
            children[v].append(nv)
            que.append(nv)   
    memo = [[-1]*2 for _ in range(N)]
    def dp(i, c):
        if memo[i][c] >=0:
            return memo[i][c]
        if not children[i]:
            return 1
        if c == 1:
            memo[i][c] = sum(dp(j, 0) for j in children[i])%mod
        else:
            memo[i][c] = sum(dp(j, 0) for j in children[i])%mod+sum(dp(j, 1) for j in children[i])%mod
            memo[i][c]%=mod
        return memo[i][c]
    print(dp(0, 0)+dp(0, 1))
main()



### FIXED CODE ###

def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**9)
    from collections import deque
    mod = 10**9+7
    N = int(input())
    G = [[] for _ in range(N)]
    for _ in range(N-1):
        x, y = map(int, input().split())
        G[x-1].append(y-1)
        G[y-1].append(x-1)
    que = deque([0])
    children = [[] for _ in range(N)]
    while que:
        v = que.pop()
        for nv in G[v]:
            if children[nv]:
                continue
            children[v].append(nv)
            que.append(nv)   
    memo = [[-1]*2 for _ in range(N)]
    def dp(i, c):
        if memo[i][c] >=0:
            return memo[i][c]
        if c == 1:
            res = 1
            for j in children[i]:
                res*=dp(j, 0)
                res%=mod
            memo[i][c] = res
        else:
            res = 1
            for j in children[i]:
                res*=(dp(j, 0)+dp(j, 1))
                res%=mod
            memo[i][c]= res
        return memo[i][c]
    print((dp(0, 0)+dp(0, 1))%mod)
main()
import fractions
a = int(input())
print((a * 2 ) // math.gcd(a, 2))

### FIXED CODE ###

def gcd(x, y):
    while y != 0:
        x, y = y, x % y
    return x

n = int(input())
print((n * 2) // gcd(n, 2))
a = [1,2,3]

a.remove(int(input()))
a.remoce(int(input()))

print(a[0])

### FIXED CODE ###

a = int(input())
b = int(input())
c = [1, 2, 3]

c.remove(a)
c.remove(b)

print(c[0])
def(a,b,c):
  if a%2+b%2+c%2>0:
    return 0
  if a==b==c:
    return -1
  return f((b+c)//2,(c+a)//2,(a+b)//2)+1

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

### FIXED CODE ###

def f(a,b,c):
  if a%2+b%2+c%2>0:
    return 0
  if a==b==c:
    return -1
  return f((b+c)//2,(c+a)//2,(a+b)//2)+1

a,b,c=map(int,input().split())
print(f(a,b,c))
N=int(input())
A=list(map(int,input().split()))
print(*A[::-2],*A[N%2::2])

### FIXED CODE ###

n = int(input())
A = list(map(int,input().split()))
answer = A[1::2][::-1]+A[::2]
if n%2==1:
    answer=answer[::-1]
print(*answer)
Sa = list(input())
Sb = list(input())
Sc = list(input())
d = Sa.pop(0)
for i in range(305):
  if d == "a":
    d = Sa.pop(0)
  elif d == "b":
    d = Sb.pop(0)
  else:
    d = Sc.pop(0)
  if Sa == [] and d == "a":
    print("A")
    break
  elif Sb == [] and d == "b":
    print("B")
    break
  elif Sc == [] and d == "c":
    print("C")
    break

### FIXED CODE ###

Sa = list(input())
Sb = list(input())
Sc = list(input())
d = Sa[0]
for i in range(300):
  if d == "a":
    d = Sa.pop(0)
  elif d == "b":
    d = Sb.pop(0)
  else:
    d = Sc.pop(0)
  if Sa == [] and d == "a":
    print("A")
    break
  elif Sb == [] and d == "b":
    print("B")
    break
  elif Sc == [] and d == "c":
    print("C")
    break
import sys
from collections import deque
import bisect
import math
import itertools
from queue import deque
from math import gcd

INF = float('inf')
mod = 10**9+7
eps = 10**-7


def inp(): return int(sys.stdin.readline())


def inp_list(): return list(map(int, sys.stdin.readline().split()))


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


N, M = inp_list()
X = inp_list()
X.sort()
# print(X)

d = []
for i in range(M - 1): d.append(X[i + 1] - X[i])
# print(d)
d.sort()
ans = sum(d[: - (N - 1)])
print(ans)


### FIXED CODE ###

import sys
# from collections import deque
# import bisect
# import math
# import itertools
# from queue import deque
# from math import gcd

INF = float('inf')
mod = 10**9+7
eps = 10**-7


def inp(): return int(sys.stdin.readline())


def inp_list(): return list(map(int, sys.stdin.readline().split()))


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


N, M = inp_list()
X = inp_list()
X.sort()
# print(X)

if N >= M:
    print(0)
    exit()

d = [X[i + 1] - X[i] for i in range(M - 1)]
# for i in range(M - 1): d.append(X[i + 1] - X[i])
# print(d)
d.sort()
# ans = sum(d[: - (N - 1)])
ans = 0
for i in range(M - 1 -  (N - 1)):
    ans += d[i]
print(ans)
import math
#素因数分解
def factorization(n):
    arr = [[1, 1]]
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

a, b = map(int, input().split())
g = math.gcd(a, b)
l = factorization(g)
print(len(l))

### FIXED CODE ###

def factorization(n):
    arr = [[1, 1]]
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr
def gcd(x, y):
    if y == 0:
        return x
    else:
        return gcd(y, x % y)
a, b = map(int, input().split())
g = gcd(a, b)
l = factorization(g)
print(len(l))