Harryxun/stf_run huggingface dataset:
S = input()
if S.count('9') >= 1:
  print('Yes')
elss:
  print('No')

### FIXED CODE ###

S = input()
if S.count('9') >= 1:
  print('Yes')
else:
  print('No')
t=input()
a,*b,c=t
print(a+int(len(b))+c)


### FIXED CODE ###

t=input()
a,*b,c=t
print(a+str(len(b))+c)
import sys
a, b, c = map(int, input().split())
k = int(input())
while True:
    if b <= a:
        b = b*2
        k += -1
        if k == 0:
            print('No')
            sys.exit(1)
    else:
        break
while True:
    if c <= b:
        c = c*2
        k += -1
        if k == 0:
            print('No')
            sys.exit(1)
    else:
        break
print('Yes')

### FIXED CODE ###

import sys
a, b, c = map(int, input().split())
k = int(input())
while True:
    if b <= a:
        b = b*2
        k += -1
        if k < 0:
            print('No')
            sys.exit()
    else:
        break
while True:
    if c <= b:
        c = c*2
        k += -1
        if k < 0:
            print('No')
            sys.exit()
    else:
        break
print('Yes')
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left
import random
from itertools import permutations, accumulate, combinations
import sys
import string


INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
mod = 10 ** 9 + 7


n, c = LI()
L = [0] * (10 ** 5 + 1)
for s, t, c in LIR(n):
    L[s] += 1
    L[t + 1] -= 1



print(max(accumulate(L)))


### FIXED CODE ###

from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left
import random
from itertools import permutations, accumulate, combinations
import sys
import string


INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
mod = 10 ** 9 + 7


n, c = LI()
L = [0] * (10 ** 5 + 2)
each_channel = [[] for _ in range(c)]
for s, t, k in LIR(n):
    each_channel[k - 1] += [(s, t)]



for i in each_channel:
    i.sort()


for i in range(c):
    pre_t = -1
    for j in range(len(each_channel[i])):
        s, t = each_channel[i][j]
        if j >= 1 and pre_t == s:
            L[pre_t + 1] += 1
            L[t + 1] -= 1
        else:
            L[s] += 1
            L[t + 1] -= 1
        pre_t = t


print(max(accumulate(L)))
N = int(input())
Lists = []
ans = 0
for _ in range(3):
    s = [int(e) for e in input().split()]
    s.sort()
print(Lists)
def binary(right,left,i,j):
    global ans
    while(right >= left):
        mid =int(left + (right-left) / 2)
        if(i>=Lists[j][mid]):
            left = mid + 1
        else:
            right = mid - 1
    if(j == 2 and left <= N-1):
        ans += N-left
    elif(left <= N-1):
        for k in range(left,N):
            binary(N-1,0,Lists[j][k],j+1)
for i in Lists[0]:
    binary(N-1,0,i,1)
print(ans)

### FIXED CODE ###

N = int(input())
Lists = []
ans = 0
for _ in range(3):
    s = [int(e) for e in input().split()]
    s.sort()
    Lists.append(s)
def bin(i,j):
    global t,s
    right = N-1;left = 0
    while(right >= left):
        mid = int(left + (right-left)/2)
        if(j==0):
            if(i>Lists[j][mid]):
                left = mid + 1
            else:
                right = mid -1
        else:
            if(i>=Lists[j][mid]):
                left = mid + 1
            else:
                right = mid - 1
    if(j == 0):
        t = left
    else:
        s = N - left
for i in Lists[1]:
    bin(i,0)
    bin(i,2)
    ans += t*s
print(ans)
import numpy as np
N,M = map(int,input().split())
A = np.array([0]+[int(x) for x in input().split()],dtype=np.int64)
A_cum = np.mod(A.cumsum(),M)

counter = np.bincount(A_cum)
counter[0] += 1 # empty
answer = (counter * (counter-1)).sum() // 2
print(answer)

### FIXED CODE ###

import numpy as np
from collections import Counter

N,M = map(int,input().split())
A = np.array([0]+[int(x) for x in input().split()],dtype=np.int64)
A_cum = np.mod(A.cumsum(),M)

c = Counter(A_cum)

answer = 0
for x in c.values():
  answer += x*(x-1)//2
print(answer)
a = list(map(int, input().split()))
k = int(input())
count = 0

while a[1] <= a[0]:
    a[1] = a[1]*2
    count += 1
while a[2] <= a[1]:
    a[2] = a[2]*2
    count += 1

if count > k:
    print(no)
else:
    print(yes)

### FIXED CODE ###

a = list(map(int, input().split()))
k = int(input())
count = 0

while a[1] <= a[0]:
    a[1] = a[1]*2
    count += 1
while a[2] <= a[1]:
    a[2] = a[2]*2
    count += 1

if count > k:
    print('No')
else:
    print('Yes')
n = int(input())
cards = list(sorted(map(int, input()), reverse=True))

a = sum(cards[0::2])
b = sum(cards[1::2])

print(a - b)




### FIXED CODE ###

n = int(input())
cards = list(sorted(map(int, input().split()), reverse=True))

a = sum(cards[0::2])
b = sum(cards[1::2])

print(a - b)
def dfs_v(u):
  color[u] = 1
  t += 1
  d[u] = t
  for v in range(n):
    if M[u][v] == 0 and color[v] == 0:
      dfs_v(v)
  color[u] = 2
  t += 1
  f[u] = t

def dfs():
  color = [0 for i in range(n)]
  t = 0
  for u in range(n):
    dfs_v(u)
  for u in range(n):
    print u+1, d[u], f[u]

n = input()

color = [0 for i in range(100)]
d = [0 for i in range(100)]
f = [0 for i in range(100)]
M = [0 for i in range(n)]0 for j in range(n)]

for i in range(n):
  u, k = map(int, raw_input().split())
  for j in range(k):
   v = input()
   M[u-1][v-1] = 1

dfs()
    

### FIXED CODE ###

n = int(raw_input())
 
d = [0 for i in range(n)]
f = [0 for i in range(n)]
G = [0 for i in range(n)]
M = [[0 for i in range(n)] for j in range(n)]
col = [0 for i in range(n)]
t = [0]
 
def DFS_visit(u):
    col[u] = 1
    t[0] += 1
    d[u] = t[0]
    for v in range(n):
        if M[u][v] == 1 and col[v] == 0:
            DFS_visit(v)
    col[u] = 2
    t[0] += 1
    f[u] = t[0]
 
def DFS():
    for u in range(n):
        if col[u] == 0:
            DFS_visit(u)
    for u in range(n):
        print'{0} {1} {2}'.format(u+1, d[u], f[u])
     
for i in range(n):
    X = map(int, raw_input().split())
    for j in range(X[1]):
        M[X[0]-1][X[2+j]-1] = 1
 
DFS()
n = int(input())
a = list(map(int, input().split()))
c1_list = [0]*n
for i in range(n):
  b = format(a[i], '060b')
  for j in b:
    if j == "1":
      c1_list[j] += 1
count = 0
for i in range(n):
  count = (count + c1_list[i]*(n-c1_list[i])*2**(60-i)) % 1000000007
print(count)

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
c1_list = [0]*60
for i in range(n):
  b = format(a[i], '060b')

  for j in range(len(b)):
    if b[j] == "1":
      c1_list[j] += 1
count = 0
for i in range(60):
  count = (count + c1_list[i]*(n-c1_list[i])*2**(59-i)) % 1000000007
print(count)
A,B = int(input().split())
print(AxB)

### FIXED CODE ###

A,B = map(int,input().split())
print(A*B)
a,b = map(int, intput().split())
if a>=9 or b>=9:
  print(':(')
else:
  print('Yay!')

### FIXED CODE ###

a,b = map(int, input().split())
if a>=9 or b>=9:
  print(':(')
else:
  print('Yay!')
n = int(input())
p = list(map(int, input().split()))

min = p[1]
count = 1

for i in range(1,n):
    if p[i] <= min:
        count += 1
        min = p[i]

print(count)

### FIXED CODE ###

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

min = p[0]
count = 1

for i in range(1,n):
    if p[i] <= min:
        count += 1
        min = p[i]

print(count)
import math

r = 999999
sqrt = int(math.sqrt(r))
prime = "1"*r
prime[0] = 0
for i in range(2,r/2):
    prime[2*i-1] = 0
for i in range(3,sqrt,2):
    for j in range(2*i,r+1,i):
        prime[j-1] = 0

while True:
    try:
        n = int(raw_input())
        print sum(prime[:n])
    except:
        break

### FIXED CODE ###

import math
n = []
while True:
    try:
        n.append(int(raw_input()))
    except:
        break
  
r = max(n)+1
sqrt = int(math.sqrt(r))
p = [1]*r
p[0] = 0
p[3::2] = [0 for x in range(3,r,2)]
for i in range(2,sqrt,2):
    if p[i]:
        p[2*i+1::i+1] = [0 for x in range(2*i+1,r,i+1)] 
  
for i in n:
     print sum(p[:i])
print(*input().split(',')

### FIXED CODE ###

print(*input().split(','))
a = [int(input()) for _ in range(5)]
b = min([i%10 for i in a if i%10 != 0],0)
print(sum([((i + 9)//10 *10) for  i in a]) - (10-b) )

### FIXED CODE ###

a = [int(input()) for _ in range(5)]
b = [i%10 for i in a if i%10 !=0]
if len(b)==0:
  b=0
else:
  b= 10 - min(b)
print(sum([((i + 9)//10 *10) for  i in a]) - b)
N, K = map(int, input().split())
A = list(map(int, input().split()))
 
A = sorted(A, key = lambda x:abs(x), reverse=True)
#print(A)
 
ans = []
negidx = 0
posidx = 0
neg = False
for i in range(K):
  a = A[i]
  ans.append(a)
  if a<0:
    negidx = i
    neg = not neg
  else:
    posidx = i
#print(ans, neg, negidx)
answer = 1
if neg:
  poppos = list(ans)
  pg = poppos.pop(posidx)
  popneg = list(ans)
  ng = popneg.pop(negidx)
  pgratio = None
  ngratio = None
  found = 0
  for i in range(K+1, N):
    if A[i]>=0 and ngratio is None:
      found = 1
      popneg.append(A[i])
      ngratio = -A[i]/ng
    if A[i]<0 and pgratio is None:
      found = 2
      poppos.append(A[i])
      pgratio = -A[i]/pg
    if pgratio is not None and npratio is not None:
      found = 3
      break
  if found == 1:
    for a in popnep:
      answer *= abs(a)%1000000007
    print(answer%1000000007)
  elif found == 2:
    for a in poppos:
      answer *= abs(a)%1000000007
    print(answer%1000000007)
  elif found == 3:
    if pgratio > ngratio:
      for a in poppos:
        answer *= abs(a)%1000000007
      print(answer%1000000007)
    else:
      for a in popneg:
        answer *= abs(a)%1000000007
      print(answer%1000000007)
  else:
    for i in range(K):
      answer *= A[-(i+1)]%1000000007
    print(answer%1000000007)
else:
  for a in ans:
    answer *= abs(a)%1000000007
  print(answer%1000000007)
      

### FIXED CODE ###

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

A_neg = []
A_pos = []

for i in range(N):
  if A[i] <= 0:
    A_neg.append(-A[i])
  else:
    A_pos.append(A[i])

A_neg.sort(reverse=True)
A_pos.sort(reverse=True)

ans = 1

if K == N:
  for i in range(N):
    ans *= (A[i]%1000000007)
    ans %= 1000000007
  print(ans)

elif K%2==1 and len(A_pos)==0:
  for i in range(1, K+1):
    ans *= ((-A_neg[-i])%1000000007)
    ans %= 1000000007
  print(ans)

else:
  if K%2==1:
    ans *= A_pos.pop(0)
    K -= 1
  buf = []
  for i in range(len(A_pos)//2):
    buf.append(A_pos[2*i]*A_pos[2*i+1])
  for i in range(len(A_neg)//2):
    buf.append(A_neg[2*i]*A_neg[2*i+1])
  buf.sort(reverse=True)
  for i in range(K//2):
    ans *= (buf[i]%1000000007)
    ans %= 1000000007
  print(ans)
print('ABD'if input()>999 else'ABC')

### FIXED CODE ###

print('ABD'if int(input())>999else'ABC')
while True:
    try:
        line = input()
        res = ""
        for i in range(len(line)-2):
            if line[i+1]-line[i]<= line[-1]:
                res = "Yay!"
            else:
                res = ":("
                break
        print(res)
    except EOFError:
        break

### FIXED CODE ###

a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
k = int(input())
if a<b<c<d<e :
  if e - a <= k :
    if d - a <= k:
      if c - a <= k:
        if b - a <= k:
          print('Yay!')
  else:
    print(":(")
a=set(int,input().split())
print(len(a)

### FIXED CODE ###

a=set(map(int,input().split()))
print(len(a))
S,T=input().split('')
print(T+S)

### FIXED CODE ###

S,T=input().split(' ')
print(T+S)
print((L**3)/27)

### FIXED CODE ###

L=int(input())
print((L**3)/27)
import math
print((int(input())*2*math.pi())

### FIXED CODE ###

r=int(input())
print(2*r*3.141592)
N = int(input())
a = [int(input()) for _ in range(N)]

button = 0
for i in range(1,N+1):
    button = a[a[button]-1]
    if button == 2:
        print(i)
else:
    print(-1)

### FIXED CODE ###

N = int(input())
a = [int(input()) for _ in range(N)]

button = 1
for i in range(N):
    if button == 2:
        print(i)
        break
    button = a[button-1]
    
else:
    print(-1)
import sys
input = lambda: sys.stdin.readline().rstrip()

# UnionFind
class UnionFind:
    def __init__(self,n):
        self.n=n
        self.a=[-1]*n
        self.siz=n
    def root_find(self,x):
        if self.a[x]<0:
            return x
        else:
            self.a[x]=self.root_find(self.a[x])
            return self.a[x]
    def unite(self,x,y):
        x=self.root_find(x)
        y=self.root_find(y)
        if self.a[x]<self.a[y]:
            self.a[x]+=self.a[y]
            self.a[y]=x
        else:
            self.a[y]+=self.a[x]
            self.a[x]=y
    def root_same(self,x,y):
        return self.root_find(x)==self.root_find(y)

n,q=map(int,input().split())
u=UnionFind(n)
for _ in range(q):
    t,a,b=map(int,input().split())
    if t==0:
        u.unite(a,b)
    else:
        print(u.root_same(a,b)+0)

### FIXED CODE ###

# UnionFind
import sys
sys.setrecursionlimit(10**9)
class UnionFind:
  def __init__(self, n):
    self.n = [-1]*n
    self.r = [0]*n
    self.siz = n

  def find_root(self, x):
    if self.n[x] < 0:
      return x
    else:
      self.n[x] = self.find_root(self.n[x])
      return self.n[x]

  def unite(self, x, y):
    x = self.find_root(x)
    y = self.find_root(y)
    if x == y:
      return
    elif self.r[x] > self.r[y]:
      self.n[x] += self.n[y]
      self.n[y] = x
    else:
      self.n[y] += self.n[x]
      self.n[x] = y
      if self.r[x] == self.r[y]:
        self.r[y] += 1
    self.siz -= 1

  def root_same(self, x, y):
    return self.find_root(x) == self.find_root(y)

  def count(self, x):
    return -self.n[self.find_root(x)]

  def size(self):
    return self.siz

n,q=map(int,input().split())
uf=UnionFind(n)
for _ in range(q):
  t,u,v=map(int,input().split())
  if t==0:
    uf.unite(u,v)
  else:
    print(uf.root_same(u,v)+0)
s = input()
nlen = len(s)
a = min([abs(int(s[i:i+3])-753) for i in range(nlen-2+1)])
print(a)


### FIXED CODE ###

a = int(input())
if a==3 or a==5 or a==7:
	print("YES")
else:
	print("NO")
from collections import*
n, *v = map(int, open(0).read().split())
a, b = [Counter(v[i::2]).most_common() + [(0,0)] for i in (0,1)]
s, x = a[0]
t, y = b[0]
print(n - [x+y, max(x+b[1][1], y+a[1][1])][s==t])

### FIXED CODE ###

print(1110 - int(input()))
import fractions

N = int(input())
r = [int(input()) for _ in range(5)]

m_r = min(r)
print(fractions.ceil(N/m_r) + 4)

### FIXED CODE ###

import math
N = int(input())
r = [int(input()) for _ in range(5)]

m_r = min(r)
print(math.ceil(N/m_r) + 4)
N, K = map(int, input().split())
pi = list(map(int, input().split()))

max = 0
maxi = 0
for i in range(N - K):
    tmp = sum(pi[i : i + K - 1])
    if tmp > max:
        max = tmp
        maxi = i

out = 0
for j in range(K)
    exp = (pi[j + maxi] + 1) / 2
    out = out + exp

print(out)

### FIXED CODE ###

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

tmp = sum(pi[0 : K])
max = tmp

if N == K:
    print((max + K) / 2)
else:
    for i in range(N - K):
        tmp = tmp - pi[i] + pi[i + K]
        if tmp > max:
            max = tmp
    print((max + K) / 2)
class UnionFind:
  par = None
  
  def __init__(self, n):
    self.par = [0] * n
    
  def root(self, x):
    if(self.par[x] == 0):
      return x
    else:
      self.par[x] = self.root(self.par[x])
      return self.root(self.par[x])
  
  def unite(self, x, y):
    if(self.root(x) != self.root(y)):
      self.par[self.root(x)] = self.root(y)
      
  def same(self, x, y):
    return self.root(x) == self.root(y)
  
N, M = list(map(int, input().split()))
UF = UnionFind(N)
for i in range(M):
  print(UF.par)
  A, B = list(map(int, input().split()))
  UF.unite(A - 1, B - 1) 
ans = 0
for i in range(N):
  if(UF.par[i] == 0):
    ans += 1
print(UF.par)
print(ans - 1)  


### FIXED CODE ###

class UnionFind:
  par = None
  
  def __init__(self, n):
    self.par = [0] * n
    
  def root(self, x):
    if(self.par[x] == 0):
      return x
    else:
      self.par[x] = self.root(self.par[x])
      return self.root(self.par[x])
  
  def unite(self, x, y):
    if(self.root(x) != self.root(y)):
      self.par[self.root(x)] = self.root(y)
      
  def same(self, x, y):
    return self.root(x) == self.root(y)
  
N, M = list(map(int, input().split()))
UF = UnionFind(N)
for i in range(M):
  A, B = list(map(int, input().split()))
  UF.unite(A - 1, B - 1) 
ans = 0
for i in range(N):
  if(UF.par[i] == 0):
    ans += 1
print(ans - 1)
from collections import deque
n, k = map(int, input().split())
P = deque(map(int, input().split()))

s_max = 0
popped = 0
P_max = deque([])
for i in range(k):
    popped = P.popleft()
    P_max.append(popped)
    s_max += popped
s = s_max
# print(s)
P_extracted =　deque(list(P_max))
while P != deque([]):
    # print(P_extracted, P, P_max)
    s -= P_extracted.popleft()
    popped = P.popleft()
    s += popped
    # print(s)

    # P_extracted.popleft()
    P_extracted.append(popped)
    # print(P_extracted)
    if s_max < s:
        s_max = s
        P_max = deque(list(P_extracted))
        # print(s_max, P_max)

# print(s_max, P_max)
e = 0
for i in P_max:
    # tmp = 0
    e += sum(range(1, i+1)) / i
    # print(tmp)
    # e += tmp
print(e)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline    ####
int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

def tsum(l, r):
    return (r + l) * (r - l + 1) // 2

def exp(num):
    return tsum(1, num) / num

def solve():
    n, k = MI()
    P = LI()

    E = [0] * n
    pre = 0
    for i in range(n):
        E[i] = pre + exp(P[i])
        pre = E[i]
    # print(E)

    p = E[0]
    mx = E[k-1]
    for j in range(k, n):
        diff = E[j] - E[j-k]
        # print(diff)
        if mx < diff:
            mx = diff
    print(mx)


if __name__ == '__main__':
    solve()
k =int(input())
a, b = map(int, input().split())
 
for i in range(a, b):
    j = i % k
    if (j == 0):
        break
   
if(j == 0):
    print("OK")
else:
    print("NG")

### FIXED CODE ###

k =int(input())
a, b = map(int, input().split())
 
for i in range(a, b+1):
    if (i % k == 0):
        print("OK")
        break
else:
    print("NG")
n=int(input())
sum = 0
for i in range(n):
  a,b=map(input().split())
  if b == "JPY":
    sum += int(a)
  else:
    sum += int(a)*380000
print(sum)

### FIXED CODE ###

n=int(input())
sum = 0
for i in range(n):
  s = input().rstrip().split(' ')
  a=float(s[0])
  b=str(s[1])
  if b == "JPY":
    sum += int(a)
  else:
    sum += float(a)*380000
print(sum)
N = int(input())
if N >= 90 or (N+1)%10 is 0:
        print("Yes")
    else:
        print("No")

### FIXED CODE ###

N = int(input())

if N >= 90:
    print("Yes")
elif (N+1)%10 is 0:
    print("Yes")
else:
     print("No")
# The question itself is not diffifult, but the website only 
# tested my code with two cases, so I am not sure whether the 
# "accepted" is trustworthy.

# Note: math.inf > math.inf -> False

import math
V = int(input())
E = int(input())
fees = [[math.inf] * V for i in range(V)]
for i in range(V): 
	fees[i][i] = 0
for i in range(E):
	a, b, c, d = map(int, input().split(','))
	fees[a-1][b-1] = c
	fees[b-1][a-1] = d
start, end, funding, cost = map(int, input().split(','))
for i in range(V):
	for j in range(V):
		for k in range(V):
			if (fees[j][k] > fees[j][i] + fees[i][k]):
				fees[j][k] = fees[j][i] + fees[i][k]
if (fees[start-1][end-1]==math.inf or fees[end-1][start-1]==math.inf):
	print(0)
else:
	print(funding-cost-fees[start-1][end-1]-fees[end-1][start-1])

### FIXED CODE ###

# The question itself is not diffifult, but the website only 
# tested my code with two cases, so I am not sure whether the 
# "accepted" is trustworthy.

# Note: math.inf > math.inf -> False

import math
V = int(input())
E = int(input())
fees = [[math.inf] * V for i in range(V)]
for i in range(V): 
	fees[i][i] = 0
for i in range(E):
	a, b, c, d = map(int, input().split(','))
	fees[a-1][b-1] = c
	fees[b-1][a-1] = d
start, end, funding, cost = map(int, input().split(','))
for i in range(V):
	for j in range(V):
		for k in range(V):
			if (fees[j][k] > fees[j][i] + fees[i][k]):
				fees[j][k] = fees[j][i] + fees[i][k]
if (fees[start-1][end-1]==math.inf or fees[end-1][start-1]==math.inf):
	print(0)
else:
	print(funding-cost-fees[start-1][end-1]-fees[end-1][start-1])
N = int(input())
if N / 9 == 0:
    print("Yes")
else :
    print("No")

### FIXED CODE ###

N=int(input())
if N%9 == 0:
    print("Yes")
else:
    print("No")
S=list(input())

count=0
max=0

for moji in list:
  if moji==("A"or"T"or"G"or"C"):
    count+=1
    if count>max:
      max=count
  else:
    count=0
print(max)

### FIXED CODE ###

S = list(input())

count = 0
max = 0

for moji in S:
    if moji == "A"or moji == "T"or moji == "G"or moji == "C":
        count += 1
        if count > max:
            max = count
    else:
        count = 0
print(max)
D, N = map(int, input().split())
li = [i * 100 ** D for i in range(1, N + 1)]
print(li[N])


### FIXED CODE ###

D, N = map(int, input().split())
li = []
cnt = 1
while len(li) < N:
    if cnt % 100 != 0:
        li.append(cnt * 100 ** D)
    cnt += 1

print(li[-1])
# input
A, B, K = map(int, input().split())

# check
if K == 1:
    print(1)
else:
    cnt, op = 1, 1
    div_nums = []
    append = div_nums.append
    for i in range(2, min(A, B) + 1):
        if A % i == 0 and B % i == 0:
            append(i)
    
    print(div_nums[-K])

### FIXED CODE ###

# input
A, B, K = map(int, input().split())

# check
div_nums = [1]
append = div_nums.append
for i in range(2, min(A, B) + 1):
    if A % i == 0 and B % i == 0:
        append(i)

print(div_nums[-K])
n = int(input())
nn = int(pow(n,1/5)) + 1
for i in range(nn):
    b = pow(i ** 5 - n, 1/5)
    if float.is_integer(b):
        break

print(i,int(-b))

### FIXED CODE ###

from decimal import Decimal
n = int(input())
nn = int(pow(n,1/5)) + 1
for i in range(-200,200):
    cheak = i ** 5 - n
    ans = float(pow(Decimal(abs(cheak)), Decimal("0.2")))

    if type(ans) is float:

        if ans.is_integer():
            if cheak < 0:
                b = -1 * ans
            else:
                b = ans
            print(i,int(b))
            break
ans=0
right=0
left=0
for i in range(n):
    left=min(a[i],b[i])
    ans+=left
    a[i]-=left
    b[i]-=left
    
    right=min(a[i+1],b[i])
    ans+=right
    a[i+1]-=right
    b[i]-=right
print(ans)

### FIXED CODE ###

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

ans=0
right=0
left=0
for i in range(n):
    left=min(a[i],b[i])
    ans+=left
    a[i]-=left
    b[i]-=left
    
    right=min(a[i+1],b[i])
    ans+=right
    a[i+1]-=right
    b[i]-=right
print(ans)