Harryxun/stf_run huggingface dataset:
from sys import stdin
N = int(stdin.readline().rstrip())
ans = stdin.readline().rstrip()
sum = 0
left = 0
right = 0
for itr in range(0,len(ans)):
    count_dot = 0
    count_sharp = 0
    left = itr
    right = left + 1
    if left == len(ans)-1:
        break
    if ans[left] == '#' and ans[right] == '.':
        while(right < N and ans[right] == '.'):
            count_dot += 1
            right += 1
        while(left >= 0 and ans[left] == '#'):
            count_sharp += 1
            left -= 1
        if tmp != 0:
            count += 1
        sum += max(count_dot, count_sharp)
print(count)

### FIXED CODE ###

from sys import stdin
N = int(stdin.readline().rstrip())
s = stdin.readline().rstrip()
sum = 0
wh = s.count('.')
cnt = 0
for itr in range(N):
    if s[itr] == '#':
        cnt += 1
        continue
    if cnt > 0:
        sum += 1
        cnt -= 1
print(sum)
n,k=map(int,input().split())
x=list(map(int,input().split()))
from bisect import bisect_left as bl

x0=bl(x,0)
if x[x0]==0:
    k-=1
    a=x[:x0]
    a=a[::-1]
    a=list(map(lambda x:-x,a))
    b=x[x0:]
else:
    a=x[:x0]
    a=a[::-1]
    a=list(map(lambda x:-x,a))
    b=x[x0:]
#print(a,b)
ans=float("INF")
if k==0:
    print(0)
    exit()
if k-1<len(a):
    ans=min(ans,a[k-1])
if k-1<len(b):
    ans=min(ans,b[k-1])
for i in range(k):
    j=k-i-2
    if i<len(a) and 0<=j and j<len(b):
        ans2=2*a[i]+b[j]
        ans=min(ans,ans2)
        #print(i,j,ans)
for i in range(k):
    j=k-i-2
    if i<len(b) and 0<=j and j<len(a):
        ans2=b[i]+2*a[j]
        ans=min(ans,ans2)
        #print(i,j,ans)
print(ans)


### FIXED CODE ###

n,k=map(int,input().split())
x=[0]
for xi in input().split():
    xi=int(xi)
    if xi==0:
        k-=1
    else:
        x.append(xi)
x.sort()
ans=float("INF")
zero=x.index(0)
for i in range(max(0,zero-k-1),min(zero+1,n-k+1)):
    if x[i+k]<0 or x[i]>0:
        continue
    jogen=abs(x[i+k])
    kagen=abs(x[i])
    ans=min(ans,jogen*2+kagen,kagen*2+jogen)
print(ans)
a,b = map(input().split())
c = a*b
d = 2*(a+b)

print(str(c)+" "+str(d))

### FIXED CODE ###

a,b = list(map(int, input().split()))
c = 2 * (a+ b)
d = a * b

print(str(d) + " " + str(c))
N=int(inpuit())

p=list(map(int,input().split()))
sort=list(range(1,N+1))
count=[p[i]==sort[i] for i in range(N)].count(True)
if count > 2:
    print("NO")
else:
    print("YES")

### FIXED CODE ###

N=int(input())

p=list(map(int,input().split()))
sort=list(range(1,N+1))
count=list(p[i]==sort[i] for i in range(N)).count(False)
if count > 2:
    print("NO")
else:
    print("YES")
N=int(input())
if N%10==2 or N%10==4 or N%10==5 or N%10==7 or N%10==9:
    print(' hon ')
elif  N%10==0 or N%10==1 or N%10==6 or N%10==8:
    print(' pon ')
elif n%10==3:
    print(' bob ')

### FIXED CODE ###

n=int(input())
N=n%10
if N==3:
  print('bon')
elif N==0 or N==6 or N==8 or N==1:
  print('pon')
else:
  print('hon')
1<=R<=100
Circle_Pond=R*2*3.14
print(Circle_Pond)

### FIXED CODE ###

import math
r=int(input())
print(2*r*math.pi)
def inkousha(w_list, x, y, z):
    w_list[x-1][y-1] += z
    
def answerp(w_list):
    for i in range(3):
        for j in range(10):
            print w_list[i][j],
        print("")
        

n = input()

A1 = [[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,0]]
A2 = [[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,0]]
A3 = [[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,0]]
A4 = [[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,0]]

for i in range(n):
    x = raw_input()
    b, f, r, v = x.split()
    b = int(b)
    f = int(f)
    r = int(r)
    v = int(v)
    
    if b == 1:
        inkousha(A1, f, r, v)
    elif b == 2:
        inkousha(A2, f, r, v)
    elif b == 3:
        inkousha(A3, f, r, v)
    else:
        inkousha(A4, f, r, v)
    
answerp(A1)
print("####################")
answerp(A2)
print("####################")
answerp(A3)
print("####################")
answerp(A4)

### FIXED CODE ###


import sys

def check(x_list, f, r, v):
    x_list[f][r] += v

def peo(x_list):
    for i in range(3):
        for j in range(10):
            sys.stdout.write(" %d" %(x_list[i][j]))
        print ("")

A_bill = [[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,0]]
B_bill = [[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,0]]
C_bill = [[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,0]]
D_bill = [[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,0]]

n = input()
for i in range(n):
    x = raw_input()
    b, f, r, v = x.split()
    b = int(b)
    f = int(f)
    r = int(r)
    v = int(v)
    
    if b == 1:
        check(A_bill, f-1,r-1,v)
    elif b == 2:
        check(B_bill, f-1,r-1,v)
    elif b == 3:
        check(C_bill, f-1,r-1,v)
    elif b == 4:
        check(D_bill, f-1,r-1,v)

peo(A_bill)
print("####################")
peo(B_bill)
print("####################")
peo(C_bill)
print("####################")
peo(D_bill)
import numpy as np

MOD = 10**9+7
D,T,E = input().split()
n= int(D)

print(a)






### FIXED CODE ###

D,T,S = [int(i) for i in input().split()]
out = 'Yes' if D <= T * S else 'No'
print(out)
A, B, K = map(int, input().split())

print(max(0, A-K), max(0, B-max(0, K-A))

### FIXED CODE ###

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

print(max(0, A-K), max(0, B-max(0, K-A)))
N, K = map(int, input())

for i in range(N):
  dice = i+1
  result = 0
  calc = []
  count = 0
  while result <= K
    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)
import numpy as np
N,M,X=map(int,input().split())
C=np.zeros(N,dtype=int)
A=np.zeros([N,M],dtype=int)
for i in range(N):
    T=list(map(int,input().split()))
    C[i]=T[0]
    for j in range(M):
        A[i,j]=T[j+1]
a=np.zeros(N,dtype=int)
ans=-1
while a.all()!=1:
  if ((a@A)>X).all():
    if ans==-1:
        ans=a@(C.T)
    elif a@(C.T)<ans:
        ans=a@(C.T)
  for i in range(N):
    if a[N-i-1]==0:
      a[N-i-1]=1
      break
    else:
      a[N-i-1]=0

a=np.array([0,1,1])
if ((a@A)>=X).all():
  if ans==-1:
      ans=a@(C.T)
  elif a@(C.T)<ans:
      ans=a@(C.T)

print(ans)

### FIXED CODE ###

import numpy as np
N,M,X=map(int,input().split())
C=np.zeros(N,dtype=int)
A=np.zeros([N,M],dtype=int)
for i in range(N):
    T=list(map(int,input().split()))
    C[i]=T[0]
    for j in range(M):
        A[i,j]=T[j+1]
a=np.zeros(N,dtype=int)
ans=-1
while a.all()!=1:
  if ((a@A)>=X).all():
    if ans==-1:
        ans=a@(C.T)
    elif a@(C.T)<ans:
        ans=a@(C.T)
  for i in range(N):
    if a[N-i-1]==0:
      a[N-i-1]=1
      break
    else:
      a[N-i-1]=0

if ((a@A)>=X).all():
  if ans==-1:
      ans=a@(C.T)
  elif a@(C.T)<ans:
      ans=a@(C.T)

print(ans)
from sys import setrecursionlimit
setrecursionlimit(50000)
   
class Node():
    NIL = -1

    def __init__(self, parent=NIL, left=NIL, right=NIL, depth=-1):
        self.parent = parent
        self.left = left
        self.right = right
        self.depth = depth

def read_nodes(T):
    for _ in range(len(T)):
        id, _, *child = [int(x) for x in input().split()]
        for i, c in enumerate(child):
            if i == 0:
                T[id].left = c
            else:
                T[l].right = c
            l = c
            T[c].parent = id

def calc_depth(T):

    def rec(r, p):
        nonlocal T

        T[r].depth = p
        if T[r].right != Node.NIL:
            rec(T[r].right, p)
        if T[r].left != Node.NIL:
            rec(T[r].left, p + 1)

    rec([u.parent for u in T].index(-1), 0)

def node_type(T, id):
    if T[id].parent == Node.NIL:
        return "root"
    elif T[id].left == Node.NIL:
        return "leaf"
    else:
        return "internal node"

def child(T, id):
    c = []
    i = T[id].left
    while i != Node.NIL:
        c.append(i)
        i = T[i].right
    return c

def print_nodes(T):
    for id in range(len(T)):
        print("node {}: parent = {}, depth = {}, {}, {}".
              format(id, T[id].parent, T[id].depth,
                     node_type(T, id), child(T, id)))

def main():
    n = int(input())
    T = [Node() for _ in range(n)]

    read_nodes(T)
    calc_depth(T)
    print_nodes(T)

main()


### FIXED CODE ###

class Node():
    def __init__(self, parent=-1, child=[]):
        self.parent = parent
        self.child = child


def node_depth(u, id):
    if u[id].parent == -1:
        return 0
    else:
        return node_depth(u, u[id].parent) + 1


def node_type(u, id):
    if u[id].parent == -1:
        return "root"
    elif u[id].child == []:
        return "leaf"
    else:
        return "internal node"


def main():
    n = int(input())
    u = [Node() for _ in range(n)]

    for _ in range(n):
        id, _, *child = (int(x) for x in input().split())
        u[id].child = child
        for c in child:
            u[c].parent = id

    for id in range(n):
        print("node {}: parent = {}, depth = {}, {}, {}".
              format(id, u[id].parent,
                     node_depth(u, id), node_type(u, id),
                     u[id].child))


main()
n = int(input())
h = map(int, input().split())

ans = 0
for i in range(1, n):
  d = h[i] - h[i-1]
  if d > 0:
    ans += d
print(ans)

### FIXED CODE ###

n = int(input())
h = list(map(int, input().split()))
 
ans = h[0]
for i in range(1, n):
  d = h[i] - h[i-1]
  if d > 0:
    ans += d
print(ans)
N = int(input())
A = [int(i) for i in input().split()]
gcd_left = [0] * N
gcd_right = [0] * N
chk = 1
for i in range(N):
	if i == 0:
		chk = A[0]
	else:
		chk = fractions.gcd(chk,A[i])
	gcd_left[i] = chk
temp = 0
for i in range(N):
	num = N-1-i
	if i == 0 :
		temp = A[num]
	else:
		temp = fractions.gcd(temp,A[num])
	gcd_right[num] = temp
ans = 0
for i in range(N):
	if i == 0:
		ans = max(ans,gcd_right[1])
	elif i == N-1:
		ans = max(ans,gcd_left[N-2])
	else:
		ans = max(ans,fractions.gcd(gcd_left[i-1],gcd_right[i+1]))
print(ans)

### FIXED CODE ###

import fractions
N = int(input())
A = [int(i) for i in input().split()]
gcd_left = [0] * N
gcd_right = [0] * N
chk = 1
for i in range(N):
	if i == 0:
		chk = A[0]
	else:
		chk = fractions.gcd(chk,A[i])
	gcd_left[i] = chk
temp = 0
for i in range(N):
	num = N-1-i
	if i == 0 :
		temp = A[num]
	else:
		temp = fractions.gcd(temp,A[num])
	gcd_right[num] = temp
ans = 0
for i in range(N):
	if i == 0:
		ans = max(ans,gcd_right[1])
	elif i == N-1:
		ans = max(ans,gcd_left[N-2])
	else:
		ans = max(ans,fractions.gcd(gcd_left[i-1],gcd_right[i+1]))
print(ans)
n = int(input())
d = list(map(int,input().split()))
p = 0
q = 0
m = 0
a = 0
d.sort()
if (len(d))%2 == 0:
  m = ((d[(len(d)//2)-1])+(d[len(d)//2]))/2
else:
  m = d[(len(d)//2)]
for i in range(len(d)):
  if d[i]>=m:
    if d[i] == d[i+1]:
      break
    else:
      p = d[i]
      q = d[i-1]
      break
  else:
    a = 0
print(p-q)

### FIXED CODE ###

n = int(input())
d = sorted(list(map(int,input().split())))
print(d[n//2]-d[n//2-1])
N = int(input())
A = list(map(int,input().split()))
    
A=check.copy()
A.sort()

check=[0]*N

for idx in range(N%2,N,2):
    check[idx]=idx+1
    check[idx+1]=idx+1

ans=0

if check == A:
    if N % 2 == 0:
        ans=(2**(N//2))%(10**9+7)
    elif N % 2 != 0:
        ans=(2**((N-1)//2))%(10**9+7)
    
print(ans)

### FIXED CODE ###

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

check=[0]*N

for idx in range(N%2,N,2):
    check[idx]=idx+1
    check[idx+1]=idx+1

ans=0

if check == A:
    if N % 2 == 0:
        ans=(2**(N//2))%(10**9+7)
    elif N % 2 != 0:
        ans=(2**((N-1)//2))%(10**9+7)
    
print(ans)
import math
N=int(input())
A=[int(x) for x in input().split()]
ans=A[0]
for a in A[1:]:
  ans=math.gcd(ans,a)
print(ans)

### FIXED CODE ###

import fractions
N=int(input())
A=[int(x) for x in input().split()]
ans=A[0]
for a in A[1:]:
  ans=fractions.gcd(ans,a)
print(ans)
import sys
import copy
N=int(input())
table=[]
for i in range(N):
    A=[int(j) for j in input().split() ]
    table.append(A)
tas=copy.deepcopy(table)
for k in range(N):
    for i in range(N):
        for j in range(N):
            tas[j][i]=min(tas[j][i],tas[j][k]+tas[k][i])
            
for y in range(N):
    for x in range(N):
        if A[y][x]!=tas[y][x]:
            print(-1)
            sys.exit()
ans=0
for i in range(N):
    for j in range(i+1,N):
        flag =True
        for k in range(N):
            if i==k or j==k:
                continue
            if table[j][i]==table[j][k] +table[k][i]:
                flag = False
        if flag:        
            ans+=table[j][i]
print(ans)

### FIXED CODE ###

import sys
import copy

N = int(input())
table = []
for i in range(N):
    A = [int(j) for j in input().split()]
    table.append(A)
tas = copy.deepcopy(table)
for k in range(N):
    for i in range(N):
        for j in range(N):
            tas[j][i] = min(tas[j][i], tas[j][k] + tas[k][i])

for y in range(N):
    for x in range(y+1, N):
        if table[y][x] != tas[y][x]:
            print(-1)
            sys.exit()
ans = 0
for i in range(N):
    for j in range(i + 1, N):
        flag = True
        for k in range(N):
            if i == k or j == k:
                continue
            if table[j][i] >= table[j][k] + table[k][i]:
                flag = False
        if flag:
            ans += table[j][i]
print(ans)
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n,a = map(int,readline().split())
lst1 = list(map(int,readline().split()))

import numpy as np

dp = np.zeros((n+1,3000),dtype=np.int64) # 枚数、目標数ごとに場合の数
dp[0,0] = 1

for x in lst1:
  dp[1:,x:] += dp[:-1,:-x].copy()
  
ans = 0
for i in range(1,n+1):
  ans += dp[i,i*lst1]
  
print(ans)


### FIXED CODE ###

import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n,a = map(int,readline().split())
lst1 = list(map(int,readline().split()))

import numpy as np

dp = np.zeros((n+1,3000),dtype=np.int64) # 枚数、目標数ごとに場合の数
dp[0,0] = 1

for x in lst1:
  dp[1:,x:] += dp[:-1,:-x].copy()
  
ans = 0
for i in range(1,n+1):
  ans += dp[i,i*a]
  
print(ans)
x=input("please enter number")
print(x*x*x)



### FIXED CODE ###

x=int(input())
print(x*x*x)
n=int(input())
arr=[int(i) for i in input().split()]
ans=[ 0 for i in range(n+1)]
for i in range(n):
    ans[arr[i]-1]+=1
for i in ans:
    print(i)


### FIXED CODE ###

n=int(input())
arr=[int(i) for i in input().split()]
ans=[ 0 for i in range(n)]
for i in arr:
    ans[i-1]+=1
for i in ans:
    print(i)
import numpy as np
n,d = map(int, input().split())
l=[]
for i in range(n):
  l.append(list(map(int, input().split())))
count = 0
for i in range(n):
  for j in range(i+1,n):
    distance_a = 0
    for k in range(d):
      distance_k= l[i][k]-l[j][k]
      distance_a +=distance_k**2
    distance = np.sqrt(distance_a)
    if distance = int:
      count += 1
print(count)
    
    
      

### FIXED CODE ###

import numpy as np
n,d = map(int, input().split())
l=[]
for i in range(n):
  l.append(list(map(int, input().split())))
count = 0
for i in range(n):
  for j in range(i+1,n):
    distance_a = 0
    for k in range(d):
      distance_k= l[i][k]-l[j][k]
      distance_a +=distance_k**2
    distance = np.sqrt(distance_a)
    distance_int =int(distance)
    if distance == distance_int:
      count += 1
print(count)
a, b, c = map(int, input().split(""))
if a < b:
 if b < c:
  print ("Yes")
else:
 print ("No")

### FIXED CODE ###

a, b, c = map(int, raw_input().split())
if a < b and b < c:
 print "Yes"
else:
 print "No"
S = '_' + input()
### dp[i文字目][直前に見た文字] = 分割数
dp = []
for _ in range(len(S)):
    dp += [{}]
dp[1][S[1:2]] = 1
index = 1
while index < len(S):
    for k, v in dp[index].items():
        if index + 1 < len(S):
            s = S[index: index + 1]
            if s != k:
                if not s in dp[index + 1]:
                    dp[index + 1][s] = v + 1
                elif s in dp[index + 1] and dp[index + 1][s] < v + 1:
                    dp[index + 1][s] = v + 1
        if index + 2 < len(S):
            s = S[index: index + 2]
            if s != k:
                if not s in dp[index + 2]:
                    dp[index + 2][s] = v + 1
                elif s in dp[index + 2] and dp[index + 2][s] < v + 1:
                    dp[index + 2][s] = v + 1
    index += 1
# print(f'dp:{dp}', file=sys.stderr)
print(max([v for k, v in dp[-1].items()]))

### FIXED CODE ###

S = '_' + input()
### dp[i文字目まで読んだ][直前に読んだ文字] = 分割数
dp = []
for _ in range(len(S) + 1):
    dp += [{}]
if len(S) == 2:
    print(1)
else:
    dp[2][S[1:2]] = 1
    dp[3][S[1:3]] = 1
    index = 2
    while index < len(S):
        for k, v in dp[index].items():
            if index + 1 <= len(S):
                s = S[index: index + 1]
                # print(f"index:{index} k:{k} v:{v} s:{s}", file=sys.stderr)
                if s != k:
                    if not s in dp[index + 1]:
                        dp[index + 1][s] = v + 1
                    elif s in dp[index + 1] and dp[index + 1][s] < v + 1:
                        dp[index + 1][s] = v + 1
            if index + 2 <= len(S):
                s = S[index: index + 2]
                if s != k:
                    if not s in dp[index + 2]:
                        dp[index + 2][s] = v + 1
                    elif s in dp[index + 2] and dp[index + 2][s] < v + 1:
                        dp[index + 2][s] = v + 1
        index += 1
    # print(f'len:{len(S)} dp:{dp}', file=sys.stderr)
    print(max([v for k, v in dp[-1].items()]))
N = int(input())
H = list(map(int, input().split()))
H[0] -= 1
for i in range(0, n - 1):
    diff = H[i + 1] - H[i]
    if diff >= 1:
        H[i + 1] -= 1
    elif diff < 0:
        print("No")
        exit()
print("Yes")

### FIXED CODE ###

import numpy as np

N = int(input())
H = np.array(list(map(int, input().split())))
H[0] -= 1
for i in range(0, N - 1):
    diff = H[i + 1] - H[i]
    if diff >= 1:
        H[i + 1] -= 1
    elif diff < 0:
        print("No")
        exit()
print("Yes")
n = int(input())
ans(n//3)

### FIXED CODE ###

n = int(input())
print(n//3)
import numpy as np

n, m = map(int, input().split())
hlist = np.array(list(map(int, input().split()))).astype(np.int64)
ab = [list(map(int, input().split())) for _ in range(m)]

connect = np.zeros((n,n)).astype(np.int64)
for a, b in ab:
  connect[a-1, b-1] = connect[b-1, a-1] = 1
ans = 0
for i in range(n):
  if (connect[i] * hlist >= hlist[i]).sum() == 0:
    ans += 1
print(ans)

### FIXED CODE ###

n, m = map(int, input().split())
hlist = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]

maxh = [0]*n
for a, b in ab:
  maxh[a-1] = max(maxh[a-1], hlist[b-1])
  maxh[b-1] = max(maxh[b-1], hlist[a-1])
ans = 0
for i in range(n):
  if maxh[i] < hlist[i]:
    ans += 1
print(ans)
T = input()
lis = list(T)
n = lis.count("?")

temp = [i for i, x in enumerate(lis) if x == '?']
t = 0
for i, e in enumerate(temp):
    if 0 <= e -2:
        if 1 == e-t  and lis[e - 2] == "D":
            lis[e-1] = "P"
            lis[e] = "D"
    if e == 0:
        lis[e] = "P"
    if e < len(lis) - 1:
        if lis[e + 1] == "D":
            lis[e] = "P"
    if lis[e - 1] == "P":
        lis[e] = "D"

    t = e
    LIS = ''.join(lis)
print(LIS)

### FIXED CODE ###

T = input()
print(T.replace("?","D"))
S, T = input().split()
A, B = map(int, input().split())
U = input()
if U == S:    A -= 1
else: B -= 1
print(A,B)

### FIXED CODE ###

S, T = input().split()
A, B = map(int, input().split())
U = input()
if U == S:    A -= 1
else: B -= 1
print(A, B)
from sys import exit
N = int(input())
 
cnt = 0
for i in range(N):
    x,y = map(int,input().split())
    if cnt == 3:
        print("Yes")
        exit(0)
    if x == y:
        cnt += 1
    else:
        cnt = 0

if cnt == 3:
    print("Yes"
    
print("No")

### FIXED CODE ###

from sys import exit
N = int(input())
 
cnt = 0
for i in range(N):
    x,y = map(int,input().split())
    if cnt == 3:
        print("Yes")
        exit(0)
    if x == y:
        cnt += 1
    else:
        cnt = 0

if cnt == 3:
    print("Yes")
else:
    print("No")
#include <stdio.h>

int main() {
  int a, b, x=-1;
  scanf("%d %d", &a, &b);
  for(int i=b*10; i<(b+1)*10; ++i) {
    if ((int)(i*0.08) == a) {
      x = i;
      break;
    }
  }
  printf("%d", x);
  return 0;
}


### FIXED CODE ###

a, b = map(int, input().split())
for i in range(b*10, (b+1)*10):
  if int(i*0.08) == a:
    print(i)
    break
else:
  print(-1)
X=int(input())
    A=int(input())
    B=int(input())
    
    
    0<=B<=100
    if 0<=A<=100 and 0<=B<=100 and A<=X<=A+B;
    print("Yes")
    else;
    print("No")

### FIXED CODE ###

a, b, x = map(int, input().split())
 
n = x - a
 
if n >= 0 and b >=  n:
    print('YES')
else:
    print('NO')
P,Q,R = map(int,input().split())

a = P + Q
b = P + R
c = Q + R
d = Q + P
e = R + Q
f = R + P

list[a,b,c,d,e,f]

print(min(list))

### FIXED CODE ###

a,b,c = map(int,input().split())
print(min(a+b,a+c,b+c))
n = int(input())
h_list = [ int(v) for v in input().split() ]

dh_list = []

t = 0
for i in range(n-1):
    if h_list[i] >= h_list[i+1]:
        t += 1
    else:
        t = 0
    dh_list.append(t)
print(max(dh_list))


### FIXED CODE ###

n = int(input())
if n == 1:
    print(0)
else:
    h_list = [ int(v) for v in input().split() ]

    dh_list = []

    t = 0
    for i in range(n-1):
        if h_list[i] >= h_list[i+1]:
            t += 1
        else:
            t = 0
        dh_list.append(t)
    print(max(dh_list))
import sys
import os
import math

def file_input():
    f = open('input.txt', 'r')
    sys.stdin = f

def main():
   # file_input()

    N = [0]*int(input())
    A = list(map(int, input().split()))

    for i in A:
        N[i-1]+=1

    for i in N:
        print(i)


if __name__ == '__main__':
    main()


### FIXED CODE ###

import math


def main():

    R = int(input())
    print(R*2*math.pi)


if __name__ == '__main__':
    main()
import sys
from collections import Counter, deque, defaultdict
from math import factorial
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

n,m = MAP()
E = [[(0,0,0)]for i in range(m)]
for i in range(m):
    a,b,cost = MAP()
    E[i] = (a-1, b-1, -1*cost)



def bellmanford(s, E): #無向グラフの時はEに双方向から辺を追加
    d = [INF]*n
    d[s] = 0
    for i in range(n-1):
        for e in E:
            if d[e[0]] != INF and d[e[0]]+e[2] < d[e[1]]:
                d[e[1]] = d[e[0]]+e[2]
    return d

def find_negative_loop(s,E):
    d = bellmanford(s, E)
    negative = [False]*n
    for i in range(n):
        for j in range(m):
            if d[E[j][0]] != INF and d[E[j][0]]+E[j][2] < d[E[j][1]]:
                d[E[j][1]] = d[E[j][0]]+E[j][2]
                negative[j] = True
            if negative[E[j][0]]:
                negative[E[j][1]] = True

    return negative[n-1]

res = bellmanford(0,E)
if find_negative_loop(0,E):
    print('inf')
else:
    print(res[n-1]*-1)


### FIXED CODE ###

import sys
from collections import Counter, deque, defaultdict
from math import factorial
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

n,m = MAP()
E = [[(0,0,0)]for i in range(m)]
for i in range(m):
    a,b,cost = MAP()
    E[i] = (a-1, b-1, -1*cost)

d = [INF]*n
d[0] = 0
for i in range(n-1):
    for e in E:
        if d[e[0]] != INF and d[e[0]]+e[2] < d[e[1]]:
            d[e[1]] = d[e[0]]+e[2]
res =  d[n-1]

for e in E:
    if d[e[0]] != INF and d[e[0]]+e[2] < d[e[1]]:
            d[e[1]] = d[e[0]]+e[2]




if  res != d[n-1]:
    print('inf')
else:
    print(res*-1)