Harryxun/stf_run huggingface dataset:
import math

n = int(input())
mincost = [None]*n

def cost(n,h):
  if (mincost[n-1] is not None):
    return mincost[n-1]
  elif (n == 1):
    mincost[n-1] = 0
  elif (n == 2):
    mincost[n-1] =  abs(h[1] - h[0])
  else:
    mincost[n-1] = min(cost(n-1,h) + abs(h[n-1]-h[n-2]), cost(n-2,h) + abs(h[n-1]-h[n-3]))
  return mincost[n-1]

h = [None]*n

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

print(cost(n,h))


### FIXED CODE ###

import math
import sys
sys.setrecursionlimit(10**6)

n = int(input())
mincost = [None]*n

def cost(n,h):
  if (mincost[n-1] is not None):
    return mincost[n-1]
  elif (n == 1):
    mincost[n-1] = 0
  elif (n == 2):
    mincost[n-1] =  abs(h[1] - h[0])
  else:
    mincost[n-1] = min(cost(n-1,h) + abs(h[n-1]-h[n-2]), cost(n-2,h) + abs(h[n-1]-h[n-3]))
  return mincost[n-1]

h = [None]*n

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

print(cost(n,h))
# https://atcoder.jp/contests/abc043/tasks/abc043_a
N = int(input())

print(ame(N))

def ame(N):
    sum = 0
    for i = 1 To N:
        sum += i

### FIXED CODE ###

N = int(input())

def ame(N):
    total = 0
    for i in range(1, N + 1):
        total += i
    return total
    
print(ame(N))
n,i=int(input("enter the numbers"))
x=n-i+1
Print("the result")
print(x)

### FIXED CODE ###

t,i = map(int,input().split(" "))
j=t-i+1 
print(j)
a=list(map(int,input().split()))
b=[]
b.append(a[2])
b.append(a[0])
b.append(a[1])                                                                     for i in range(len(b)):
    print(str(b[i])+' ',end='')
print()

### FIXED CODE ###

a=list(map(int,input().split()))
b=[]
b.append(a[2])
b.append(a[0])
b.append(a[1])
for i in range(len(b)):
    print(str(b[i])+' ',end='')
print()
import numpy as np
N = int(input())
XL = []
for n in range(N):
    XL.append([int(x) for x in input().split()])
XL = sorted(XL, key=lambda x:x[1])
s = np.zeros(2*(10**9))
ans = 0
for n in range(N):
    a = s[max(XL[n][0]-XL[n][1],-1)+1:XL[n][0]+XL[n][1]]
    if a.max() != 0:
        ans += 1
    else:
        s[max(XL[n][0]-XL[n][1],-1)+1:XL[n][0]+XL[n][1]] += 1
print(N-ans)


### FIXED CODE ###

N = int(input())
XL = []
for n in range(N):
    XL.append([int(x) for x in input().split()])
XL = sorted(XL, key=lambda x:x[0]+x[1])
m = -float("inf")
ans = 0
for n in range(N):
    if XL[n][0]-XL[n][1] >= m:
        ans += 1
        m = XL[n][0]+XL[n][1]
print(ans)
N = int(input())

a = [int(i) for i in input().split()]

count=0
ans=0

for i in range(N):
    if a[i]<0:
        count+=1
    	a[i]=abs(a[i])

if count%2==0:
    ans=sum(a)

else:
    a.sort()
    ans=sum(a)-a[0]*2

print(ans)


### FIXED CODE ###

from fractions import gcd

N = int(input())
a = [int(i) for i in input().split()]

L = []
R = []
L.append(a[0])
R.append(a[-1])

for i in range(N-2):
    L.append(gcd(L[-1], a[i+1]))
    R.append(gcd(R[-1], a[-(i+2)]))

ans = max(L[-1], R[-1])
for i in range(N-2):
    tmp = gcd(L[i], R[-(i+2)])
    if tmp > ans:
        ans = tmp

print(ans)
def resolve():
    N, M = list(map(int, input().split()))
    A = list(map(int, input().split()))
    required = [None]+[2,5,5,4,5,6,3,7,6]
    dp = [0 for _ in range(N+1)]
    candidates = {}
    for a in A:
        req = required[a]
        if dp[req] < a:
            dp[req] = a
            candidates[req] = a
    #print(dp)
    #print(candidates)
    for i in range(N+1):
        for n_match, num in candidates.items():
            if i - n_match >= 0 and dp[i-n_match] != 0:
                dp[i] = max(dp[i], dp[i-n_match]*10+num)
    #print(dp)
    print(dp[N])

if '__main__' == __name__:
    resolve()

### FIXED CODE ###

def resolve():
    N, M = list(map(int, input().split()))
    A = list(map(int, input().split()))
    required = [None]+[2,5,5,4,5,6,3,7,6]
    dp = [0 for _ in range(max(10, N+1))]
    candidates = {}
    for a in A:
        req = required[a]
        if dp[req] < a:
            dp[req] = a
            candidates[req] = a
    #print(dp)
    #print(candidates)
    for i in range(N+1):
        for n_match, num in candidates.items():
            if i - n_match >= 0 and dp[i-n_match] != 0:
                dp[i] = max(dp[i], dp[i-n_match]*10+num)
    #print(dp)
    print(dp[N])

if '__main__' == __name__:
    resolve()
x, y, z, k = map(int, input().split())
a =list(map(int, input().split()))
b =list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse = True)
b.sort(reverse = True)
c.sort(reverse = True)
ab =[]
abc = []
for i in a:
    for j in b:
        ab.append(i+j)
ab.sort(reverse = True)
m = min(K, X*Y)
ab = ab[:m+1]
for i in ab:
    for j in c:
        abc.append(i +j)
abc.sort(reverse = True)
for i in abc:
    print(i)

### FIXED CODE ###

x, y, z, k = map(int, input().split())
a =list(map(int, input().split()))
b =list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse = True)
b.sort(reverse = True)
c.sort(reverse = True)
abc = []
for i in range(x):
    if (i+1) > k:
        break
    for j in range(y):
        if (i+1)*(j+1) > k:
            break
        for h in range(z):
            if (i+1)*(j+1)*(h+1) >k:
                break
            abc.append(a[i] +b[j] +c[h])
abc.sort(reverse = True)
for i in range(k):
    print(abc[i])
import numpy as np

k = int(input())

answer = 0
for a in range(1, k+1):
    for b in range(1, k+1):
        for c in range(1, k+1):
            answer += np.gcd.reduce([a,b,c])

print(answer)

### FIXED CODE ###

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
 
K = int(read())
 
x = np.arange(1, K + 1)
nums = np.gcd.outer(np.gcd.outer(x, x), x)
print(nums.sum())
c = [list(map(int, input().split())) for _ in range(3)]
try:
    assert (sum(c[2]) - sum(c[1])) % 3 == 0
    assert (sum(c[1]) - sum(c[0])) % 3 == 0
    assert (sum([c[2] for line in c]) - sum([c[1] for line in c])) % 3 == 0
    assert (sum([c[1] for line in c]) - sum([c[0] for line in c])) % 3 == 0
    print("Yes")
except AssertionError:
    print("No")


### FIXED CODE ###

c = [list(map(int, input().split())) for _ in range(3)]
try:
    assert (sum(c[2]) - sum(c[1])) % 3 == 0
    assert (sum(c[1]) - sum(c[0])) % 3 == 0
    assert (sum([line[2] for line in c]) - sum([line[1] for line in c])) % 3 == 0
    assert (sum([line[1] for line in c]) - sum([line[0] for line in c])) % 3 == 0
    print("Yes")
except AssertionError:
    print("No")
n,m=map(int,input().split())
l=[]
g=0
for i in range(m):
  a,b=map(int,input().split())
  a.append(l)
  b.append(l)
  
for j in range(1,n+1):
  g+=l.count(j)
  
print(g)

### FIXED CODE ###

n,m=map(int,input().split())
l=[]
for i in range(m):
  a,b=map(int,input().split())
  l.append(a)
  l.append(b)
  
for j in range(1,n+1):
  print(l.count(j))
print(min(int(input())*int(input()),int(input())))

### FIXED CODE ###

#133 T or T
N,A,B = map(int,input().split())
print(min(N*A,B))
N = int(input())
i = int(input())

print(N-i+1)

### FIXED CODE ###

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


num = N-i+1
print(num)
n = int(input())
a = list(map(int, input().split()))

import math
g=0
for x in a:
  g=math.gcd(g,x)
print(g)


### FIXED CODE ###

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

import fractions
g = 0
for x in a:
  g = fractions.gcd(g,x)
print(g)
x = map(float,input().split(' '))
a = x[0]
b = x[1]
c = x[2]
d = x[3]
e = x[4]
f = x[5]
print round((c*e-b*f)/(a*e-d*b),4),round((c*d-a*f)/(b*d-a*e),4)

### FIXED CODE ###

while True:
	try:
		a,b,c,d,e,f = map(float,raw_input().split(' '))
		p = round((c*e-b*f)/(a*e-b*d),4)
		q = round((a*f-c*d)/(a*e-b*d),4)
		x = '%.3f' % p
		y = '%.3f' % q
		if str(x) == '-0.000': x = '%.3f' % 0.000
		if str(y) == '-0.000': y = '%.3f' % 0.000
		print x,y
	except: break
n = int(input())
a = list(map(int, input().split()))
a.sort()
num = 0


for i in range(n):
    flag = 0
    if i == 0 and a[0]==a[1]:
        continue
    for j in range(i):
        if not a[i]%a[j]:
            flag = 1
            break

    if not flag:
        num += 1

print(num)


### FIXED CODE ###

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

l = [0]*(10**6 +1)
for i in a:
    l[i]+=1
num = 0

for i in range(10**6+1):
    if l[i] == 1:
        num += 1
    if l[i] != 0:
        for j in range(2*i, 10**6+1, i):
            if l[j]:
                l[j] += 1
print(num)
N, M = map(int, input().split())  # N個のコマ, M個の訪れるべき座標

if N >= M:
    print(0)
else:
    A = sorted(list(map(int, input().split())))
    B = sorted(A[i]-A[i-1] for i in range(1, len(A)))
    print(sum[B[:M-N]])


### FIXED CODE ###

N, M = map(int, input().split())  # N個のコマ, M個の訪れるべき座標

if N >= M:
    print(0)
else:
    A = sorted(list(map(int, input().split())))
    B = sorted(A[i]-A[i-1] for i in range(1, len(A)))
    print(sum(B[0:M-N]))
# -*- coding: utf-8 -*-

## Library

import sys
from fractions import gcd
import math
from math import ceil,floor
import collections
from collections import Counter

## input

# n=int(input())
# A,B,C,D=map(int, input().split())
# string = input()
# yoko = list(map(int, input().split()))
# tate = [int(input()) for _ in range(N)]
# N, M = map(int,input().split()) 
#    P = [list(map(int,input().split())) for i in range(M)]

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

## Logic

print(min(N%K,abs(K-N%K))


### FIXED CODE ###

# -*- coding: utf-8 -*-

## Library

import sys
from fractions import gcd
import math
from math import ceil,floor
import collections
from collections import Counter

## input

# n=int(input())
# A,B,C,D=map(int, input().split())
# string = input()
# yoko = list(map(int, input().split()))
# tate = [int(input()) for _ in range(N)]
# N, M = map(int,input().split()) 
#    P = [list(map(int,input().split())) for i in range(M)]

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

## Logic

print(min(N%K,abs(K-N%K)))
s=int(input())
def is_even(num):
    return num % 2 == 0
list=[]
list.append(s)

def calc(s):
	if is_even(int(s)):
		return (int((s)/2))
		list.append(s)
	else:
		return (int((s)*3+1))
		list.append(s)
	s=int(calc(s))
check=[1,2,4]
for (s) in (check):
	if not (s) in (check):
		calc(s)
else:
	print (int(s)+3)


### FIXED CODE ###

a,b,c=list(map(int,(input()).split()))
print (int(((a)*(b))/2))
A,B,C = map(int,input().split())
K = int(input())

X = [A,B,C]
for i in range(K):
  max(X) *= 2

print(sum(X))

### FIXED CODE ###

nums = list(map(int, input().split()))
K = int(input())
for i in range(K):
    nums[nums.index(max(nums))] *= 2

print(sum(nums))
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

def main():
    N, Q = map(int, input().split())
    link = [[] * N]
    a = [None] * (N-1)
    b = [None] * (N-1)
    for i in range(N-1):
        a[i], b[i] = map(int, input().split())

    cost = [0] * N
    for _ in range(Q):
        p, x = map(int, input().split())
        cost[p-1] += x

    for i in range(N-1):
        link[a[i]-1].append([b[i]-1, cost[i]])
        link[b[i]-1].append([a[i]-1, cost[i]])

    def dfs(v, c, p):
        for nv in link[v]:
            if nv[0] == p:
                continue
            cost[nv[0]] = c + cost[nv[0]]
            dfs(nv[0], cost[nv[0]], v)
        return

    dfs(0, cost[0], -1)

    print(*cost)

if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

def dfs(v, p):
    for u in link[v]:
        if u == p:
            continue
        ans[u] += ans[v]
        dfs(u, v)

N, Q = map(int, input().split())
link = [[] for _ in range(N)]
for i in range(N-1):
    a, b = map(int, input().split())
    link[a-1].append(b-1)
    link[b-1].append(a-1)

ans = [0] * N
for i in range(Q):
    p, x = map(int, input().split())
    ans[p-1] += x

dfs(0, -1)

print(*ans)
N,C = map(int,input().split())
D = [list(map(int,input().split())) for i in range(C)]
A = [list(map(int,input().split())) for i in range(N)]

ans = float("inf")

L = []
for i in range(1,C+1,3) :
    L.append([i,i+1,i+2])
    L.append([i,i+2,i+1])
    L.append([i+1,i,i+2])
    L.append([i+1,i+2,i])
    L.append([i+2,i,i+1])
    L.append([i+2,i+1,i])


for i in range(len(L)) :
    p,q,r = L[i]
    
    calc = 0
    
    for j in range(N) :
        for k in range(N) :
            if (j+k) % 3 == 0 :
                calc += D[A[j][k]-1][p-1]
            elif (j+k) % 3 == 1 :
                calc += D[A[j][k]-1][q-1]
            else :
                calc += D[A[j][k]-1][r-1]
    ans = min(ans,calc)
print(ans)



### FIXED CODE ###

N,C = map(int,input().split())
D = [list(map(int,input().split())) for i in range(C)]
L = [list(map(int,input().split())) for i in range(N)]

d0 = {}
d1 = {}
d2 = {}

for i in range(N) :
    for j in range(N) :
        before = L[i][j] - 1
        
        if (i+j) % 3 == 0 :
            if before not in d0 :
                d0[before] = 1
            else :
                d0[before] += 1

        elif (i+j) % 3 == 1 :
            if before not in d1 :
                d1[before] = 1
            else :
                d1[before] += 1

        else :
            if before not in d2 :
                d2[before] = 1
            else :
                d2[before] += 1



A0 = []
A1 = []
A2 = []

for after in range(C) :
    calc = 0
    for before in d0 :
        calc += D[before][after] * d0[before]
    A0.append([calc,after])

for after in range(C) :
    calc = 0
    for before in d1 :
        calc += D[before][after] * d1[before]
    A1.append([calc,after])

for after in range(C) :
    calc = 0
    for before in d2 :
        calc += D[before][after] * d2[before]
    A2.append([calc,after])
    
A0 = sorted(A0,key=lambda x:x[0],reverse=False)[:3]
A1 = sorted(A1,key=lambda x:x[0],reverse=False)[:3]
A2 = sorted(A2,key=lambda x:x[0],reverse=False)[:3]
B = [A0,A1,A2]

ans = float("inf")

for i in range(3) :
    for j in range(3) :
        for k in range(3) :
            if (B[0][i][1] - B[1][j][1]) * (B[1][j][1] - B[2][k][1]) * (B[2][k][1] - B[0][i][1]) == 0 :
                continue
            
            ans = min(ans, B[0][i][0] + B[1][j][0] + B[2][k][0])

print(ans)
a=list(map(int,input().split()));print(min(a[:2])+min(a[2:]))

### FIXED CODE ###

a=int(input())
b=int(input())
c=int(input())
d=int(input())
z=[a,b,c,d]
print(min(z[:2])+min(z[2:]))
n = input()

d = [1000 for i in range(n)]
M = [[0 for i in range(n)] for j in range(n)]

def BFS(s):
  q = []
  q.append(s)
  d[s] = 0
  while q.length != 0:
    u = q.pop()
    for v in range(n):
      if M[u][v] == 0 and d[v] != 1000:
        d[v] = d[u] + 1
        q.push(v)
  for i in range(n):
    print i+1, d[i]

for i in range(n):
  G = map(int, raw_input().split())
  for j in range(G[1]):
    M[G[0]-1][G[2+j]-1] = 1

BFS(0)

### FIXED CODE ###

n = input()
  
d = [-1 for i in range(n)]
M = [[0 for i in range(n)] for j in range(n)]
color = [0 for i in range(n)]
  
def BFS(s):
  color[0] = 1
  q = []
  q.append(s)
  d[s] = 0
  while len(q) != 0:
    u = q[0]
    q.pop(0)
    for v in range(n):
      if M[u][v] == 1 and color[v] == 0:
        color[v] = 1
        d[v] = d[u] + 1
        q.append(v)
  color[u] = 2
  for i in range(n):
    print i+1, d[i]
  
for i in range(n):
  G = map(int, raw_input().split())
  for j in range(G[1]):
    M[G[0]-1][G[2+j]-1] = 1
  
BFS(0)
S = {c: input() for c in "abc"}

s = "a"

while S[s]:
  s = S[s].pop(0)

print(s.upper())

### FIXED CODE ###

import sys

p = ["A", "B", "C"]
p_dic = {"a": 0, "b": 1, "c": 2}

def card(cards, player):
  if len(cards[player]) == 0:
    print(p[player])
    sys.exit()
  else:
    x = cards[player][0]
    cards[player] = cards[player][1:]
    card(cards, p_dic[x])

cards = [input() for i in range(3)]
card(cards, 0)
a,b=map(iNt,input().split())
c=list(map(int,input().split()))
c=[i for i in c if i>a/(4*b)]
if len(c)<b:
  print("No")
else:
  print("Yes")

### FIXED CODE ###

a,b=map(int,input().split())
c=list(map(int,input().split()))
d=sum(c)/(4*b)
e=[i for i in c if i<d]
if len(e)>a-b:
  print("No")
else:
  print("Yes")
s = input()
ans = 'No'
c = s.find('C')
if c != -1:
	f = s[c:].find('F')
    if f != -1:
      ans = 'Yes'
print(ans)

### FIXED CODE ###

s = input()
ans = 'No'
c = s.find('C')
if c != -1:
  f = s[c:].find('F')
  if f != -1:
    ans = 'Yes'
print(ans)
N, *A = map(int, open('0').read().split())
ans = 0
B = sorted(A)
dic = {B[i]:i for i in range(N)}
for i,n in enumerate(A):
  if i%2!=dic[n]%2:
    ans += 1
print(ans//2)

### FIXED CODE ###

N, *A = map(int, open(0).read().split())
ans = 0
B = sorted(A)
dic = {B[i]:i for i in range(N)}
for i,n in enumerate(A):
  if i%2!=dic[n]%2:
    ans += 1
print(ans//2)
s = input()
tmp = ord(s)
ans = tmp += 1
print(chr(ans))

### FIXED CODE ###

s = input()
tmp = ord(s)
ans = tmp + 1
print(chr(ans))
N=int(input())

for i in reversed(range(1,10)):
    if N%i==0:
        if N/i > 9:
            print('No')
            exit(1)
    print('Yes')
    exit(1)  


### FIXED CODE ###

N=int(input())

for i in reversed(range(1,10)):
    if N%i==0:
        if N/i > 9:
            print('No')
            exit(0)
        else:
            print('Yes')
            exit(0)
L=[int(x) for x in input().split()]
sum=0
product=0
mod=1000000007
for i in range(n):
    sum+=L[i]%mod
for i in range(n-1):
    sum-=(L[i]%mod)
    product+=sum*(L[i]%mod)
print(product)


### FIXED CODE ###

n=int(input())
L=[int(x) for x in input().split()]
sum=0
product=0
mod=1000000007
for i in range(n):
    sum+=L[i]%mod
for i in range(n-1):
    sum-=(L[i]%mod)
    product+=sum*(L[i]%mod)
print(product%mod)
n=int(input())
h=list(map(int, input().split()))

a=max([h[i]-min(h[i+1:]) for i in range(n-1)])

if a>1:
  print('No')
else:
  print('Yes')

### FIXED CODE ###

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

index=N-1
output='Yes'
while index>0:
  if h[index-1]-h[index]>1:
    output='No'
    break
  elif h[index-1]-h[index]==1:
    h[index-1]-=1
  else:
    pass
  index-=1
  
print(output)
from itertools import combinations

# input
N = int(input())
print(len(list(combinations([for i in range(1, N + 1)] * 3, 3))))

### FIXED CODE ###

from itertools import combinations

# input
N = int(input())
print(len(set(combinations([i for i in range(1, N + 1)] * 3, 3))))
n = int(input())
li = map(int,input().split())
print('NO' if len(li)!=len(set(li)) else 'YES')

### FIXED CODE ###

input()
li = list(map(int, input().split()))
print('NO' if len(li)>len(set(li)) else 'YES')
N = int(input())
A = sorted(list( map( int, input().split() ) ), reverse=True)
Alice = 0
Bob = 0
for i in range(0,N,2):
    Alice += A[i]
    Bob += A[i+1]
print(Alice-Bob)

### FIXED CODE ###

N = int(input())
A = sorted(list( map( int, input().split() ) ), reverse=True)
Alice = 0
Bob = 0
for i in range(0,N,2):
    Alice += A[i]
    if i+1 <= N-1:
        Bob += A[i+1]
print(Alice-Bob)
n = int(input())
stones = list(map(int, input().split()))

def frog_jump(n:int, stones)->int:
    n, stones = input(), input().split() 
    dp = [float('inf')] * n
    jumps = (1, 2)
    dp[0] = 0
    for idx in range(len(dp)):
        for jump in jumps:
            if idx+jump < len(dp):
                dp[idx+jump] =  min(dp[idx]+abs(stones[idx+jump]-stones[idx]), dp[idx+jump])
    return dp[-1]

frog_jump(n, stones)

### FIXED CODE ###

import sys
sample = sys.stdin.read().splitlines()
n, stones = int(sample[0]), list(map(int, sample[1].split()))
dp = [float('inf')] * n
jumps = (1, 2)
dp[0] = 0
for idx in range(len(dp)):
  for jump in jumps:
    if idx+jump < len(dp):
      dp[idx+jump] =  min(dp[idx]+abs(stones[idx+jump]-stones[idx]), dp[idx+jump])
print(dp[-1])
a = int(input())
b = int(input())
 
x = (a+b)/2
 
if x == int(x):
  print(x)
 
else:
  x += 1
  print(int(x))

### FIXED CODE ###

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

x = (a+b)/2
 
if x == int(x):
  print(int(x))
 
else:
  x += 1
  print(int(x))
a,b,c,k=map(int,input().split())
if k<=a+b:
  print(a)
elif k<=a+b+c:
  print(2a-k+b)
else:
  print(a-c)

### FIXED CODE ###

a,b,c,k=map(int,input().split())
if k<=a:
  print(k)
elif k<=a+b:
  print(a)
else: 
  print(2*a-k+b)
import sys
stdin = sys.stdin
def li(): return map(int, stdin.readline().split())
a, b = tuple(li())
div, mod = divmod(b, a)
if mod == 0:
	return a + b
else:
    return b - a

### FIXED CODE ###

import sys
stdin = sys.stdin
def li(): return map(int, stdin.readline().split())
a, b = tuple(li())
div, mod = divmod(b, a)
if mod == 0:
    print(a + b)
else:
    print(b - a)
N, K = map(int, input())

calc = []
for i in range(1, N+1):
  dice = i
  result = 0
  count = 0
  while result <= K-1
    dice+=dice*2
    count+=1
  calc.append(1/N*(1/2)*count)

print(sum(calc))

### FIXED CODE ###

N, K = map(int, input().split())
 
calc = 0
for i in range(1, N+1):
  tmp = i
  cnt = 0
  while tmp <= K - 1:
    tmp*=2
    cnt+=1
  calc += (1/N) * (1/(2**cnt))

print(calc)
n = int(input())
return sum(range(n))

### FIXED CODE ###

n = int(input())
print( ((n * (n+1))//2) - n )
n, *A = map(int, open(0).read().split())
c = [0]*9
for a in A:
  c[min(8, a//400)] += 1

print(8-c[:-1].count(0))
print(c[8])
cl = 8-c[:-1].count(0)
cmin = max(1, cl)
cmax = min(cl+c[8])
print(cmin, cmax)

### FIXED CODE ###

n, *A = map(int, open(0).read().split())
c = [0]*9
for a in A:
  c[min(8, a//400)] += 1

cl = 8-c[:-1].count(0)
cmin = max(1, cl)
cmax = cl+c[8]
print(cmin, cmax)
sec = input()

hms = [0]*3
for i in range(3):
    tmp = int(sec % 60)
    hms[i] = tmp
    sec = int((sec-tmp)/60)

hms.reverse()

print(str(hms[0])+':'+str(hms[1])+':'+str(hms[2]))

### FIXED CODE ###

sec = int(input())

hms = [0]*3
for i in range(3):
    tmp = int(sec % 60)
    hms[i] = tmp
    sec = int((sec-tmp)/60)

hms.reverse()

print(str(hms[0])+':'+str(hms[1])+':'+str(hms[2]))
import functools
import operator

count = 0
N = int(input())
L = list(map(int,input().split( )))

L2 = functools.reduce(operator.mul,L)

for l in range(L2):
    if L2%2 == 0:
        L2 /= 2
        count += 1
    else:
        break

print(count)

### FIXED CODE ###

count = 0
N = int(input())
L = list(map(int,input().split( )))

for n in range(N):
    for l in range(L[n]):
        if L[n]%2 == 0:
            L[n] /= 2
            count += 1
        else:
            break
            
print(count)
N=input()
X=0
Y=0
for i+1 in range(len(N)):
  if N[i]="R":
    X+=1
  else:
    Y=X
    X=0
print(max(X,Y))
  

### FIXED CODE ###

N=input()
X=0
Y=0
for i in range(len(N)):
  if N[i]=="R":
    X+=1
  else:
    Y=max([X,Y])
    X=0
print(max([X,Y]))
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush
import collections


n,m = map(int, input().split())
par = [i for i in range(n)]
rank = [0]*n

def find(x):
    if par[x] == x:
        return x
    else:
        par[x] = find(par[x])
        return par[x]


def unite(x, y):
    x, y = root(x), root(y)
    if x == y: return
    par[x] = y

def main():
    for _ in range(m):
        a,b = map(int, input().split())
        unite(a-1,b-1)
    count = [0]*n
    for p in par:
        count[find(p)] += 1
    print(max(count))


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush
import collections


n,m = map(int, input().split())
par = [i for i in range(n)]
rank = [0]*n

def find(x):
    if par[x] == x:
        return x
    else:
        par[x] = find(par[x])
        return par[x]

def unite(x, y):
    x = find(x)
    y = find(y)
    if x == y:
        return
    if rank[x] < rank[y]:
        par[x] = y
    else:
        par[y] = x
        if rank[x] == rank[y]:
            rank[x] += 1

def main():
    for _ in range(m):
        a,b = map(int, input().split())
        unite(a-1,b-1)

    count = [0]*n
    for p in par:
        count[find(p)] += 1
    print(max(count))


if __name__ == '__main__':
    main()
s = int(input())
list = [int(n) for n in input().split()]

sum = 0

for i in range(1, s - 1):
    if (list[i] - list[i - 1]) * (list[i + 1] - list[i]) > 0:
        sum += 1

print(sum)


### FIXED CODE ###

def f_f(str):
    for s in str:
        if str.count(s) != 2:
            return False
    return True
 
S = input()
if f_f(S):
    print("Yes")
else:
    print("No")