Input:
import sys

init = ''.join(sys.stdin.read().split())

# Bidirectional search using breadth-first search

def solve(start, goal):

    if start == goal:

        return 0

    generated_state = {start: 0, goal: 1}   # 0: foreward, 1: backward

    step = {start: 0, goal: 0}

    s = 0

    c_d = [(start, 0), (goal, 1)] # configure and direction

    while True:

        q = iter(c_d)

        c_d = []

        s += 1

        for c, d in q:

            i = c.find('0')

            if 0 <= i <= 5:

                t = str.maketrans('0' + c[i+3], c[i+3] + '0')

                t_c = c.translate(t)

                if t_c in generated_state:

                    if generated_state[t_c] != d:

                        return s + step[t_c]

                else:

                    generated_state[t_c] = d

                    step[t_c] = s

                    c_d.append((t_c, d))

            if i >= 3:

                t = str.maketrans('0' + c[i-3], c[i-3] + '0')

                t_c = c.translate(t)

                if t_c in generated_state:

                    if generated_state[t_c] != d:

                        return s + step[t_c]

                else:

                    generated_state[t_c] = d

                    step[t_c] = s

                    c_d.append((t_c, d))

            if i == 0 or i == 1 or i == 3 or i == 4 or i == 6 or i == 7:

                t = str.maketrans('0' + c[i+1], c[i+1] + '0')

                t_c = c.translate(t)

                if t_c in generated_state:

                    if generated_state[t_c] != d:

                        return s + step[t_c]

                else:

                    generated_state[t_c] = d

                    step[t_c] = s

                    c_d.append((t_c, d))

            if i == 1 or i == 2 or i == 4 or i == 5 or i == 7 or i == 8:

                t = str.maketrans('0' + c[i-1], c[i-1] + '0')

                t_c = c.translate(t)

                if t_c in generated_state:

                    if generated_state[t_c] != d:

                        return s + step[t_c]

                else:

                    generated_state[t_c] = d

                    step[t_c] = s

                    c_d.append((t_c, d))

print((solve(init, '123456780')))

import Ġsys ĊĊĊĊ init Ġ= Ġ''. join (sys .stdin .read (). split ())ĊĊ ĊĊ # ĠBid irectional Ġsearch Ġusing Ġbreadth -first Ġsearch ĊĊ def Ġsolve (start , Ġgoal ):ĊĊ ĠĠĠ Ġif Ġstart Ġ== Ġgoal :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 0 ĊĊ ĠĠĠ Ġgenerated _state Ġ= Ġ{ start : Ġ 0 , Ġgoal : Ġ 1 } ĠĠ Ġ# Ġ 0 : Ġfore ward , Ġ 1 : Ġbackward ĊĊ ĠĠĠ Ġstep Ġ= Ġ{ start : Ġ 0 , Ġgoal : Ġ 0 }ĊĊ ĠĠĠ Ġs Ġ= Ġ 0 ĊĊ ĠĠĠ Ġc _d Ġ= Ġ[( start , Ġ 0 ), Ġ( goal , Ġ 1 )] Ġ# Ġconfigure Ġand Ġdirection ĊĊ ĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠ Ġq Ġ= Ġiter (c _d )ĊĊ ĠĠĠĠĠĠĠ Ġc _d Ġ= Ġ[]ĊĊ ĠĠĠĠĠĠĠ Ġs Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġc , Ġd Ġin Ġq :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġi Ġ= Ġc .find (' 0 ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ 0 Ġ<= Ġi Ġ<= Ġ 5 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ= Ġstr .m ak etr ans (' 0 ' Ġ+ Ġc [i + 3 ], Ġc [i + 3 ] Ġ+ Ġ' 0 ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt _c Ġ= Ġc .translate (t )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġt _c Ġin Ġgenerated _state :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġgenerated _state [t _c ] Ġ!= Ġd :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġs Ġ+ Ġstep [t _c ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġgenerated _state [t _c ] Ġ= Ġd ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġstep [t _c ] Ġ= Ġs ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġc _d .append (( t _c , Ġd ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi Ġ>= Ġ 3 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ= Ġstr .m ak etr ans (' 0 ' Ġ+ Ġc [i - 3 ], Ġc [i - 3 ] Ġ+ Ġ' 0 ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt _c Ġ= Ġc .translate (t )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġt _c Ġin Ġgenerated _state :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġgenerated _state [t _c ] Ġ!= Ġd :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġs Ġ+ Ġstep [t _c ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġgenerated _state [t _c ] Ġ= Ġd ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġstep [t _c ] Ġ= Ġs ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġc _d .append (( t _c , Ġd ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi Ġ== Ġ 0 Ġor Ġi Ġ== Ġ 1 Ġor Ġi Ġ== Ġ 3 Ġor Ġi Ġ== Ġ 4 Ġor Ġi Ġ== Ġ 6 Ġor Ġi Ġ== Ġ 7 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ= Ġstr .m ak etr ans (' 0 ' Ġ+ Ġc [i + 1 ], Ġc [i + 1 ] Ġ+ Ġ' 0 ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt _c Ġ= Ġc .translate (t )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġt _c Ġin Ġgenerated _state :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġgenerated _state [t _c ] Ġ!= Ġd :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġs Ġ+ Ġstep [t _c ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġgenerated _state [t _c ] Ġ= Ġd ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġstep [t _c ] Ġ= Ġs ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġc _d .append (( t _c , Ġd ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi Ġ== Ġ 1 Ġor Ġi Ġ== Ġ 2 Ġor Ġi Ġ== Ġ 4 Ġor Ġi Ġ== Ġ 5 Ġor Ġi Ġ== Ġ 7 Ġor Ġi Ġ== Ġ 8 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ= Ġstr .m ak etr ans (' 0 ' Ġ+ Ġc [i - 1 ], Ġc [i - 1 ] Ġ+ Ġ' 0 ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt _c Ġ= Ġc .translate (t )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġt _c Ġin Ġgenerated _state :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġgenerated _state [t _c ] Ġ!= Ġd :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġs Ġ+ Ġstep [t _c ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġgenerated _state [t _c ] Ġ= Ġd ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġstep [t _c ] Ġ= Ġs ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġc _d .append (( t _c , Ġd )) ĊĊĊĊ print (( solve (init , Ġ' 1 2 3 4 5 6 7 8 0 ')))


Input:
def popcount(x):

  r, q = 0, x

  while x:

    r += 1

    x &= x - 1

  return r, q

n = int(input())

r = list(range(n))

a = [[0, 0] for _ in r]

for i in r:

  for _ in range(int(input())):

    x, y = list(map(int, input().split()))

    a[i][y] |= 1 << (x - 1)

l = (1 << n) - 1

b = sorted(map(popcount, list(range(1, l + 1))))

ans = next((i for i, x in reversed(b)

           if all(a[j][0] & x == a[j][1] & l - x == 0 for j in r if x >> j & 1)), 0)

print(ans)

def Ġpop count (x ):ĊĊ Ġ Ġr , Ġq Ġ= Ġ 0 , Ġx ĊĊ Ġ Ġwhile Ġx :ĊĊ ĠĠĠ Ġr Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġx Ġ&= Ġx Ġ- Ġ 1 ĊĊ Ġ Ġreturn Ġr , Ġq ĊĊ ĠĊĊ n Ġ= Ġint (input ())ĊĊ r Ġ= Ġlist (range (n ))ĊĊ a Ġ= Ġ[[ 0 , Ġ 0 ] Ġfor Ġ_ Ġin Ġr ]ĊĊ for Ġi Ġin Ġr :ĊĊ Ġ Ġfor Ġ_ Ġin Ġrange (int (input ())) :ĊĊ ĠĠĠ Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġa [i ][ y ] Ġ|= Ġ 1 Ġ<< Ġ( x Ġ- Ġ 1 )ĊĊ l Ġ= Ġ( 1 Ġ<< Ġn ) Ġ- Ġ 1 ĠĊĊ b Ġ= Ġsorted (map (pop count , Ġlist (range ( 1 , Ġl Ġ+ Ġ 1 ))))ĊĊ ans Ġ= Ġnext (( i Ġfor Ġi , Ġx Ġin Ġreversed (b )ĊĊ ĠĠĠĠĠĠĠĠĠĠ Ġif Ġall (a [j ][ 0 ] Ġ& Ġx Ġ== Ġa [j ][ 1 ] Ġ& Ġl Ġ- Ġx Ġ== Ġ 0 Ġfor Ġj Ġin Ġr Ġif Ġx Ġ>> Ġj Ġ& Ġ 1 )), Ġ 0 )ĊĊ print (ans )Ċ


Input:
import queue

n = int(input())

abc = [[] for i in range(n+1)]

for i in range(n-1):

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

    abc[a].append([b,c])

    abc[b].append([a,c])

Q,k = list(map(int,input().split()))

xy = [[int(i) for i in input().split()] for j in range(Q)]

q = queue.Queue()

q.put(k)

path = [-1]*(n+1)

path[k] = 0

while not q.empty():

    tmp = q.get()

    for i in range(len(abc[tmp])):

        #print(abc[tmp])

        #exit()

        num = abc[tmp][i][0]

        if path[num] != -1:

            continue

        else:

            path[num] = path[tmp] + abc[tmp][i][1]

            q.put(num)

for i in range(Q):

    print((path[xy[i][0]]+path[xy[i][1]]))

import Ġqueue ĊĊ n Ġ= Ġint (input ())ĊĊ ĊĊ abc Ġ= Ġ[[] Ġfor Ġi Ġin Ġrange (n + 1 )] ĊĊĊĊ for Ġi Ġin Ġrange (n - 1 ):ĊĊ ĠĠĠ Ġa ,b ,c Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġabc [a ]. append ([ b ,c ])ĊĊ ĠĠĠ Ġabc [b ]. append ([ a ,c ])ĊĊ ĊĊ Q ,k Ġ= Ġlist (map (int ,input (). split ()))ĊĊ xy Ġ= Ġ[[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()] Ġfor Ġj Ġin Ġrange (Q )] ĊĊĊĊ q Ġ= Ġqueue .Queue ()ĊĊĊĊ q .put (k )ĊĊĊĊ path Ġ= Ġ[- 1 ]*( n + 1 )ĊĊ path [k ] Ġ= Ġ 0 ĊĊĊĊ while Ġnot Ġq .empty ():ĊĊ ĠĠĠ Ġtmp Ġ= Ġq .get ()ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (len ( abc [tmp ])) :ĊĊ ĠĠĠĠĠĠĠ Ġ# print ( abc [tmp ])ĊĊ ĠĠĠĠĠĠĠ Ġ# exit ()ĊĊ ĠĠĠĠĠĠĠ Ġnum Ġ= Ġabc [tmp ][ i ][ 0 ]ĊĊ ĠĠĠĠĠĠĠ Ġif Ġpath [num ] Ġ!= Ġ- 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġpath [num ] Ġ= Ġpath [tmp ] Ġ+ Ġabc [tmp ][ i ][ 1 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġq .put (num )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĊĊ for Ġi Ġin Ġrange (Q ):ĊĊ ĠĠĠ Ġprint (( path [ xy [i ][ 0 ]] + path [ xy [i ][ 1 ]] ))


Input:
W,H,x,y,r = [int(i) for i in input().split()]

if x - r >= 0 and x + r <= W and y - r >= 0 and y + r <= H:

    print("Yes")

else:

    print("No")

W ,H ,x ,y ,r Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ if Ġx Ġ- Ġr Ġ>= Ġ 0 Ġand Ġx Ġ+ Ġr Ġ<= ĠW Ġand Ġy Ġ- Ġr Ġ>= Ġ 0 Ġand Ġy Ġ+ Ġr Ġ<= ĠH :ĊĊ ĠĠĠ Ġprint (" Yes ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" No ")


Input:
from math import log2

n = int(input())

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

ans = 0

for _a in a:

    if _a%2 == 0:

        cnt =0

        while _a%2 == 0:

            _a //= 2

            cnt += 1

        ans += cnt

print((int(ans)))

from Ġmath Ġimport Ġlog 2 ĊĊ n Ġ= Ġint (input ())ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ans Ġ= Ġ 0 ĊĊĊĊ for Ġ_ a Ġin Ġa :ĊĊ ĠĠĠ Ġif Ġ_ a % 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ= 0 ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġ_ a % 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġ_ a Ġ//= Ġ 2 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġcnt ĊĊĊĊ print (( int (ans )))


Input:
# coding: utf-8

def solve(*args: str) -> str:

    n, m, k = list(map(int, args[0].split()))

    mod = 998244353

    if m == 1 and n-1 == k:

        return str(1)

    ncr = 1

    p = m*pow(m-1, n-1, mod) % mod

    ret = p

    inv = pow(m-1, mod-2, mod)

    for i in range(1, k+1):

        ncr = (ncr * (n-i)*pow(i, mod-2, mod)) % mod

        p = (p*inv) % mod

        ret += p*ncr % mod

    return str(ret % mod)

if __name__ == "__main__":

    print((solve(*(open(0).read().splitlines()))))

# Ġcoding : Ġutf - 8 ĊĊĊĊĊĊ def Ġsolve (* args : Ġstr ) Ġ-> Ġstr :ĊĊ ĠĠĠ Ġn , Ġm , Ġk Ġ= Ġlist (map (int , Ġargs [ 0 ]. split ()))ĊĊ ĠĠĠ Ġmod Ġ= Ġ 9 9 8 2 4 4 3 5 3 ĊĊĊĊ ĠĠĠ Ġif Ġm Ġ== Ġ 1 Ġand Ġn - 1 Ġ== Ġk :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġstr ( 1 )ĊĊĊĊ ĠĠĠ Ġn cr Ġ= Ġ 1 ĊĊ ĠĠĠ Ġp Ġ= Ġm *pow (m - 1 , Ġn - 1 , Ġmod ) Ġ% Ġmod ĊĊ ĠĠĠ Ġret Ġ= Ġp ĊĊ ĠĠĠ Ġinv Ġ= Ġpow (m - 1 , Ġmod - 2 , Ġmod )ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġk + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġn cr Ġ= Ġ( nc r Ġ* Ġ( n -i )* pow (i , Ġmod - 2 , Ġmod )) Ġ% Ġmod ĊĊ ĠĠĠĠĠĠĠ Ġp Ġ= Ġ( p * inv ) Ġ% Ġmod ĊĊ ĠĠĠĠĠĠĠ Ġret Ġ+= Ġp * nc r Ġ% Ġmod ĊĊĊĊ ĠĠĠ Ġreturn Ġstr (ret Ġ% Ġmod )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġprint (( solve (*( open ( 0 ). read (). split lines ())) ))Ċ


Input:
import collections as col

def prime(n):

    ans = []

    num = n

    for i in range(2,n+1):

        if i%2==0 and i!=2: continue

        while num%i == 0: num //= i ; ans.append(i)

    return ans

n = int(input())

mod = 10**9 + 7

primes = []

for i in range(2,n+1): primes += prime(i)

cnt = col.Counter(primes)

ans = 1

for key,val in list(cnt.items()): ans *= (val + 1) ; ans %= mod

print(ans)

import Ġcollections Ġas Ġcol ĊĊĊĊ def Ġprime (n ):ĊĊ ĠĠĠ Ġans Ġ= Ġ[]ĊĊ ĠĠĠ Ġnum Ġ= Ġn ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 2 ,n + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi % 2 == 0 Ġand Ġi != 2 : Ġcontinue ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġnum %i Ġ== Ġ 0 : Ġnum Ġ//= Ġi Ġ; Ġans .append (i )ĊĊ ĠĠĠ Ġreturn Ġans ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ mod Ġ= Ġ 1 0 ** 9 Ġ+ Ġ 7 ĊĊĊĊ pr imes Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange ( 2 ,n + 1 ): Ġprimes Ġ+= Ġprime (i )ĊĊĊĊ cnt Ġ= Ġcol .Counter (pr imes )ĊĊ ans Ġ= Ġ 1 ĊĊ for Ġkey ,val Ġin Ġlist (cnt .items ()): Ġans Ġ*= Ġ( val Ġ+ Ġ 1 ) Ġ; Ġans Ġ%= Ġmod ĊĊ print (ans )Ċ


Input:
import sys

def main():

    input = sys.stdin.readline

    N = int(input())

    E = [[] for _ in range(N)]

    for i in range(N-1):

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

        a, b = a-1, b-1

        E[a].append((b,i))

        E[b].append((a,i))

    def dfs(s, g):

        par = [(-1,-1)] * N

        par[s] = (s,-1)

        stack = [s]

        while stack:

            v = stack.pop()

            for to, i in E[v]:

                if par[to][0] >= 0: continue

                par[to] = (v, i)

                if to == g: break

                stack.append(to)

        r = set()

        v = g

        while v != s:

            v, i = par[v]

            r.add(i)

        return r

    M = int(input())

    path = [None] * M

    for i in range(M):

        u, v = list(map(int, input().split()))

        u, v = u-1, v-1

        path[i] = dfs(u, v)

    def calc(s): return 1<<(N-1-len(s))

    i_ans = 0

    for p in range(1, 1<<M):

        is_odd = bin(p).count('1') & 1

        s = set()

        for i in range(M):

            if p&1: s |= path[i]

            p >>= 1

        if is_odd: i_ans += calc(s)

        else: i_ans -= calc(s)

    print(((1<<(N-1)) - i_ans))

if __name__ == '__main__':

    main()

import Ġsys ĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġinput Ġ= Ġsys .stdin .readline ĊĊ ĠĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠE Ġ= Ġ[[] Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (N - 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġa , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠĠĠĠĠ Ġa , Ġb Ġ= Ġa - 1 , Ġb - 1 ĊĊ ĠĠĠĠĠĠĠ ĠE [a ]. append (( b ,i ))ĊĊ ĠĠĠĠĠĠĠ ĠE [b ]. append (( a ,i ))ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġdef Ġdfs (s , Ġg ):ĊĊ ĠĠĠĠĠĠĠ Ġpar Ġ= Ġ[ (- 1 ,- 1 )] Ġ* ĠN ĊĊ ĠĠĠĠĠĠĠ Ġpar [s ] Ġ= Ġ( s ,- 1 )ĊĊ ĠĠĠĠĠĠĠ Ġstack Ġ= Ġ[ s ]ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġstack :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġv Ġ= Ġstack .pop ()ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġto , Ġi Ġin ĠE [v ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġpar [to ][ 0 ] Ġ>= Ġ 0 : Ġcontinue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġpar [to ] Ġ= Ġ( v , Ġi )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġto Ġ== Ġg : Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġstack .append (to )ĊĊ ĠĠĠĠĠĠĠ Ġr Ġ= Ġset ()ĊĊ ĠĠĠĠĠĠĠ Ġv Ġ= Ġg ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġv Ġ!= Ġs :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġv , Ġi Ġ= Ġpar [v ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġr .add (i )ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġr ĊĊ ĠĠĠĠĊĊ ĠĠĠ ĠM Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġpath Ġ= Ġ[ None ] Ġ* ĠM ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠĠĠĠĠ Ġu , Ġv Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠĠĠĠĠ Ġu , Ġv Ġ= Ġu - 1 , Ġv - 1 ĊĊ ĠĠĠĠĠĠĠ Ġpath [i ] Ġ= Ġdfs (u , Ġv )ĊĊĊĊ ĠĠĠ Ġdef Ġcalc (s ): Ġreturn Ġ 1 <<( N - 1 -len (s )) ĊĊĊĊ ĠĠĠ Ġi _ans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġp Ġin Ġrange ( 1 , Ġ 1 << M ):ĊĊ ĠĠĠĠĠĠĠ Ġis _odd Ġ= Ġbin (p ). count (' 1 ') Ġ& Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġs Ġ= Ġset ()ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġp & 1 : Ġs Ġ|= Ġpath [i ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġp Ġ>>= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġis _odd : Ġi _ans Ġ+= Ġcalc (s )ĊĊ ĠĠĠĠĠĠĠ Ġelse : Ġi _ans Ġ-= Ġcalc (s )ĊĊĊĊ ĠĠĠ Ġprint ((( 1 <<( N - 1 )) Ġ- Ġi _ans )) ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()


Input:
'''

    Auther: ghoshashis545 Ashis Ghosh

    College: jalpaiguri Govt Enggineering College

'''

from os import path

import sys

from functools import cmp_to_key as ctk

from collections import deque,defaultdict as dd

from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right

from itertools import permutations

from datetime import datetime

from math import ceil,sqrt,log,gcd

def ii():return int(input())

def si():return input()

def mi():return list(map(int,input().split()))

def li():return list(mi())

abc='abcdefghijklmnopqrstuvwxyz'

mod=1000000007

#mod=998244353

inf = float("inf")

vow=['a','e','i','o','u']

dx,dy=[-1,1,0,0],[0,0,1,-1]

def bo(i):

    return ord(i)-ord('a')

file = 0

def solve():

    # for _ in range(ii()):

    n=ii()

    n%=1000

    if n!=0:

        n=1000-n

    print(n)

if __name__ =="__main__":

    if(file):

        if path.exists('input1.txt'):

            sys.stdin=open('input1.txt', 'r')

            sys.stdout=open('output1.txt','w')

        else:

            input=sys.stdin.readline

    solve()

'''ĊĊ ĠĠĠ ĠAuth er : Ġgh os hash is 5 4 5 ĠAsh is ĠGh osh ĊĊ ĠĠĠ ĠCollege : Ġjal pa ig uri ĠGov t ĠEng g ine ering ĠCollege ĊĊĊĊ '''ĊĊ from Ġos Ġimport Ġpath ĊĊ import Ġsys ĊĊ from Ġfunctools Ġimport Ġcmp _to _key Ġas Ġc tk ĊĊ from Ġcollections Ġimport Ġdeque ,default dict Ġas Ġdd ĠĊĊ from Ġbis ect Ġimport Ġbis ect ,b is ect _left ,b is ect _right , ins ort , ins ort _left , ins ort _right ĊĊ from Ġitertools Ġimport Ġpermutations ĊĊ from Ġdatetime Ġimport Ġdatetime ĊĊ from Ġmath Ġimport Ġceil ,s qrt , log ,g cd ĊĊ def Ġii (): return Ġint (input ())ĊĊ def Ġsi (): return Ġinput ()ĊĊ def Ġmi (): return Ġlist (map (int ,input (). split ()))ĊĊ def Ġli (): return Ġlist (mi ())ĊĊ abc =' abcdefghijklmnopqrstuvwxyz 'ĊĊ mod = 1 0 0 0 0 0 0 0 0 7 ĊĊ # mod = 9 9 8 2 4 4 3 5 3 ĊĊ inf Ġ= Ġfloat (" inf ")ĊĊ v ow =[' a ',' e ',' i ',' o ',' u ']ĊĊ dx , dy =[ - 1 , 1 , 0 , 0 ],[ 0 , 0 , 1 ,- 1 ]ĊĊĊĊ def Ġbo (i ):ĊĊ ĠĠĠ Ġreturn Ġord (i )- ord (' a ')ĊĊĊĊ file Ġ= Ġ 0 ĊĊĊĊ def Ġsolve ():ĊĊ ĠĠĠĠ ĊĊĊĊĊĊĊĊ ĠĠĠ Ġ# Ġfor Ġ_ Ġin Ġrange (ii ()): ĊĊĊĊ ĠĠĠ Ġn = ii ()ĊĊ ĠĠĠ Ġn %= 1 0 0 0 ĊĊ ĠĠĠ Ġif Ġn != 0 :ĊĊ ĠĠĠĠĠĠĠ Ġn = 1 0 0 0 -n ĊĊ ĠĠĠ Ġprint (n )ĊĊ ĊĊĊĊĊĊĊĊ ĊĊĊĊĊĊĊĊĊĊ ĠĠ ĊĊĊĊĊĊĊĊĊĊĊĊĊĊĊĊ ĊĊĊĊĊĊĊĊ ĊĊĊĊĊĊĊĊĊĊ if Ġ__ name __ Ġ==" __ main __ ": ĊĊĊĊ ĠĠĠ Ġif (file ): ĊĊĊĊ ĠĠĠĠĠĠĠ Ġif Ġpath .exists (' input 1 .txt ') :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsys .stdin =open (' input 1 .txt ', Ġ' r ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsys .stdout =open (' output 1 .txt ',' w ')ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġinput =sys .stdin .readline ĊĊ ĠĠĠ Ġsolve ()


Input:
M=998244353

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

a=0

c=1

for i in range(k+1):

  a+=c*m*pow(m-1,n-i-1,M)

  c=c*(n-i-1)*pow(i+1,M-2,M)%M

print((a%M))

M = 9 9 8 2 4 4 3 5 3 ĊĊ n ,m ,k =list (map (int ,input (). split ()))ĊĊ a = 0 ĊĊ c = 1 ĊĊ for Ġi Ġin Ġrange (k + 1 ):ĊĊ Ġ Ġa += c *m *pow (m - 1 ,n -i - 1 ,M )ĊĊ Ġ Ġc =c *( n -i - 1 )* pow (i + 1 ,M - 2 ,M )% M ĊĊ print (( a %M ))


Input:
N = int(input())

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

cnt, i = 0, 0

for j in range(10 ** 6):

    cnt += 1

    if a[i] == 2:

        print(cnt)

        #break

        quit()

    else:

        i = a[i] - 1

print((-1))

N Ġ= Ġint (input ())ĊĊ a Ġ= Ġ[ int (input ()) Ġfor Ġ_ Ġin Ġrange (N )] ĊĊĊĊ cnt , Ġi Ġ= Ġ 0 , Ġ 0 ĊĊ for Ġj Ġin Ġrange ( 1 0 Ġ** Ġ 6 ):ĊĊ ĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġa [i ] Ġ== Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (cnt )ĊĊ ĠĠĠĠĠĠĠ Ġ# break ĊĊ ĠĠĠĠĠĠĠ Ġquit ()ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġi Ġ= Ġa [i ] Ġ- Ġ 1 ĊĊ print ((- 1 ))


Input:
import math

def combinations_count(n, r):

    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def combinations_with_replacement_count(n, r):

    return combinations_count(n + r - 1, r)

def main():

    s = int(input())

    ans = 0

    n = s // 3

    for i in range(1, n + 1):

        ans += combinations_with_replacement_count(i, 3*(n-i)+s % 3)

    print((ans % (10**9 + 7)))

if __name__ == '__main__':

    main()

import Ġmath ĊĊĊĊĊĊ def Ġcombinations _count (n , Ġr ):ĊĊ ĠĠĠ Ġreturn Ġmath .factor ial (n ) Ġ// Ġ( math .factor ial (n Ġ- Ġr ) Ġ* Ġmath .factor ial (r )) ĊĊĊĊĊĊ def Ġcombinations _with _re placement _count (n , Ġr ):ĊĊ ĠĠĠ Ġreturn Ġcombinations _count (n Ġ+ Ġr Ġ- Ġ 1 , Ġr )ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġs Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġn Ġ= Ġs Ġ// Ġ 3 ĊĊĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġcombinations _with _re placement _count (i , Ġ 3 *( n -i )+ s Ġ% Ġ 3 )ĊĊĊĊ ĠĠĠ Ġprint (( ans Ġ% Ġ( 1 0 ** 9 Ġ+ Ġ 7 )))ĊĊ ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
G_MAX = 40*10

N_MAX = 40

INF = float('inf')

dp = [[[INF]*(G_MAX+1) for _ in range(G_MAX+1)]

      for _ in range(N_MAX+1)]

N,Ma,Mb = list(map(int, input().split()))

a,b,c = [],[],[]

for _ in range(N):

    ai,bi,ci = list(map(int, input().split()))

    a.append(ai)

    b.append(bi)

    c.append(ci)

dp[0][0][0] = 0

from math import isinf

for i in range(N):

    for ca in range(G_MAX+1):

        for cb in range(G_MAX+1):

            if isinf(dp[i][ca][cb]): continue

            dp[i+1][ca][cb] = min(dp[i+1][ca][cb],

                                 dp[i][ca][cb])

            dp[i+1][ca+a[i]][cb+b[i]] = min(dp[i+1][ca+a[i]][cb+b[i]],

                                           dp[i][ca][cb]+c[i])

ans = INF

for ca in range(1,G_MAX+1):

    for cb in range(1,G_MAX+1):

        if ca*Mb==cb*Ma:

            ans = min(ans, dp[N][ca][cb])

if isinf(ans): ans = -1

print(ans)

ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ

ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ

ĠĠĠĠĠĠĠĠĠĠĠĠĊĊ

ĠĠĠĠĠĠĠĠĠĠĠĠĊĊ


Input:
from itertools import product

n = int(input())

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

count = 0

for C in product((-1, 0, 1), repeat=n):

  total = 1

  for a, c in zip(A, C):

    total *= (a + c)

  if total % 2 == 0:

    count += 1

print(count)

from Ġitertools Ġimport Ġproduct ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ A Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ count Ġ= Ġ 0 ĊĊ for ĠC Ġin Ġproduct ((- 1 , Ġ 0 , Ġ 1 ), Ġrepeat =n ):ĊĊ Ġ Ġtotal Ġ= Ġ 1 ĊĊ Ġ Ġfor Ġa , Ġc Ġin Ġzip (A , ĠC ):ĊĊ ĠĠĠ Ġtotal Ġ*= Ġ( a Ġ+ Ġc )ĊĊ Ġ Ġif Ġtotal Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ print (count )


Input:
import sys

sys.setrecursionlimit(2147483647)

INF=float("inf")

MOD=10**9+7

input=lambda :sys.stdin.readline().rstrip()

def resolve():

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

    WV=[tuple(map(int,input().split())) for _ in range(n)]

    V=100000

    dp=[INF]*(V+1)

    dp[0]=0

    for w,v in WV:

        for x in range(V,-1,-1):

            if(x+v<=V):

                dp[x+v]=min(dp[x+v],dp[x]+w)

    for x in range(V,-1,-1):

        if(dp[x]<=W):

            print(x)

            return

resolve()

import Ġsys ĊĊ sys .set rec ursion limit ( 2 1 4 7 4 8 3 6 4 7 )ĊĊ INF =float (" inf ")ĊĊ MOD = 1 0 ** 9 + 7 ĊĊ input =lambda Ġ: sys .stdin .readline (). rstrip ()ĊĊ def Ġresolve ():ĊĊ ĠĠĠ Ġn ,W =list (map (int ,input (). split ()))ĊĊ ĠĠĠ ĠWV =[ tuple (map (int ,input (). split ())) Ġfor Ġ_ Ġin Ġrange (n )] ĊĊĊĊ ĠĠĠ ĠV = 1 0 0 0 0 0 ĊĊ ĠĠĠ Ġdp =[ INF ]*( V + 1 )ĊĊ ĠĠĠ Ġdp [ 0 ]= 0 ĊĊĊĊ ĠĠĠ Ġfor Ġw ,v Ġin ĠWV :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx Ġin Ġrange (V ,- 1 ,- 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif (x +v <= V ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp [x +v ]= min (dp [x +v ], dp [x ]+ w )ĊĊĊĊ ĠĠĠ Ġfor Ġx Ġin Ġrange (V ,- 1 ,- 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif (dp [x ]<= W ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (x )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĊĊ resolve ()


Input:
from collections import defaultdict

def main():

    _ = int(input())

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

    """

    for j>i, j-i = Ai + Aj

    i + Ai = j -Aj

    """

    L = defaultdict(int)

    R = defaultdict(int)

    for i, height in enumerate(heights):

        L[i + height] += 1

        R[i - height] += 1

    total_count = 0

    for x, count_l in list(L.items()):

        if x in R:

            count_r = R[x]

            total_count += count_l * count_r

    print(total_count)

if __name__ == "__main__":

    main()

from Ġcollections Ġimport Ġdefaultdict ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġ_ Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġheights Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ĠĠĠ Ġ"""ĊĊ ĠĠĠ Ġfor Ġj >i , Ġj -i Ġ= ĠAi Ġ+ ĠAj ĊĊ ĠĠĠ Ġi Ġ+ ĠAi Ġ= Ġj Ġ- Aj ĊĊ ĠĠĠ Ġ""" ĊĊĊĊ ĠĠĠ ĠL Ġ= Ġdefaultdict (int )ĊĊ ĠĠĠ ĠR Ġ= Ġdefaultdict (int )ĊĊĊĊ ĠĠĠ Ġfor Ġi , Ġheight Ġin Ġenumerate (height s ):ĊĊ ĠĠĠĠĠĠĠ ĠL [i Ġ+ Ġheight ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ ĠR [i Ġ- Ġheight ] Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġtotal _count Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġx , Ġcount _l Ġin Ġlist (L .items ()) :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġx Ġin ĠR :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcount _r Ġ= ĠR [x ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġtotal _count Ġ+= Ġcount _l Ġ* Ġcount _r ĊĊĊĊ ĠĠĠ Ġprint (total _count )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
import sys

readline = sys.stdin.readline

sys.setrecursionlimit(10**8)

mod = 10**9+7

#mod = 998244353

INF = 10**18

eps = 10**-7

m,n,k = list(map(int,readline().split()))

def comb(n, r, mod):

    r = min(r, n-r)

    mol = 1

    deno = 1

    for i in range(1, r+1):

        mol = mol * (n-r+i) % mod

        deno = deno * i % mod

    ret = mol * pow(deno, mod-2, mod) % mod

    return ret

def f1(x,y,a,b):

    return (a+b-x-y)*(a-x+1)*(b-y+1)//2

def f2(x,a):

    return (a-x)*(a-x+1)//2

ans = 0

for x in range(1,n+1):

    for y in range(1,m+1):

        a = n-x+1

        b = m-y+1

        c = m*(a*(a-1)+x*(x-1))

        d = n*(b*(b-1)+y*(y-1))

        ans += (c+d)//2

        ans %= mod

ans = (ans * comb(m*n-2,k-2,mod))%mod

ans = ans*pow(2,mod-2,mod)%mod

print(ans)

import Ġsys ĊĊ read line Ġ= Ġsys .stdin .readline ĊĊ sys .set rec ursion limit ( 1 0 ** 8 )ĊĊ mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊ # mod Ġ= Ġ 9 9 8 2 4 4 3 5 3 ĊĊ INF Ġ= Ġ 1 0 ** 1 8 ĊĊ eps Ġ= Ġ 1 0 ** - 7 ĊĊĊĊ m ,n ,k Ġ= Ġlist (map (int , read line (). split ())) ĊĊĊĊ def Ġcomb (n , Ġr , Ġmod ):ĊĊ ĠĠĠ Ġr Ġ= Ġmin (r , Ġn -r )ĊĊ ĠĠĠ Ġmol Ġ= Ġ 1 ĊĊ ĠĠĠ Ġden o Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġr + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġmol Ġ= Ġmol Ġ* Ġ( n -r +i ) Ġ% Ġmod ĊĊ ĠĠĠĠĠĠĠ Ġden o Ġ= Ġden o Ġ* Ġi Ġ% Ġmod ĊĊ ĠĠĠ Ġret Ġ= Ġmol Ġ* Ġpow (d eno , Ġmod - 2 , Ġmod ) Ġ% Ġmod ĊĊ ĠĠĠ Ġreturn Ġret ĊĊĊĊ def Ġf 1 (x ,y ,a ,b ):ĊĊ ĠĠĠ Ġreturn Ġ( a +b -x -y )*( a -x + 1 )*( b -y + 1 )// 2 ĊĊĊĊ def Ġf 2 (x ,a ):ĊĊ ĠĠĠ Ġreturn Ġ( a -x )*( a -x + 1 )// 2 ĊĊĊĊ ans Ġ= Ġ 0 ĊĊĊĊ for Ġx Ġin Ġrange ( 1 ,n + 1 ):ĊĊ ĠĠĠ Ġfor Ġy Ġin Ġrange ( 1 ,m + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġa Ġ= Ġn -x + 1 ĊĊ ĠĠĠĠĠĠĠ Ġb Ġ= Ġm -y + 1 ĊĊ ĠĠĠĠĠĠĠ Ġc Ġ= Ġm *( a *( a - 1 )+ x *( x - 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġd Ġ= Ġn *( b *( b - 1 )+ y *( y - 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ( c +d )// 2 ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ%= Ġmod ĊĊĊĊ ans Ġ= Ġ( ans Ġ* Ġcomb (m *n - 2 ,k - 2 , mod )) % mod ĊĊ ans Ġ= Ġans *pow ( 2 , mod - 2 , mod )% mod ĊĊĊĊ print (ans )ĊĊĊ


Input:
N,M = list(map(int,input().split()))

div =[]

for i in range(2,int(M**(1/2))+2):

    cur = 0

    while M%i==0:

        M = M//i

        cur += 1

    if cur >=1:

        div.append(cur)

if M>1: div.append(1)

div.sort()

mod = 10**9+7

frac = [1]*(N+50)

num = len(frac)

for i in range(len(frac)-1):

    frac[i+1] = frac[i]*(i+1)%mod

finv = [1] * (N+50)

finv[-1] = pow(frac[-1], mod-2, mod)

for i in range(1, num):

  finv[num-1-i] = finv[num-i] * (num-i) % mod

ans = 1

for i in div:

    ans = ans * frac[N+i-1]*finv[N-1]*finv[i]%mod

print(ans)

N ,M Ġ= Ġlist (map (int ,input (). split ()))ĊĊ div Ġ= [] ĊĊ for Ġi Ġin Ġrange ( 2 ,int (M **( 1 / 2 ))+ 2 ):ĊĊ ĠĠĠ Ġcur Ġ= Ġ 0 ĊĊ ĠĠĠ Ġwhile ĠM %i == 0 :ĊĊ ĠĠĠĠĠĠĠ ĠM Ġ= ĠM // i ĊĊ ĠĠĠĠĠĠĠ Ġcur Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġcur Ġ>= 1 :ĊĊ ĠĠĠĠĠĠĠ Ġdiv .append (cur )ĊĊ if ĠM > 1 : Ġdiv .append ( 1 )ĊĊ div .sort ()ĊĊ mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊ frac Ġ= Ġ[ 1 ]*( N + 5 0 )ĊĊ num Ġ= Ġlen (f rac )ĊĊ for Ġi Ġin Ġrange (len (f rac )- 1 ):ĊĊ ĠĠĠ Ġfrac [i + 1 ] Ġ= Ġfrac [i ]*( i + 1 )% mod ĊĊ fin v Ġ= Ġ[ 1 ] Ġ* Ġ( N + 5 0 )ĊĊ fin v [- 1 ] Ġ= Ġpow (f rac [- 1 ], Ġmod - 2 , Ġmod )ĊĊ for Ġi Ġin Ġrange ( 1 , Ġnum ):ĊĊ Ġ Ġfin v [num - 1 -i ] Ġ= Ġfin v [num -i ] Ġ* Ġ( num -i ) Ġ% Ġmod ĊĊ ans Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġdiv :ĊĊ ĠĠĠ Ġans Ġ= Ġans Ġ* Ġfrac [N +i - 1 ]* fin v [N - 1 ]* fin v [i ]% mod ĊĊ print (ans )


Input:
a, b, c, x, y = list(map(int, input().split()))

# print(a, b, c, x, y)

ans = 10000 * (10 **5) + 7

c_max = 0

if x > y:

  c_max = x * 2

else:

  c_max = y * 2

for cc in range(c_max+1):

  ac = x - (cc // 2)

  bc = y - (cc // 2)

  if ac < 0:

    ac = 0

  if bc < 0:

    bc = 0

  price = ac * a + bc * b + cc * c

  # print('price: {}, ac: {}, bc: {}, cc: {}'.format(price, ac, bc, cc))

  ans = min(ans, price)

print(ans)

a , Ġb , Ġc , Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ # Ġprint (a , Ġb , Ġc , Ġx , Ġy )ĊĊĊĊ ans Ġ= Ġ 1 0 0 0 0 Ġ* Ġ( 1 0 Ġ** 5 ) Ġ+ Ġ 7 ĊĊ c _max Ġ= Ġ 0 ĊĊ if Ġx Ġ> Ġy :ĊĊ Ġ Ġc _max Ġ= Ġx Ġ* Ġ 2 ĊĊ else :ĊĊ Ġ Ġc _max Ġ= Ġy Ġ* Ġ 2 ĊĊĊĊ for Ġcc Ġin Ġrange (c _max + 1 ):ĊĊ Ġ Ġac Ġ= Ġx Ġ- Ġ( cc Ġ// Ġ 2 )ĊĊ Ġ Ġbc Ġ= Ġy Ġ- Ġ( cc Ġ// Ġ 2 )ĊĊ ĠĠĊĊ Ġ Ġif Ġac Ġ< Ġ 0 :ĊĊ ĠĠĠ Ġac Ġ= Ġ 0 ĊĊ Ġ Ġif Ġbc Ġ< Ġ 0 :ĊĊ ĠĠĠ Ġbc Ġ= Ġ 0 ĊĊ Ġ Ġprice Ġ= Ġac Ġ* Ġa Ġ+ Ġbc Ġ* Ġb Ġ+ Ġcc Ġ* Ġc ĊĊ Ġ Ġ# Ġprint (' price : Ġ{}, Ġac : Ġ{}, Ġbc : Ġ{}, Ġcc : Ġ{}'. format (price , Ġac , Ġbc , Ġcc ))ĊĊ Ġ Ġans Ġ= Ġmin (ans , Ġprice )ĊĊĊĊ print (ans )


Input:
N = int(input())

name = {'M':0, 'A':0, 'R':0, 'C':0, 'H':0}

march = "MARCH"

for _ in range(N):

  S = input()

  if(S[0] in name):

    name[S[0]] += 1

ans = 0

for i in range(3):

  for j in range(i+1,4):

    for k in range(j+1,5):

      ans += name[march[i]] * name[march[j]] * name[march[k]]

print(ans)

N Ġ= Ġint (input ())ĊĊ name Ġ= Ġ{' M ': 0 , Ġ' A ': 0 , Ġ' R ': 0 , Ġ' C ': 0 , Ġ' H ': 0 }ĊĊ m arch Ġ= Ġ" M ARCH "ĊĊ for Ġ_ Ġin Ġrange (N ):ĊĊ Ġ ĠS Ġ= Ġinput ()ĊĊ Ġ Ġif (S [ 0 ] Ġin Ġname ):ĊĊ ĠĠĠ Ġname [S [ 0 ]] Ġ+= Ġ 1 ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 3 ):ĊĊ Ġ Ġfor Ġj Ġin Ġrange (i + 1 , 4 ):ĊĊ ĠĠĠ Ġfor Ġk Ġin Ġrange (j + 1 , 5 ):ĊĊ ĠĠĠĠĠ Ġans Ġ+= Ġname [m arch [i ]] Ġ* Ġname [m arch [j ]] Ġ* Ġname [m arch [k ]]ĊĊ print (ans )


Input:
n = int(input())

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

ans = [i for i in range(n)]

a1 = sorted(a)

for i in range(n):

    num = a[i]

    ans[num - 1] = str(i + 1)

print((' '.join(ans)))

n Ġ= Ġint (input ())ĊĊ a Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ans Ġ= Ġ[ i Ġfor Ġi Ġin Ġrange (n )]ĊĊ a 1 Ġ= Ġsorted (a )ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġnum Ġ= Ġa [i ]ĊĊ ĠĠĠ Ġans [num Ġ- Ġ 1 ] Ġ= Ġstr (i Ġ+ Ġ 1 )ĊĊ ĠĠĠĠĊĊ print ((' Ġ'. join (ans )))


Input:
INF = 2*10**7

def main():

    N, M = (int(i) for i in input().split())

    A = []

    B = []

    C = []

    for _ in range(M):

        a, b = (int(i) for i in input().split())

        A.append(a)

        B.append(b)

        bit = 0

        for i in input().split():

            bit |= (1 << (int(i)-1))

        C.append(bit)

    dp = [[INF]*(1 << N) for _ in range(M+1)]

    dp[0][0] = 0

    for i in range(M):

        for j in range(1 << N):

            dp[i+1][j] = min(dp[i+1][j], dp[i][j])

            if dp[i][j] != INF:

                next_bit = j | C[i]

                dp[i+1][next_bit] = min(dp[i+1][next_bit], dp[i][j] + A[i])

    ans = dp[-1][-1]

    if ans == INF:

        print((-1))

    else:

        print(ans)

    # print(*dp, sep="\n")

if __name__ == '__main__':

    main()

INF Ġ= Ġ 2 * 1 0 ** 7 ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠN , ĠM Ġ= Ġ( int (i ) Ġfor Ġi Ġin Ġinput (). split ())ĊĊ ĠĠĠ ĠA Ġ= Ġ[]ĊĊ ĠĠĠ ĠB Ġ= Ġ[]ĊĊ ĠĠĠ ĠC Ġ= Ġ[]ĊĊ ĠĠĠ Ġfor Ġ_ Ġin Ġrange (M ):ĊĊ ĠĠĠĠĠĠĠ Ġa , Ġb Ġ= Ġ( int (i ) Ġfor Ġi Ġin Ġinput (). split ())ĊĊ ĠĠĠĠĠĠĠ ĠA .append (a )ĊĊ ĠĠĠĠĠĠĠ ĠB .append (b )ĊĊ ĠĠĠĠĠĠĠ Ġbit Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġinput (). split ():ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbit Ġ|= Ġ( 1 Ġ<< Ġ( int (i )- 1 ))ĊĊ ĠĠĠĠĠĠĠ ĠC .append (bit )ĊĊ ĠĠĠ Ġdp Ġ= Ġ[[ INF ]*( 1 Ġ<< ĠN ) Ġfor Ġ_ Ġin Ġrange (M + 1 )]ĊĊ ĠĠĠ Ġdp [ 0 ][ 0 ] Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 Ġ<< ĠN ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdp [i + 1 ][ j ] Ġ= Ġmin (dp [i + 1 ][ j ], Ġdp [i ][ j ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġdp [i ][ j ] Ġ!= ĠINF :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġnext _bit Ġ= Ġj Ġ| ĠC [i ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp [i + 1 ][ next _bit ] Ġ= Ġmin (dp [i + 1 ][ next _bit ], Ġdp [i ][ j ] Ġ+ ĠA [i ])ĊĊ ĠĠĠ Ġans Ġ= Ġdp [- 1 ][- 1 ]ĊĊ ĠĠĠ Ġif Ġans Ġ== ĠINF :ĊĊ ĠĠĠĠĠĠĠ Ġprint ((- 1 ))ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint (ans )ĊĊ ĠĠĠ Ġ# Ġprint (* dp , Ġsep ="\ n ")ĊĊ ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
def prime_factorize(num):

    """

    This function performs prime factorization on the input natural number.

    The result is returned in the form of a dictionary with the prime number as the key

    and its number as the value.

    :param num:

    :return prime_factor: Dictionary with the prime number as the key and its number as the value.

    """

    prime_factor = {}

    i = 2

    while i ** 2 <= num:

        while num % i == 0:

            num //= i

            if i in list(prime_factor.keys()):

                prime_factor[i] += 1

            else:

                prime_factor[i] = 1

        i += 1

    if num > 1:

        prime_factor[num] = 1

    return prime_factor

from math import factorial

def comb(n, r, R):

    if n not in R:

        a = factorial(n)

        R[n] = a

    else:

        a = R[n]

    if n - r not in R:

        b = factorial(n - r)

        R[n - r] = b

    else:

        b = R[n - r]

    if r not in R:

        c = factorial(r)

        R[r] = c

    else:

        c = R[r]

    return a // (b * c)

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

r = 1

R = dict()

prime_fac = prime_factorize(m)

for v in list(prime_fac.values()):

    r *= comb(v + n - 1, v, R)

mod = 1000000000 + 7

print((r % mod))

def Ġprime _factor ize (num ):ĊĊ ĠĠĠ Ġ"""ĊĊ ĠĠĠ ĠThis Ġfunction Ġperforms Ġprime Ġfactor ization Ġon Ġthe Ġinput Ġnatural Ġnumber .ĊĊ ĠĠĠ ĠThe Ġresult Ġis Ġreturned Ġin Ġthe Ġform Ġof Ġa Ġdictionary Ġwith Ġthe Ġprime Ġnumber Ġas Ġthe Ġkey ĊĊ ĠĠĠ Ġand Ġits Ġnumber Ġas Ġthe Ġvalue .ĊĊ ĠĠĠ Ġ: param Ġnum :ĊĊ ĠĠĠ Ġ: return Ġprime _factor : ĠDictionary Ġwith Ġthe Ġprime Ġnumber Ġas Ġthe Ġkey Ġand Ġits Ġnumber Ġas Ġthe Ġvalue .ĊĊ ĠĠĠ Ġ"""ĊĊ ĠĠĠ Ġprime _factor Ġ= Ġ{}ĊĊ ĠĠĠ Ġi Ġ= Ġ 2 ĊĊ ĠĠĠ Ġwhile Ġi Ġ** Ġ 2 Ġ<= Ġnum :ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġnum Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġnum Ġ//= Ġi ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi Ġin Ġlist (pr ime _factor .keys ()) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġprime _factor [i ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġprime _factor [i ] Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġi Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġnum Ġ> Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġprime _factor [num ] Ġ= Ġ 1 ĊĊ ĠĠĠ Ġreturn Ġprime _factor ĊĊĊĊĊĊ from Ġmath Ġimport Ġfactorial ĊĊĊĊĊĊ def Ġcomb (n , Ġr , ĠR ):ĊĊ ĠĠĠ Ġif Ġn Ġnot Ġin ĠR :ĊĊ ĠĠĠĠĠĠĠ Ġa Ġ= Ġfactorial (n )ĊĊ ĠĠĠĠĠĠĠ ĠR [n ] Ġ= Ġa ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġa Ġ= ĠR [n ]ĊĊĊĊ ĠĠĠ Ġif Ġn Ġ- Ġr Ġnot Ġin ĠR :ĊĊ ĠĠĠĠĠĠĠ Ġb Ġ= Ġfactorial (n Ġ- Ġr )ĊĊ ĠĠĠĠĠĠĠ ĠR [n Ġ- Ġr ] Ġ= Ġb ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġb Ġ= ĠR [n Ġ- Ġr ]ĊĊĊĊ ĠĠĠ Ġif Ġr Ġnot Ġin ĠR :ĊĊ ĠĠĠĠĠĠĠ Ġc Ġ= Ġfactorial (r )ĊĊ ĠĠĠĠĠĠĠ ĠR [r ] Ġ= Ġc ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġc Ġ= ĠR [r ]ĊĊ ĠĠĠ Ġreturn Ġa Ġ// Ġ( b Ġ* Ġc )ĊĊĊĊĊĊ n , Ġm Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ r Ġ= Ġ 1 ĊĊĊĊ R Ġ= Ġdict ()ĊĊ prime _fac Ġ= Ġprime _factor ize (m )ĊĊ for Ġv Ġin Ġlist (pr ime _fac .values ()) :ĊĊ ĠĠĠ Ġr Ġ*= Ġcomb (v Ġ+ Ġn Ġ- Ġ 1 , Ġv , ĠR )ĊĊ mod Ġ= Ġ 1 0 0 0 0 0 0 0 0 0 Ġ+ Ġ 7 ĊĊ print (( r Ġ% Ġmod ))Ċ


Input:
a, b, c = list(map(int, input().split()))

if a < b + c:

    print((b+c-a))

else:

    print((0))

a , Ġb , Ġc Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ if Ġa Ġ< Ġb Ġ+ Ġc :ĊĊ ĠĠĠ Ġprint (( b +c -a ))ĊĊ else :ĊĊ ĠĠĠ Ġprint (( 0 ))


Input:
from collections import Counter

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

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

X = Counter(A)

for i in range(M):

    B, C = list(map(int, input().split()))

    X[C] += B

Z = []

for key, value in list(X.items()):

    Z.append((key, value))

Z.sort(key=lambda x: x[0], reverse=True)

ans = 0

cnt = 0

for value, key in Z:

    if cnt + key <= N:

        ans += key * value

        cnt += key

    else:

        ans += (N - cnt) * value

        break

print(ans)

from Ġcollections Ġimport ĠCounter ĊĊ N , ĠM Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ A Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ X Ġ= ĠCounter (A )ĊĊ for Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠ ĠB , ĠC Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠX [C ] Ġ+= ĠB ĊĊĊĊ Z Ġ= Ġ[]ĊĊ for Ġkey , Ġvalue Ġin Ġlist (X .items ()) :ĊĊ ĠĠĠ ĠZ .append (( key , Ġvalue )) ĊĊĊĊ Z .sort (key =lambda Ġx : Ġx [ 0 ], Ġreverse =True )ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ cnt Ġ= Ġ 0 ĊĊĊĊ for Ġvalue , Ġkey Ġin ĠZ :ĊĊ ĠĠĠ Ġif Ġcnt Ġ+ Ġkey Ġ<= ĠN :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġkey Ġ* Ġvalue ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġkey ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ( N Ġ- Ġcnt ) Ġ* Ġvalue ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ print (ans )Ċ


Input:
a, b, c = list(map(int, input().split()))

if any(i % 2 != 0 for i in [a, b, c]):

    print((0))

    exit()

if a == b and b == c:

    print((-1))

    exit()

cnt = 0

a_list = [0]*(1001001)

b_list = [0]*(1001001)

c_list = [0]*(1001001)

a_list[0] = a

b_list[0] = b

c_list[0] = c

for i in range(1, 1001001):

    a_list[i] = (b_list[i-1] + c_list[i-1]) // 2

    b_list[i] = (c_list[i-1] + a_list[i-1]) // 2

    c_list[i] = (a_list[i-1] + b_list[i-1]) // 2

    cnt += 1

    if a_list[i] % 2 != 0 or b_list[i] % 2 != 0 or c_list[i] % 2 != 0:

        break

print(cnt)

a , Ġb , Ġc Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ if Ġany (i Ġ% Ġ 2 Ġ!= Ġ 0 Ġfor Ġi Ġin Ġ[ a , Ġb , Ġc ]) :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠ Ġexit ()ĊĊĊĊ if Ġa Ġ== Ġb Ġand Ġb Ġ== Ġc :ĊĊ ĠĠĠ Ġprint ((- 1 ))ĊĊ ĠĠĠ Ġexit ()ĊĊĊĊ cnt Ġ= Ġ 0 ĊĊ a _list Ġ= Ġ[ 0 ]*( 1 0 0 1 0 0 1 )ĊĊ b _list Ġ= Ġ[ 0 ]*( 1 0 0 1 0 0 1 )ĊĊ c _list Ġ= Ġ[ 0 ]*( 1 0 0 1 0 0 1 )ĊĊ a _list [ 0 ] Ġ= Ġa ĊĊ b _list [ 0 ] Ġ= Ġb ĊĊ c _list [ 0 ] Ġ= Ġc ĊĊĊĊ for Ġi Ġin Ġrange ( 1 , Ġ 1 0 0 1 0 0 1 ):ĊĊ ĠĠĠ Ġa _list [i ] Ġ= Ġ( b _list [i - 1 ] Ġ+ Ġc _list [i - 1 ]) Ġ// Ġ 2 ĊĊ ĠĠĠ Ġb _list [i ] Ġ= Ġ( c _list [i - 1 ] Ġ+ Ġa _list [i - 1 ]) Ġ// Ġ 2 ĊĊ ĠĠĠ Ġc _list [i ] Ġ= Ġ( a _list [i - 1 ] Ġ+ Ġb _list [i - 1 ]) Ġ// Ġ 2 ĊĊ ĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġa _list [i ] Ġ% Ġ 2 Ġ!= Ġ 0 Ġor Ġb _list [i ] Ġ% Ġ 2 Ġ!= Ġ 0 Ġor Ġc _list [i ] Ġ% Ġ 2 Ġ!= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ print (cnt )Ċ


Input:
from functools import lru_cache

import sys

sys.setrecursionlimit(30000)

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

a = list(int(input()) for _ in range(M))

MOD = pow(10, 9) + 7

isOk = True

for i in range(M-1):

    if a[i] + 1 == a[i+1]:

        isOk = False

funcb = [-1] * 100001

def func(n):

    if n <= 0:

        return 1

    cnt = funcb[n]

    if cnt > 0:

        return cnt

    cnt = 0

    if n >= 2:

        cnt += func(n-2)

    if n >= 1:

        cnt += func(n-1)

    funcb[n] = cnt % MOD

    return funcb[n]

func(30000)

func(50000)

func(80000)

func(100000)

if not isOk:

    print((0))

else:

    ans = 1

    s = 0

    for i in range(M+1):

        if i >= M:

            e = N

        else:

            e = a[i] - 1

        ans = ans * func(e-s) % MOD

        if i >= M:

            break

        s = a[i] + 1

    print(ans)

from Ġfunctools Ġimport Ġl ru _cache ĊĊ import Ġsys ĊĊ sys .set rec ursion limit ( 3 0 0 0 0 )ĊĊĊĊ N , ĠM Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġlist (int (input ()) Ġfor Ġ_ Ġin Ġrange (M )) ĊĊĊĊ MOD Ġ= Ġpow ( 1 0 , Ġ 9 ) Ġ+ Ġ 7 ĊĊĊĊ isOk Ġ= ĠTrue ĊĊ for Ġi Ġin Ġrange (M - 1 ):ĊĊ ĠĠĠ Ġif Ġa [i ] Ġ+ Ġ 1 Ġ== Ġa [i + 1 ]:ĊĊ ĠĠĠĠĠĠĠ Ġis Ok Ġ= ĠFalse ĊĊ ĠĠĠĠĊĊ func b Ġ= Ġ[- 1 ] Ġ* Ġ 1 0 0 0 0 1 ĊĊ def Ġfunc (n ):ĊĊ ĠĠĠ Ġif Ġn Ġ<= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 1 ĊĊ ĠĠĠ Ġcnt Ġ= Ġfunc b [n ]ĊĊ ĠĠĠ Ġif Ġcnt Ġ> Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġcnt ĊĊ ĠĠĠ Ġcnt Ġ= Ġ 0 ĊĊ ĠĠĠ Ġif Ġn Ġ>= Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġfunc (n - 2 )ĊĊ ĠĠĠ Ġif Ġn Ġ>= Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġfunc (n - 1 )ĊĊ ĠĠĠ Ġfunc b [n ] Ġ= Ġcnt Ġ% ĠMOD ĊĊ ĠĠĠ Ġreturn Ġfunc b [n ]ĊĊĊĊ func ( 3 0 0 0 0 )ĊĊ func ( 5 0 0 0 0 )ĊĊ func ( 8 0 0 0 0 )ĊĊ func ( 1 0 0 0 0 0 )ĊĊĊĊ if Ġnot Ġis Ok :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ else :ĊĊ ĠĠĠ Ġans Ġ= Ġ 1 ĊĊ ĠĠĠ Ġs Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (M + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi Ġ>= ĠM :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġe Ġ= ĠN ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġe Ġ= Ġa [i ] Ġ- Ġ 1 ĊĊĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġans Ġ* Ġfunc (e -s ) Ġ% ĠMOD ĊĊĊĊ ĠĠĠĠĠĠĠ Ġif Ġi Ġ>= ĠM :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ ĠĠĠĠĠĠĠ Ġs Ġ= Ġa [i ] Ġ+ Ġ 1 ĊĊĊĊ ĠĠĠ Ġprint (ans )Ċ


Input:
# 2019-11-17 20:44:23(JST)

import sys

# import collections

# import math

# from string import ascii_lowercase, ascii_uppercase, digits

# from bisect import bisect_left as bi_l, bisect_right as bi_r

# import itertools

# from functools import reduce

# import operator as op

# import re

# import heapq

# import array

# from scipy.misc import comb # (default: exact=False)

# import numpy as np

def main():

    s, t = sys.stdin.read().split()

    count = 0

    for i in range(3):

        if s[i] == t[i]:

            count += 1

    print(count)

if __name__ == "__main__":

    main()

# Ġ 2 0 1 9 - 1 1 - 1 7 Ġ 2 0 : 4 4 : 2 3 (J ST )ĊĊ import Ġsys ĊĊ # Ġimport Ġcollections ĊĊ # Ġimport Ġmath ĊĊ # Ġfrom Ġstring Ġimport Ġascii _lowercase , Ġascii _upper case , Ġdigits ĊĊ # Ġfrom Ġbis ect Ġimport Ġbis ect _left Ġas Ġbi _l , Ġbis ect _right Ġas Ġbi _r ĊĊ # Ġimport Ġitertools ĊĊ # Ġfrom Ġfunctools Ġimport Ġreduce ĊĊ # Ġimport Ġoperator Ġas Ġop ĊĊ # Ġimport Ġre ĊĊ # Ġimport Ġheapq ĊĊ # Ġimport Ġarray ĊĊ # Ġfrom Ġscipy .misc Ġimport Ġcomb Ġ# Ġ( default : Ġexact =False )ĊĊ # Ġimport Ġnumpy Ġas Ġnp Ġ ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġs , Ġt Ġ= Ġsys .stdin .read (). split ()ĊĊĊĊ ĠĠĠ Ġcount Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 3 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [i ] Ġ== Ġt [i ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġprint (count )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
#                         author:  kagemeka

#                         created: 2019-11-06 21:30:22(JST)

import sys

# import collections

# import math

# import string

# import bisect

# import re

# import itertools

# import statistics

# import functools

# import operator

def main():

    a, b = (int(x) for x in sys.stdin.read().split())

    count = 0

    for n in range(a, b+1):

        n = str(n)

        if n == n[::-1]:

            count += 1

    print(count)

if __name__ == "__main__":

    # execute only if run as a script

    main()

# ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġauthor : Ġ Ġk agem eka ĠĊĊ # ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġcreated : Ġ 2 0 1 9 - 1 1 - 0 6 Ġ 2 1 : 3 0 : 2 2 (J ST )ĊĊ import Ġsys ĊĊ # Ġimport Ġcollections ĊĊ # Ġimport Ġmath ĊĊ # Ġimport Ġstring ĊĊ # Ġimport Ġbis ect ĊĊ # Ġimport Ġre ĊĊ # Ġimport Ġitertools ĊĊ # Ġimport Ġstatistics ĊĊ # Ġimport Ġfunctools ĊĊ # Ġimport Ġoperator ĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġa , Ġb Ġ= Ġ( int (x ) Ġfor Ġx Ġin Ġsys .stdin .read (). split ())ĊĊ ĊĊ ĠĠĠ Ġcount Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġn Ġin Ġrange (a , Ġb + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ= Ġstr (n )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ== Ġn [::- 1 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġprint (count ) ĠĠĠĠĠĠĠ ĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġ# Ġexecute Ġonly Ġif Ġrun Ġas Ġa Ġscript ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
N = int(input())

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

X = list(sorted(X))

if N == 1:

  print((0))

  exit()

ans = float('inf')

for p in range(X[0], X[N - 1] + 1):

  sum = 0

  for x in X:

    sum += (x - p) ** 2

  ans = min(sum, ans)

print(ans)

N Ġ= Ġint (input ())ĊĊ X Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ X Ġ= Ġlist (sorted (X ))ĊĊ if ĠN Ġ== Ġ 1 :ĊĊ Ġ Ġprint (( 0 ))ĊĊ Ġ Ġexit ()ĊĊ ans Ġ= Ġfloat (' inf ')ĊĊ for Ġp Ġin Ġrange (X [ 0 ], ĠX [N Ġ- Ġ 1 ] Ġ+ Ġ 1 ):ĊĊ Ġ Ġsum Ġ= Ġ 0 ĊĊ Ġ Ġfor Ġx Ġin ĠX :ĊĊ ĠĠĠ Ġsum Ġ+= Ġ( x Ġ- Ġp ) Ġ** Ġ 2 ĊĊ Ġ Ġans Ġ= Ġmin (sum , Ġans )ĊĊ print (ans )


Input:
k, n = list(map(int, input().split()))

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

d = [0] * n

d_max = 0

for i in range(n - 1):

    d[i] = a[i + 1] - a[i]

    d_max = max(d_max, d[i])

d[-1] = (k - a[-1]) + a[0]

d_max = max(d_max, d[-1])

print((k - d_max))

k , Ġn Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ d Ġ= Ġ[ 0 ] Ġ* Ġn ĊĊ d _max Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (n Ġ- Ġ 1 ):ĊĊ ĠĠĠ Ġd [i ] Ġ= Ġa [i Ġ+ Ġ 1 ] Ġ- Ġa [i ]ĊĊ ĠĠĠ Ġd _max Ġ= Ġmax (d _max , Ġd [i ])ĊĊ ĊĊ d [- 1 ] Ġ= Ġ( k Ġ- Ġa [- 1 ]) Ġ+ Ġa [ 0 ]ĊĊ d _max Ġ= Ġmax (d _max , Ġd [- 1 ])ĊĊ ĊĊ print (( k Ġ- Ġd _max ))Ċ


Input:
import sys

input = sys.stdin.readline

from collections import deque

N = int(input())

X = [[] for i in range(N)]

for i in range(N-1):

    x, y = list(map(int, input().split()))

    X[x-1].append(y-1)

    X[y-1].append(x-1)

i0 = min([i for i in range(N) if len(X[i]) == 1])

P = [-1] * N

Q = deque([i0])

R = []

while Q:

    i = deque.popleft(Q)

    R.append(i)

    for a in X[i]:

        if a != P[i]:

            P[a] = i

            X[a].remove(i)

            deque.append(Q, a)

mod = 10 ** 9 + 7

inv2 = (mod + 1) // 2

A = [1] * N

for i in R[::-1]:

    s = 0

    for j in X[i]:

        A[i] += A[j]

ans = 0

for i in range(N):

    s = pow(inv2, N - A[i], mod)

    t = 1 + (1-pow(inv2, N - A[i], mod)) * pow(2, N - A[i], mod)

    for j in X[i]:

        s = (s * pow(inv2, A[j], mod)) % mod

        t = (t + (1-pow(inv2, A[j], mod)) * pow(2, A[j], mod)) % mod

    ans = (ans + 1 - s * t) % mod

print((ans * inv2 % mod))

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ from Ġcollections Ġimport Ġdeque ĊĊ N Ġ= Ġint (input ())ĊĊ X Ġ= Ġ[[] Ġfor Ġi Ġin Ġrange (N )]ĊĊ for Ġi Ġin Ġrange (N - 1 ):ĊĊ ĠĠĠ Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠX [x - 1 ]. append (y - 1 )ĊĊ ĠĠĠ ĠX [y - 1 ]. append (x - 1 )ĊĊ i 0 Ġ= Ġmin ([ i Ġfor Ġi Ġin Ġrange (N ) Ġif Ġlen (X [i ]) Ġ== Ġ 1 ])ĊĊ ĊĊ P Ġ= Ġ[- 1 ] Ġ* ĠN ĊĊ Q Ġ= Ġdeque ([ i 0 ])ĊĊ R Ġ= Ġ[]ĊĊ while ĠQ :ĊĊ ĠĠĠ Ġi Ġ= Ġdeque .p opleft (Q )ĊĊ ĠĠĠ ĠR .append (i )ĊĊ ĠĠĠ Ġfor Ġa Ġin ĠX [i ]:ĊĊ ĠĠĠĠĠĠĠ Ġif Ġa Ġ!= ĠP [i ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠP [a ] Ġ= Ġi ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠX [a ]. remove (i )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdeque .append (Q , Ġa )ĊĊĊĊ mod Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĊĊ inv 2 Ġ= Ġ( mod Ġ+ Ġ 1 ) Ġ// Ġ 2 ĊĊ A Ġ= Ġ[ 1 ] Ġ* ĠN ĊĊ for Ġi Ġin ĠR [::- 1 ]:ĊĊ ĠĠĠ Ġs Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġj Ġin ĠX [i ]:ĊĊ ĠĠĠĠĠĠĠ ĠA [i ] Ġ+= ĠA [j ]ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġs Ġ= Ġpow (inv 2 , ĠN Ġ- ĠA [i ], Ġmod )ĊĊ ĠĠĠ Ġt Ġ= Ġ 1 Ġ+ Ġ( 1 -p ow (inv 2 , ĠN Ġ- ĠA [i ], Ġmod )) Ġ* Ġpow ( 2 , ĠN Ġ- ĠA [i ], Ġmod )ĊĊ ĠĠĠ Ġfor Ġj Ġin ĠX [i ]:ĊĊ ĠĠĠĠĠĠĠ Ġs Ġ= Ġ( s Ġ* Ġpow (inv 2 , ĠA [j ], Ġmod )) Ġ% Ġmod ĊĊ ĠĠĠĠĠĠĠ Ġt Ġ= Ġ( t Ġ+ Ġ( 1 -p ow (inv 2 , ĠA [j ], Ġmod )) Ġ* Ġpow ( 2 , ĠA [j ], Ġmod )) Ġ% Ġmod ĊĊ ĠĠĠ Ġans Ġ= Ġ( ans Ġ+ Ġ 1 Ġ- Ġs Ġ* Ġt ) Ġ% Ġmod ĊĊĊĊ print (( ans Ġ* Ġinv 2 Ġ% Ġmod ))


Input:
from math import factorial

def myAnswer(N:int) ->int:

   ans =factorial(N)

   return ans % (10**9 + 7)

def modelAnswer():

   tmp=1

def main():

   N = int(input())

   print((myAnswer(N)))

if __name__ == '__main__':

   main()

from Ġmath Ġimport Ġfactorial ĊĊ def Ġmy Answer (N :int ) Ġ-> int :ĊĊ ĠĠ Ġans Ġ= factor ial (N )ĊĊ ĠĠ Ġreturn Ġans Ġ% Ġ( 1 0 ** 9 Ġ+ Ġ 7 )ĊĊĊĊ def Ġmodel Answer ():ĊĊ ĠĠ Ġtmp = 1 ĊĊ def Ġmain ():ĊĊ ĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĠĠ Ġprint (( my Answer (N )))ĊĊ ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠ Ġmain ()


Input:
s = input()[::-1]

while True:

    if len(s) == 0:

        break

    if s[:7] == "remaerd":

        s = s[7:]

    elif s[:6] == "resare":

        s = s[6:]

    elif s[:5] == "maerd" or s[:5] == "esare":

        s = s[5:]

    else:

        print("NO")

        exit()

print("YES")

s Ġ= Ġinput ()[ ::- 1 ]ĊĊĊĊ while ĠTrue :ĊĊ ĠĠĠ Ġif Ġlen (s ) Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġif Ġs [: 7 ] Ġ== Ġ" rema erd ":ĊĊ ĠĠĠĠĠĠĠ Ġs Ġ= Ġs [ 7 :]ĊĊ ĠĠĠ Ġelif Ġs [: 6 ] Ġ== Ġ" res are ":ĊĊ ĠĠĠĠĠĠĠ Ġs Ġ= Ġs [ 6 :]ĊĊ ĠĠĠ Ġelif Ġs [: 5 ] Ġ== Ġ" ma erd " Ġor Ġs [: 5 ] Ġ== Ġ" es are ":ĊĊ ĠĠĠĠĠĠĠ Ġs Ġ= Ġs [ 5 :]ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint (" NO ")ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊĊĊ print (" YES ")


Input:
import sys

stdin = sys.stdin

ni = lambda: int(ns())

na = lambda: list(map(int, stdin.readline().split()))

ns = lambda: stdin.readline()

def Solve():

    N,K=na()

    S=[int(d) for d in input()]

    l=[]

    N=len(S)

    if(S[0]==0):

        l.append(0)

    b=S[0]

    ct=1

    for i in S[1:]:

        if(b!=i):

            l.append(ct)

            ct=1

            b=i

        else:

            ct+=1

    l.append(ct)

    len_l=len(l)

    if(len_l//2 <= K):

        return sum(l)

    ans = res = sum(l[:2*K+1])

    if(len_l%2==0):

        l.append(0)

        len_l+=1

    g = K * 2 + 1

    for i in range(K*2+1,len_l-1,2):

        ans -= l[i-g] + l[i-g+1]

        ans += l[i] + l[1+i]

        if(res<ans):

            res=ans

    #print(S)

    #print(l)

    #print(len_l)

    return res

print((Solve()))

import Ġsys ĊĊ stdin Ġ= Ġsys .stdin ĠĊĊ ni Ġ= Ġlambda : Ġint (ns ())ĊĊ na Ġ= Ġlambda : Ġlist (map (int , Ġstdin .readline (). split ()))ĊĊ ns Ġ= Ġlambda : Ġstdin .readline ()ĊĊĊĊ def ĠSolve ():ĊĊ ĠĠĠ ĠN ,K = na ()ĊĊ ĠĠĠ ĠS =[ int (d ) Ġfor Ġd Ġin Ġinput ()]ĊĊ ĠĠĠ Ġl =[] ĊĊ ĠĠĠ ĠN =len (S )ĊĊ ĠĠĠ Ġif (S [ 0 ]== 0 ):ĊĊ ĠĠĠĠĠĠĠ Ġl .append ( 0 )ĊĊ ĠĠĠ Ġb =S [ 0 ]ĊĊ ĠĠĠ Ġct = 1 ĊĊ ĠĠĠ Ġfor Ġi Ġin ĠS [ 1 :] :ĊĊ ĠĠĠĠĠĠĠ Ġif (b != i ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġl .append (ct )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġct = 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġb =i ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġct += 1 ĊĊ ĠĠĠ Ġl .append (ct )ĊĊ ĠĠĠ Ġlen _l =len (l )ĊĊ ĠĠĠ Ġif (len _l // 2 Ġ<= ĠK ):ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġsum (l )ĊĊ ĠĠĠ Ġans Ġ= Ġres Ġ= Ġsum (l [: 2 *K + 1 ])ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġif (len _l % 2 == 0 ):ĊĊ ĠĠĠĠĠĠĠ Ġl .append ( 0 )ĊĊ ĠĠĠĠĠĠĠ Ġlen _l += 1 ĊĊ ĠĠĠ Ġg Ġ= ĠK Ġ* Ġ 2 Ġ+ Ġ 1 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (K * 2 + 1 ,len _l - 1 , 2 ):ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ-= Ġl [i -g ] Ġ+ Ġl [i -g + 1 ]ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġl [i ] Ġ+ Ġl [ 1 +i ]ĊĊ ĠĠĠĠĠĠĠ Ġif (res < ans ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġres = ans ĊĊ ĠĠĠ Ġ# print (S )ĊĊ ĠĠĠ Ġ# print (l )ĊĊ ĠĠĠ Ġ# print (len _l )ĊĊ ĠĠĠ Ġreturn Ġres ĊĊĊĊ print (( S olve ()))


Input:
def check(x, y):

    for a, b in zip(x, y):

        if a != b and b != -1:

            return False

    else:

        return True

n = int(input())

remarks = []

cnt_max = 0

for _ in range(n):

    a = int(input())

    x = [tuple(map(int, input().split())) for i in range(a)]

    r = [-1] * n

    for i, j in x:

        r[i - 1] = j

    remarks.append(r)

for r in range(2 ** n):

    r = list(bin(r)[2:].zfill(n))

    r = [int(i) for i in r[:]]

    cnt = 0

    for i in range(n):

        if r[i] == 1:

            flag = check(r, remarks[i])

            cnt += 1

            if not flag:

                cnt = 0

                break

    cnt_max = max(cnt, cnt_max)

print(cnt_max)

def Ġcheck (x , Ġy ):ĊĊ ĠĠĠ Ġfor Ġa , Ġb Ġin Ġzip (x , Ġy ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġa Ġ!= Ġb Ġand Ġb Ġ!= Ġ- 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠFalse ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġreturn ĠTrue ĊĊĊĊĊĊ n Ġ= Ġint (input ())ĊĊ remarks Ġ= Ġ[]ĊĊ cnt _max Ġ= Ġ 0 ĊĊ for Ġ_ Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġa Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġx Ġ= Ġ[ tuple (map (int , Ġinput (). split ())) Ġfor Ġi Ġin Ġrange (a )]ĊĊ ĠĠĠ Ġr Ġ= Ġ[- 1 ] Ġ* Ġn ĊĊ ĠĠĠ Ġfor Ġi , Ġj Ġin Ġx :ĊĊ ĠĠĠĠĠĠĠ Ġr [i Ġ- Ġ 1 ] Ġ= Ġj ĊĊ ĠĠĠ Ġremarks .append (r )ĊĊ for Ġr Ġin Ġrange ( 2 Ġ** Ġn ):ĊĊ ĠĠĠ Ġr Ġ= Ġlist (bin (r )[ 2 :]. z fill (n ))ĊĊ ĠĠĠ Ġr Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġr [: ]]ĊĊ ĠĠĠ Ġcnt Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġr [i ] Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġflag Ġ= Ġcheck (r , Ġremarks [i ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġnot Ġflag :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġcnt _max Ġ= Ġmax (cnt , Ġcnt _max )ĊĊ print (cnt _max )


Input:
A, B = list(map(int, input().split()))

count_target = 0

for i in range(A, B + 1):

    str_i = str(i)

    reversed_i = ''

    for n_th_i in reversed(list(range(len(str_i)))):

        reversed_i += str_i[n_th_i]

    if str_i == reversed_i:

        count_target += 1

print(count_target)

A , ĠB Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ count _target Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (A , ĠB Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġstr _i Ġ= Ġstr (i )ĊĊ ĠĠĠ Ġreversed _i Ġ= Ġ''ĊĊ ĠĠĠ Ġfor Ġn _th _i Ġin Ġreversed (list (range (len (str _i )))) :ĊĊ ĠĠĠĠĠĠĠ Ġreversed _i Ġ+= Ġstr _i [n _th _i ]ĊĊĊĊ ĠĠĠ Ġif Ġstr _i Ġ== Ġreversed _i :ĊĊ ĠĠĠĠĠĠĠ Ġcount _target Ġ+= Ġ 1 ĊĊĊĊ print (count _target )


Input:
from collections import Counter,defaultdict,deque

import sys,bisect,math,itertools,string,queue

from heapq import heappop, heappush

sys.setrecursionlimit(10**8)

mod = 10**9+7

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

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

def inpl_str(): return list(sys.stdin.readline().split())

def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

n = inp()

res = float('inf')

for i in range(1,2*10**6):

    if (n/i).is_integer():

        res = min(res, i + n/i)

print((int(res-2)))

from Ġcollections Ġimport ĠCounter ,default dict , deque ĊĊ import Ġsys ,b is ect , math ,it ertools ,string , queue ĊĊ from Ġheapq Ġimport Ġhe app op , Ġhe app ush ĊĊ sys .set rec ursion limit ( 1 0 ** 8 )ĊĊ mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊ def Ġinp (): Ġreturn Ġint (sys .stdin .readline ())ĊĊ def Ġin pl (): Ġreturn Ġlist (map (int , Ġsys .stdin .readline (). split ()))ĊĊ def Ġin pl _str (): Ġreturn Ġlist (sys .stdin .readline (). split ())ĊĊ def Ġin pl n (n ): Ġreturn Ġlist (int (sys .stdin .readline ()) Ġfor Ġi Ġin Ġrange (n )) ĊĊĊĊ n Ġ= Ġinp ()ĊĊ res Ġ= Ġfloat (' inf ')ĊĊ for Ġi Ġin Ġrange ( 1 , 2 * 1 0 ** 6 ):ĊĊ ĠĠĠ Ġif Ġ( n /i ). is _integer ():ĊĊ ĠĠĠĠĠĠĠ Ġres Ġ= Ġmin (res , Ġi Ġ+ Ġn /i )ĊĊ print (( int (res - 2 )))Ċ


Input:
S = int(input())

dp = [0] * (S + 1)

dp[0] = 1

M = 10 ** 9 + 7

for i in range(1, S + 1):

    num = 0

    for j in range(i - 2):

        num += dp[j]

        dp[i] = num % M

print((dp[S]))

S Ġ= Ġint (input ())ĊĊ ĊĊ dp Ġ= Ġ[ 0 ] Ġ* Ġ( S Ġ+ Ġ 1 )ĊĊ dp [ 0 ] Ġ= Ġ 1 ĊĊ M Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĊĊĊĊ for Ġi Ġin Ġrange ( 1 , ĠS Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġnum Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (i Ġ- Ġ 2 ):ĊĊ ĠĠĠĠĠĠĠ Ġnum Ġ+= Ġdp [j ]ĊĊ ĠĠĠĠĠĠĠ Ġdp [i ] Ġ= Ġnum Ġ% ĠM ĊĊĊĊ print (( dp [S ])) ĊĊĊ


Input:
import random, math

random.seed()

def gen(a, b, num):

    result = set()

    while 1:

        while 1:

            v = random.randint(a, b)//2*2+1

            if v not in result:

                break

        for x in range(3, int(math.sqrt(v))+1, 2):

            if v % x == 0:

                break

        else:

            result.add(v)

            if len(result) == num:

                break

    return result

class RH():

    def __init__(self, s, base, mod):

        self.base = base

        self.mod = mod

        self.rev = pow(base, mod-2, mod)

        l = len(s)

        self.h = h = [0]*(l+1)

        tmp = 0

        for i in range(l):

            num = ord(s[i])

            tmp = (tmp*base + num) % mod

            h[i+1] = tmp

    def calc(self, l, r):

        return (self.h[r] - self.h[l] * pow(self.base, r-l, self.mod)) % self.mod

    def fixed(self, length):

        v = pow(self.base, length, self.mod)

        h = self.h; mod = self.mod

        def fixed_calc(l):

            return (h[length+l] - h[l] * v) % mod

        return fixed_calc

class RRH():

    def __init__(self, s, num=10, primes=None):

        primes = primes or gen(2, 10**3, num)

        MOD = 10**9+7

        self.rhs = [RH(s, p, MOD) for p in primes]

    def calc(self, l, r):

        return [rh.calc(l, r) for rh in self.rhs]

    def fixed(self, length):

        fs = [rh.fixed(length) for rh in self.rhs]

        def multi_fixed_calc(l):

            return list(f(l) for f in fs)

        return multi_fixed_calc

T = input(); P = input()

primes = gen(2, 10**3, 2)

HT = RRH(T, primes=primes)

HP = RRH(P, primes=primes)

pv = HP.calc(0, len(P))

calc = HT.fixed(len(P))

for i in range(len(T)-len(P)+1):

    if calc(i) == pv:

        print(i)

import Ġrandom , Ġmath ĊĊ random .seed ()ĊĊ def Ġgen (a , Ġb , Ġnum ):ĊĊ ĠĠĠ Ġresult Ġ= Ġset ()ĊĊ ĠĠĠ Ġwhile Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġv Ġ= Ġrandom .randint (a , Ġb )// 2 * 2 + 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġv Ġnot Ġin Ġresult :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx Ġin Ġrange ( 3 , Ġint (math .sqrt (v ))+ 1 , Ġ 2 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġv Ġ% Ġx Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġresult .add (v )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġlen (result ) Ġ== Ġnum :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġreturn Ġresult ĊĊ class ĠRH ():ĊĊ ĠĠĠ Ġdef Ġ__ init __( self , Ġs , Ġbase , Ġmod ):ĊĊ ĠĠĠĠĠĠĠ Ġself .base Ġ= Ġbase ĊĊ ĠĠĠĠĠĠĠ Ġself .mod Ġ= Ġmod ĊĊ ĠĠĠĠĠĠĠ Ġself .rev Ġ= Ġpow (base , Ġmod - 2 , Ġmod )ĊĊĊĊ ĠĠĠĠĠĠĠ Ġl Ġ= Ġlen (s )ĊĊ ĠĠĠĠĠĠĠ Ġself .h Ġ= Ġh Ġ= Ġ[ 0 ]*( l + 1 )ĊĊ ĠĠĠĠĠĠĠ Ġtmp Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (l ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġnum Ġ= Ġord (s [i ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġtmp Ġ= Ġ( tmp * base Ġ+ Ġnum ) Ġ% Ġmod ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġh [i + 1 ] Ġ= Ġtmp ĊĊ ĠĠĠ Ġdef Ġcalc (self , Ġl , Ġr ):ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ( self .h [r ] Ġ- Ġself .h [l ] Ġ* Ġpow (self .base , Ġr -l , Ġself .mod )) Ġ% Ġself .mod ĊĊ ĠĠĠ Ġdef Ġfixed (self , Ġlength ):ĊĊ ĠĠĠĠĠĠĠ Ġv Ġ= Ġpow (self .base , Ġlength , Ġself .mod )ĊĊ ĠĠĠĠĠĠĠ Ġh Ġ= Ġself .h ; Ġmod Ġ= Ġself .mod ĊĊ ĠĠĠĠĠĠĠ Ġdef Ġfixed _calc (l ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġ( h [length +l ] Ġ- Ġh [l ] Ġ* Ġv ) Ġ% Ġmod ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġfixed _calc ĊĊ class ĠRR H ():ĊĊ ĠĠĠ Ġdef Ġ__ init __( self , Ġs , Ġnum = 1 0 , Ġprimes =None ):ĊĊ ĠĠĠĠĠĠĠ Ġprimes Ġ= Ġprimes Ġor Ġgen ( 2 , Ġ 1 0 ** 3 , Ġnum )ĊĊ ĠĠĠĠĠĠĠ ĠMOD Ġ= Ġ 1 0 ** 9 + 7 ĊĊ ĠĠĠĠĠĠĠ Ġself .r hs Ġ= Ġ[ RH (s , Ġp , ĠMOD ) Ġfor Ġp Ġin Ġprimes ]ĊĊ ĠĠĠ Ġdef Ġcalc (self , Ġl , Ġr ):ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ[ rh .calc (l , Ġr ) Ġfor Ġrh Ġin Ġself .r hs ]ĊĊ ĠĠĠ Ġdef Ġfixed (self , Ġlength ):ĊĊ ĠĠĠĠĠĠĠ Ġfs Ġ= Ġ[ rh .fixed (length ) Ġfor Ġrh Ġin Ġself .r hs ]ĊĊ ĠĠĠĠĠĠĠ Ġdef Ġmulti _fixed _calc (l ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġlist (f (l ) Ġfor Ġf Ġin Ġfs )ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġmulti _fixed _calc ĊĊĊĊ T Ġ= Ġinput (); ĠP Ġ= Ġinput ()ĊĊ pr imes Ġ= Ġgen ( 2 , Ġ 1 0 ** 3 , Ġ 2 )ĊĊ HT Ġ= ĠRR H (T , Ġprimes = pr imes )ĊĊ HP Ġ= ĠRR H (P , Ġprimes = pr imes )ĊĊĊĊ pv Ġ= ĠHP .calc ( 0 , Ġlen (P ))ĊĊ calc Ġ= ĠHT .fixed (len (P ))ĊĊ for Ġi Ġin Ġrange (len (T )- len (P )+ 1 ):ĊĊ ĠĠĠ Ġif Ġcalc (i ) Ġ== Ġpv :ĊĊ ĠĠĠĠĠĠĠ Ġprint (i )


Input:
a = int(input())

h = int(a / 3600)

m = int((a - h * 3600) / 60)

s = int(a - h * 3600 - m * 60)

print((":" .join(map(str, [h, m, s]))))

a Ġ= Ġint (input ())ĊĊ h Ġ= Ġint (a Ġ/ Ġ 3 6 0 0 )ĊĊ m Ġ= Ġint (( a Ġ- Ġh Ġ* Ġ 3 6 0 0 ) Ġ/ Ġ 6 0 )ĊĊ s Ġ= Ġint (a Ġ- Ġh Ġ* Ġ 3 6 0 0 Ġ- Ġm Ġ* Ġ 6 0 )ĊĊ print ((" :" Ġ. join (map (str , Ġ[ h , Ġm , Ġs ])) ))


Input:
n = int(input())

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

ans = list(range(n))

for i in range(n):

    ans[a[i]-1] = i+1

print((' '.join(map(str,ans))))

n Ġ= Ġint (input ())ĊĊ a Ġ= Ġ[ int (x ) Ġfor Ġx Ġin Ġinput (). split ()] ĊĊĊĊ ans Ġ= Ġlist (range (n )) ĊĊĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġans [a [i ]- 1 ] Ġ= Ġi + 1 ĊĊ ĠĠĠĠĊĊ print ((' Ġ'. join (map (str , ans ))))


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

cnt = 0

for x in range(a, b + 1):

    s = str(x)

    l = len(s)

    flg = True

    for i in range(l // 2):

        if s[i] != s[l - 1 - i]:

            flg = False

            break

    if flg:

        cnt += 1

print(cnt)

a , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġx Ġin Ġrange (a , Ġb Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġs Ġ= Ġstr (x )ĊĊ ĠĠĠ Ġl Ġ= Ġlen (s )ĊĊ ĠĠĠ Ġfl g Ġ= ĠTrue ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (l Ġ// Ġ 2 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [i ] Ġ!= Ġs [l Ġ- Ġ 1 Ġ- Ġi ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfl g Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġif Ġfl g :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ print (cnt )Ċ


Input:
N = int(input())

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

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

a.reverse()

b.reverse()

ans = 0

capacity = 0

for i in range(N):

    ans += min(b[i] + capacity, a[i])

    capacity = max(b[i] - max(a[i] - capacity, 0), 0)

ans += min(a[-1], capacity)

print(ans)

N Ġ= Ġint (input ())ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ b Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a .reverse ()ĊĊ b .reverse ()ĊĊ ans Ġ= Ġ 0 ĊĊ capacity Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġans Ġ+= Ġmin (b [i ] Ġ+ Ġcapacity , Ġa [i ])ĊĊ ĠĠĠ Ġcapacity Ġ= Ġmax (b [i ] Ġ- Ġmax (a [i ] Ġ- Ġcapacity , Ġ 0 ), Ġ 0 )ĊĊ ans Ġ+= Ġmin (a [- 1 ], Ġcapacity )ĊĊ print (ans )


Input:
#coding:utf-8

import bisect

import sys

sys.setrecursionlimit(10**6)

write = sys.stdout.write

dbg = lambda *something : print(*something) if DEBUG else 0

DEBUG = True

def main(given = sys.stdin.readline):

    input = lambda : given().rstrip()

    LMIIS = lambda : list(map(int,input().split()))

    II = lambda : int(input())

    XLMIIS = lambda x : [LMIIS() for _ in range(x)]

    n, t = LMIIS()

    ab = XLMIIS(n)

    dp1 = [[0]*t for _ in range(n)]

    for i in range(1, n):

        for j in range(1, t):

            if j < ab[i-1][0]:

                dp1[i][j] = dp1[i-1][j]

            else:

                dp1[i][j] = max(dp1[i-1][j], dp1[i-1][j-ab[i-1][0]] + ab[i-1][1])

    dp2 = [[0]*t for _ in range(n)]

    for i in range(1, n):

        for j in range(1, t):

            if j < ab[n - i][0]:

                dp2[i][j] = dp2[i-1][j]

            else:

                dp2[i][j] = max(dp2[i-1][j], dp2[i-1][j-ab[n-i][0]] + ab[n-i][1])

    ans = 0

    for i in range(n):

        for j in range(t - 1):

            ans = max(ans, dp1[i][j] + dp2[n - i - 1][t - j - 1] + ab[i][1])

    print(ans)

if __name__ == '__main__':

    main()

# coding :utf - 8 ĊĊ import Ġbis ect ĊĊ import Ġsys ĊĊ sys .set rec ursion limit ( 1 0 ** 6 )ĊĊ write Ġ= Ġsys .stdout .write ĊĊ dbg Ġ= Ġlambda Ġ* something Ġ: Ġprint (* something ) Ġif ĠDEBUG Ġelse Ġ 0 ĊĊ DEBUG Ġ= ĠTrue ĊĊĊĊĊĊĊĊ def Ġmain (g iven Ġ= Ġsys .stdin .readline ):ĊĊ ĠĠĠ Ġinput Ġ= Ġlambda Ġ: Ġgiven (). rstrip ()ĊĊ ĠĠĠ ĠL MI IS Ġ= Ġlambda Ġ: Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ ĠII Ġ= Ġlambda Ġ: Ġint (input ())ĊĊ ĠĠĠ ĠXL MI IS Ġ= Ġlambda Ġx Ġ: Ġ[ L MI IS () Ġfor Ġ_ Ġin Ġrange (x )] ĊĊĊĊ ĠĠĠ Ġn , Ġt Ġ= ĠL MI IS ()ĊĊ ĠĠĠ Ġab Ġ= ĠXL MI IS (n )ĊĊĊĊ ĠĠĠ Ġdp 1 Ġ= Ġ[[ 0 ]* t Ġfor Ġ_ Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġn ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 , Ġt ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġj Ġ< Ġab [i - 1 ][ 0 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp 1 [i ][ j ] Ġ= Ġdp 1 [i - 1 ][ j ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp 1 [i ][ j ] Ġ= Ġmax (dp 1 [i - 1 ][ j ], Ġdp 1 [i - 1 ][ j -ab [i - 1 ][ 0 ]] Ġ+ Ġab [i - 1 ][ 1 ])ĊĊ ĊĊĊĊ ĠĠĠ Ġdp 2 Ġ= Ġ[[ 0 ]* t Ġfor Ġ_ Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġn ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 , Ġt ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġj Ġ< Ġab [n Ġ- Ġi ][ 0 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp 2 [i ][ j ] Ġ= Ġdp 2 [i - 1 ][ j ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp 2 [i ][ j ] Ġ= Ġmax (dp 2 [i - 1 ][ j ], Ġdp 2 [i - 1 ][ j -ab [n -i ][ 0 ]] Ġ+ Ġab [n -i ][ 1 ])ĊĊ ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (t Ġ- Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġmax (ans , Ġdp 1 [i ][ j ] Ġ+ Ġdp 2 [n Ġ- Ġi Ġ- Ġ 1 ][ t Ġ- Ġj Ġ- Ġ 1 ] Ġ+ Ġab [i ][ 1 ])ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
import sys

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

S = input()

def nexti(n):

    while S[n] == '1':

        n += 1

    while S[n] == '0':

        n += 1

    return n

def nextj(n):

    while S[n] == '0':

        n += 1

        if n == N:

            return N

    while S[n] == '1':

        n += 1

        if n == N:

            return N

    return n

i = 0

j = 0

while S[j] == '1':

    j += 1

    if j == N:

        print(N)

        sys.exit(0)

for _ in range(K):

    j = nextj(j)

    if j == N:

        print(N)

        sys.exit(0)

ans = j - i

while True:

    i = nexti(i)

    j = nextj(j)

    ans = max(ans, j - i)

    if j == N:

        break

print(ans)

import Ġsys ĊĊĊĊ N , ĠK Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ S Ġ= Ġinput () ĊĊĊĊĊĊ def Ġnext i (n ):ĊĊ ĠĠĠ Ġwhile ĠS [n ] Ġ== Ġ' 1 ':ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġwhile ĠS [n ] Ġ== Ġ' 0 ':ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġreturn Ġn ĊĊĊĊĊĊ def Ġnext j (n ):ĊĊ ĠĠĠ Ġwhile ĠS [n ] Ġ== Ġ' 0 ':ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ== ĠN :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠN ĊĊ ĠĠĠ Ġwhile ĠS [n ] Ġ== Ġ' 1 ':ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ== ĠN :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠN ĊĊ ĠĠĠ Ġreturn Ġn ĊĊĊĊĊĊ i Ġ= Ġ 0 ĊĊ j Ġ= Ġ 0 ĊĊ while ĠS [j ] Ġ== Ġ' 1 ':ĊĊ ĠĠĠ Ġj Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġj Ġ== ĠN :ĊĊ ĠĠĠĠĠĠĠ Ġprint (N )ĊĊ ĠĠĠĠĠĠĠ Ġsys .exit ( 0 )ĊĊ for Ġ_ Ġin Ġrange (K ):ĊĊ ĠĠĠ Ġj Ġ= Ġnext j (j )ĊĊ ĠĠĠ Ġif Ġj Ġ== ĠN :ĊĊ ĠĠĠĠĠĠĠ Ġprint (N )ĊĊ ĠĠĠĠĠĠĠ Ġsys .exit ( 0 )ĊĊĊĊ ans Ġ= Ġj Ġ- Ġi ĊĊ while ĠTrue :ĊĊ ĠĠĠ Ġi Ġ= Ġnext i (i )ĊĊ ĠĠĠ Ġj Ġ= Ġnext j (j )ĊĊ ĠĠĠ Ġans Ġ= Ġmax (ans , Ġj Ġ- Ġi )ĊĊ ĠĠĠ Ġif Ġj Ġ== ĠN :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ print (ans )


Input:
N, L = list(map(int, input().split()))

S = list(input() for i in range(N))

str = ""

for i in range(N-1):

    for j in range(N-1):

        if S[j+1] + S[j] <= S[j] + S[j+1]:

            S[j], S[j+1] = S[j+1], S[j]

for i in S:

    str += i

print(str)

N , ĠL Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ S Ġ= Ġlist (input () Ġfor Ġi Ġin Ġrange (N ))ĊĊ str Ġ= Ġ""ĊĊ for Ġi Ġin Ġrange (N - 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (N - 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif ĠS [j + 1 ] Ġ+ ĠS [j ] Ġ<= ĠS [j ] Ġ+ ĠS [j + 1 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠS [j ], ĠS [j + 1 ] Ġ= ĠS [j + 1 ], ĠS [j ]ĊĊ for Ġi Ġin ĠS :ĊĊ ĠĠĠ Ġstr Ġ+= Ġi ĊĊ print (str )Ċ


Input:
while True:

	k=list(map(int,input().split(" ")))

	if k[0]==k[1]==0:

		break

	ct=0

	a=0

	b=0

	c=0

	max=k[0]

	sum=k[1]

	a=max+1

	while True:

		a-=1

		b=a-1

		c=sum-a-b

		if not a>b>c:

			print(ct)

			break

		while a>b>c:

			if a>b>c>0:

				ct+=1

			b-=1

			c+=1

while ĠTrue :ĊĊ ĉk =list (map (int ,input (). split (" Ġ" )))ĊĊ ĉif Ġk [ 0 ]== k [ 1 ]== 0 :ĊĊ ĉ ĉbreak ĊĊ ĉct = 0 ĊĊ ĉa = 0 ĊĊ ĉb = 0 ĊĊ ĉc = 0 ĉĊĊ ĉmax =k [ 0 ]ĊĊ ĉsum =k [ 1 ]ĊĊ ĉa =max + 1 ĊĊ ĉĊĊ ĉwhile ĠTrue :ĊĊ ĉ ĉa -= 1 ĊĊ ĉ ĉb =a - 1 ĊĊ ĉ ĉc =sum -a -b ĊĊ ĉ ĉif Ġnot Ġa >b >c :ĊĊ ĉĉ ĉprint (ct )ĊĊ ĉĉ ĉbreak ĊĊ ĉ ĉwhile Ġa >b >c :ĊĊ ĉĉ ĉif Ġa >b >c > 0 :ĊĊ ĉĉĉ ĉct += 1 ĊĊ ĉĉ ĉb -= 1 ĊĊ ĉĉ ĉc += 1 ĊĊ ĉĉĉ


Input:
n, l = list(map(int, input().split()))

S = [input() for i in range(n)]

S.sort()

print(("".join(S)))

n , Ġl Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ S Ġ= Ġ[ input () Ġfor Ġi Ġin Ġrange (n )]ĊĊ S .sort ()ĊĊ print ((" ". join (S )))


Input:
N = int(input())

if N < 2:

  print(N)

elif 2<=N<4:

  print((2))

elif 4<=N<8:

  print((4))

elif 8<=N<16:

  print((8))

elif 16<=N<32:

  print((16))

elif 32<=N<64:

  print((32))

elif 64<=N:

  print((64))

N Ġ= Ġint (input ())ĊĊ if ĠN Ġ< Ġ 2 :ĊĊ Ġ Ġprint (N )ĊĊ elif Ġ 2 <= N < 4 :ĊĊ Ġ Ġprint (( 2 ))ĊĊ elif Ġ 4 <= N < 8 :ĊĊ Ġ Ġprint (( 4 ))ĊĊ elif Ġ 8 <= N < 1 6 :ĊĊ Ġ Ġprint (( 8 ))ĊĊ elif Ġ 1 6 <= N < 3 2 :ĊĊ Ġ Ġprint (( 1 6 ))ĊĊ elif Ġ 3 2 <= N < 6 4 :ĊĊ Ġ Ġprint (( 3 2 ))ĊĊ elif Ġ 6 4 <= N :ĊĊ Ġ Ġprint (( 6 4 ))


Input:
N, M = list(map(int, input().split()))

LR = [list(map(int, input().split())) for _ in range(M)]

left = 1

right = N

for l, r in LR:

    if left < l:

        left = l

    if right > r:

        right = r

ans = right - left

print((ans + 1 if ans >= 0 else 0))

N , ĠM Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ LR Ġ= Ġ[ list (map (int , Ġinput (). split ())) Ġfor Ġ_ Ġin Ġrange (M )] ĊĊĊĊ left Ġ= Ġ 1 ĊĊ right Ġ= ĠN ĊĊĊĊ for Ġl , Ġr Ġin ĠLR :ĊĊ ĠĠĠ Ġif Ġleft Ġ< Ġl :ĊĊ ĠĠĠĠĠĠĠ Ġleft Ġ= Ġl ĊĊ ĠĠĠ Ġif Ġright Ġ> Ġr :ĊĊ ĠĠĠĠĠĠĠ Ġright Ġ= Ġr ĊĊĊĊ ans Ġ= Ġright Ġ- Ġleft ĊĊĊĊ print (( ans Ġ+ Ġ 1 Ġif Ġans Ġ>= Ġ 0 Ġelse Ġ 0 ))Ċ


Input:
s = input()

t = input()

for i in range(len(s)):

        if s[i:]+s[:i]==t:

                print('Yes')

                exit()

print('No')

s Ġ= Ġinput ()ĊĊ t Ġ= Ġinput ()ĊĊ for Ġi Ġin Ġrange (len (s )) :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [i : ]+ s [: i ]== t :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġprint (' Yes ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġexit ()ĊĊ print (' No ')


Input:
n = int(input())

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

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

result = 0

for i in range(n):

  if v[i] > c[i]:

    result += v[i] - c[i]

print(result)

n Ġ= Ġint (input ())ĊĊ v Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ c Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ result Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ Ġ Ġif Ġv [i ] Ġ> Ġc [i ]:ĊĊ ĠĠĠ Ġresult Ġ+= Ġv [i ] Ġ- Ġc [i ]ĊĊ print (result )


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

answer = 0

for i in range(a,b+1) :

    j = str(i)

    p1 = j[4]

    p2 = j[3]

    p3 = j[2]

    p4 = j[1]

    p5 = j[0]

    k = int(p1+p2+p3+p4+p5)

    if i == k :

        answer += 1

print(answer)

a ,b Ġ= Ġlist (map (int ,input (). split ()))ĊĊ answer Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (a ,b + 1 ) Ġ:ĊĊ ĠĠĠ Ġj Ġ= Ġstr (i )ĊĊ ĠĠĠ Ġp 1 Ġ= Ġj [ 4 ]ĊĊ ĠĠĠ Ġp 2 Ġ= Ġj [ 3 ]ĊĊ ĠĠĠ Ġp 3 Ġ= Ġj [ 2 ]ĊĊ ĠĠĠ Ġp 4 Ġ= Ġj [ 1 ]ĊĊ ĠĠĠ Ġp 5 Ġ= Ġj [ 0 ]ĊĊ ĠĠĠ Ġk Ġ= Ġint (p 1 +p 2 +p 3 +p 4 +p 5 )ĊĊ ĠĠĠ Ġif Ġi Ġ== Ġk Ġ:ĊĊ ĠĠĠĠĠĠĠ Ġanswer Ġ+= Ġ 1 ĊĊ print (answer )ĊĊĊ


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

dic={}

for i in range(N):

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

  if a in dic:

    dic[a]+=b

  else:

    dic[a]=b

dic=sorted(list(dic.items()),key=lambda x:x[0])

for d in range(len(dic)):

  amount=dic[d][1]

  if amount>=K:

    print((dic[d][0]))

    exit(0)

  else:

    K-=amount

N ,K =list (map (int ,input (). split ()))ĊĊ dic ={ }ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ Ġ Ġa ,b =list (map (int ,input (). split ()))ĊĊ Ġ Ġif Ġa Ġin Ġdic :ĊĊ ĠĠĠ Ġdic [a ]+= b ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ Ġdic [a ]= b ĊĊ ĠĠĠĠĊĊ dic = sorted (list (dic .items ()), key =lambda Ġx :x [ 0 ])ĊĊ for Ġd Ġin Ġrange (len (dic )) :ĊĊ Ġ Ġamount =d ic [d ][ 1 ]ĊĊ Ġ Ġif Ġamount >= K :ĊĊ ĠĠĠ Ġprint (( dic [d ][ 0 ]))ĊĊ ĠĠĠ Ġexit ( 0 )ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ ĠK -= amount ĊĊ ĠĠ


Input:
# Problem https://atcoder.jp/contests/abc053/tasks/abc053_b

# Python 1st Try

import copy

class Problem:

    def __init__(self, stringdata):

        self.stringdata = stringdata

    def solver(self):

        strcont = copy.copy(self.stringdata)

        result = 0

        rightposition = 0

        leftposition = len(strcont)

        j = 0

        while True:

            if strcont[j] == 'A':

                rightposition = j

                break

            else:

                j = j + 1

        j = leftposition - 1

        while True:

            if strcont[j] == 'Z':

                leftposition = j

                break

            else:

                j = j - 1

        result = leftposition - rightposition + 1

        return result

if __name__ == "__main__":

    s = input()

    print(("{}".format(Problem(s).solver())))

# ĠProblem Ġhttps :// at coder .jp / cont ests / abc 0 5 3 /tasks / abc 0 5 3 _b ĊĊ # ĠPython Ġ 1 st ĠTry ĊĊ import Ġcopy ĊĊĊĊĊĊ class ĠProblem :ĊĊ ĠĠĠ Ġdef Ġ__ init __( self , Ġstring data ):ĊĊ ĠĠĠĠĠĠĠ Ġself .string data Ġ= Ġstring data ĊĊĊĊ ĠĠĠ Ġdef Ġsolver (self ):ĊĊ ĠĠĠĠĠĠĠ Ġstr cont Ġ= Ġcopy .copy (self .string data )ĊĊ ĠĠĠĠĠĠĠ Ġresult Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġright position Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġleft position Ġ= Ġlen (str cont )ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġstr cont [j ] Ġ== Ġ' A ':ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġright position Ġ= Ġj ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġj Ġ= Ġj Ġ+ Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= Ġleft position Ġ- Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġstr cont [j ] Ġ== Ġ' Z ':ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġleft position Ġ= Ġj ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġj Ġ= Ġj Ġ- Ġ 1 ĊĊĊĊ ĠĠĠĠĠĠĠ Ġresult Ġ= Ġleft position Ġ- Ġright position Ġ+ Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġresult ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġs Ġ= Ġinput ()ĊĊ ĠĠĠ Ġprint ((" {}". format ( Problem (s ). solver ())))Ċ


Input:
from itertools import accumulate

from bisect import *

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

L = list(tuple(map(int, input().split())))

acc = sorted(list(accumulate(L)) + [0])

n = bisect_right(acc,X)

print(n)

from Ġitertools Ġimport Ġaccumulate ĊĊ from Ġbis ect Ġimport Ġ*ĊĊ N , ĠX Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ L Ġ= Ġlist (tuple (map (int , Ġinput (). split ())) )ĊĊĊĊ acc Ġ= Ġsorted (list ( accumulate (L )) Ġ+ Ġ[ 0 ])ĊĊ ĊĊ n Ġ= Ġbis ect _right (acc ,X )ĊĊ print (n )ĊĊĊ


Input:
A, B = list(map(int, input().split()))

cnt = 0

for n in range(A, B+1):

    n_s = str(n)

    n_s_rvs = n_s[::-1]

    if n_s == n_s_rvs:

        cnt += 1

print(cnt)

A , ĠB Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġn Ġin Ġrange (A , ĠB + 1 ):ĊĊ ĠĠĠ Ġn _s Ġ= Ġstr (n )ĊĊ ĠĠĠ Ġn _s _r vs Ġ= Ġn _s [::- 1 ]ĊĊ ĠĠĠ Ġif Ġn _s Ġ== Ġn _s _r vs :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊĊĊ print (cnt )Ċ


Input:
import math

N=int(input())

print((math.factorial(N)%(10**9+7)))

import Ġmath ĊĊ N =int (input ())ĊĊ print (( math .factor ial (N ) %( 1 0 ** 9 + 7 )))


Input:
# ABC95 C -Half and Half

a,b,c,x,y = list(map(float,input().split()))

ans = 0

if a+b > 2*c:

    while x != 0.0 and y != 0.0:

        ans += 2*c

        x -= 1.0

        y -= 1.0

        if y == 0.0:

            while x != 0.0:

                if a > 2*c:

                    ans += 2*c

                    x -= 1.0

                else:

                    ans += a

                    x -= 1.0

        if x == 0.0:

            while y != 0.0:

                if b > 2*c:

                    ans += 2*c

                    y -= 1.0

                else:

                    ans += b

                    y -= 1.0

else:

    ans += a*x + b*y

print((int(ans)))

# ĠABC 9 5 ĠC Ġ- Half Ġand ĠHalf ĊĊ a ,b ,c ,x ,y Ġ= Ġlist (map (float ,input (). split ()))ĊĊ ans Ġ= Ġ 0 ĊĊ if Ġa +b Ġ> Ġ 2 *c :ĊĊ ĠĠĠ Ġwhile Ġx Ġ!= Ġ 0 . 0 Ġand Ġy Ġ!= Ġ 0 . 0 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 2 *c ĊĊ ĠĠĠĠĠĠĠ Ġx Ġ-= Ġ 1 . 0 ĊĊ ĠĠĠĠĠĠĠ Ġy Ġ-= Ġ 1 . 0 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġy Ġ== Ġ 0 . 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġwhile Ġx Ġ!= Ġ 0 . 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġa Ġ> Ġ 2 *c :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 2 *c ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx Ġ-= Ġ 1 . 0 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġa ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġx Ġ-= Ġ 1 . 0 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġx Ġ== Ġ 0 . 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġwhile Ġy Ġ!= Ġ 0 . 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġb Ġ> Ġ 2 *c :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 2 *c ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġy Ġ-= Ġ 1 . 0 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġb ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġy Ġ-= Ġ 1 . 0 ĊĊ else :ĊĊ ĠĠĠ Ġans Ġ+= Ġa *x Ġ+ Ġb *y ĊĊ print (( int (ans )) )ĊĊĊĊ ĠĠĠĠ


Input:
N, D = list(map(int, input().split()))

cnt = 0

for _ in range(N):

    x, y = list(map(int, input().split()))

    if x ** 2 + y ** 2 <= D ** 2:

        cnt += 1

print(cnt)

N , ĠD Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġ_ Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġif Ġx Ġ** Ġ 2 Ġ+ Ġy Ġ** Ġ 2 Ġ<= ĠD Ġ** Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĊĊ print (cnt )


Input:
from math import gcd

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

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

a=list(set(a))

a=list([x//2 for x in a])

def lcm(q):

  x = q[0]

  for i in range(1, len(q)):

    x = (x * q[i]) // gcd(x, q[i])

  return x

lcma=lcm(a)

if (lcma//a[0])%2==0:

  print((0))

else:

  flg=0

  for i in range(1,len(a)):

    if (lcma//a[i])%2==0:

      print((0))

      flg=1

      break

  if flg==0:

    temp=m//lcma

    print((temp//2 if temp%2==0 else temp//2+1))

from Ġmath Ġimport Ġgcd ĊĊĊĊ n ,m =list (map (int ,input (). split ()))ĊĊ a =list (map (int ,input (). split ()))ĊĊ a =list (set (a )) ĊĊĊĊ a =list ([ x // 2 Ġfor Ġx Ġin Ġa ])ĊĊ ĊĊ def Ġlcm (q ):ĊĊ Ġ Ġx Ġ= Ġq [ 0 ]ĊĊ Ġ Ġfor Ġi Ġin Ġrange ( 1 , Ġlen (q )) :ĊĊ ĠĠĠ Ġx Ġ= Ġ( x Ġ* Ġq [i ]) Ġ// Ġgcd (x , Ġq [i ])ĊĊ Ġ Ġreturn Ġx ĊĊĊĊ lc ma =l cm (a )ĊĊĊĊ if Ġ( lc ma // a [ 0 ]) % 2 == 0 :ĊĊ Ġ Ġprint (( 0 ))ĊĊ else :ĊĊ Ġ Ġfl g = 0 ĊĊ Ġ Ġfor Ġi Ġin Ġrange ( 1 ,len (a )) :ĊĊ ĠĠĠ Ġif Ġ( lc ma // a [i ]) % 2 == 0 :ĊĊ ĠĠĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠĠĠ Ġfl g = 1 ĊĊ ĠĠĠĠĠ Ġbreak ĊĊ Ġ Ġif Ġfl g == 0 :ĊĊ ĠĠĠ Ġtemp =m // lc ma ĊĊ ĠĠĠ Ġprint (( temp // 2 Ġif Ġtemp % 2 == 0 Ġelse Ġtemp // 2 + 1 ))


Input:
S = int(input())

a = 0

count = 0

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

while count == 0:

    a += S

    if n <= a and m >= a:

        count = 1

    if a >= 1000:

        break

if count == 0:

    print("NG")

else:

    print("OK")

S Ġ= Ġint (input ())ĊĊ a Ġ= Ġ 0 ĊĊ count Ġ= Ġ 0 ĊĊ n ,m Ġ= Ġlist (map (int ,input (). split ()))ĊĊ while Ġcount Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġa Ġ+= ĠS ĊĊ ĠĠĠ Ġif Ġn Ġ<= Ġa Ġand Ġm Ġ>= Ġa :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ= Ġ 1 ĊĊ ĠĠĠ Ġif Ġa Ġ>= Ġ 1 0 0 0 :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ if Ġcount Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġprint (" NG ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" OK ")


Input:
N = int(input())

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

n = N % 2

DP = [[0] * (N+1) for _ in range(N+1)]

for w in range(1, N+1):

    for i in range(N):

        j = i + w

        if j > N:

            continue

        if (w+n) % 2 == 1:

            DP[i][j] = min(DP[i+1][j] - A[i], DP[i][j-1] - A[j-1])

        else:

            DP[i][j] = max(DP[i+1][j] + A[i], DP[i][j-1] + A[j-1])

print((DP[0][N]))

N Ġ= Ġint (input ())ĊĊ A Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ n Ġ= ĠN Ġ% Ġ 2 ĊĊĊĊ DP Ġ= Ġ[[ 0 ] Ġ* Ġ( N + 1 ) Ġfor Ġ_ Ġin Ġrange (N + 1 )] ĊĊĊĊ for Ġw Ġin Ġrange ( 1 , ĠN + 1 ):ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= Ġi Ġ+ Ġw ĊĊ ĠĠĠĠĠĠĠ Ġif Ġj Ġ> ĠN :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ( w +n ) Ġ% Ġ 2 Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠDP [i ][ j ] Ġ= Ġmin (D P [i + 1 ][ j ] Ġ- ĠA [i ], ĠDP [i ][ j - 1 ] Ġ- ĠA [j - 1 ])ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠDP [i ][ j ] Ġ= Ġmax (D P [i + 1 ][ j ] Ġ+ ĠA [i ], ĠDP [i ][ j - 1 ] Ġ+ ĠA [j - 1 ])ĊĊ ĊĊ print (( DP [ 0 ][ N ]))Ċ


Input:
from math import factorial as fc

a = int(input())

print((fc(a)%(10**9+7)))

from Ġmath Ġimport Ġfactorial Ġas Ġfc ĊĊ a Ġ= Ġint (input ())ĊĊ print (( fc (a ) %( 1 0 ** 9 + 7 )))


Input:
from math import gcd

N = int(input())

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

c = True

def osa_k(max_num):

  lis = [i for i in range(max_num+1)]

  p = 2

  while p**2 <= max_num:

    if lis[p] == p:

      for q in range(2*p, max_num+1, p):

        if lis[q] == q:

          lis[q] = p

    p += 1

  return lis

hoge = 0

for i in num_lis:

  hoge = gcd(hoge, i)

if hoge > 1:

  print("not coprime")

  exit()

d_lis = osa_k(10**6+10)

tmp = set()

for i in num_lis:

  num = i

  new_tmp = set()

  while num > 1:

    d = d_lis[num]

    new_tmp.add(d)

    num //= d

  for j in new_tmp:

    if j in tmp:

      c = False

      break

    else:

      tmp.add(j)

  else:

    continue

  break

if c:

  print("pairwise coprime")

else:

  print("setwise coprime")

from Ġmath Ġimport Ġgcd ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ num _l is Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ c Ġ= ĠTrue ĊĊĊĊ def Ġos a _k (max _num ):ĊĊ Ġ Ġlis Ġ= Ġ[ i Ġfor Ġi Ġin Ġrange (max _num + 1 )]ĊĊ Ġ Ġp Ġ= Ġ 2 ĊĊ Ġ Ġwhile Ġp ** 2 Ġ<= Ġmax _num :ĊĊ ĠĠĠ Ġif Ġlis [p ] Ġ== Ġp :ĊĊ ĠĠĠĠĠ Ġfor Ġq Ġin Ġrange ( 2 *p , Ġmax _num + 1 , Ġp ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġlis [q ] Ġ== Ġq :ĊĊ ĠĠĠĠĠĠĠĠĠ Ġlis [q ] Ġ= Ġp ĊĊ ĠĠĠ Ġp Ġ+= Ġ 1 ĊĊ Ġ Ġreturn Ġlis ĊĊĊĊ h oge Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġnum _l is :ĊĊ Ġ Ġh oge Ġ= Ġgcd (h oge , Ġi )ĊĊ if Ġh oge Ġ> Ġ 1 :ĊĊ Ġ Ġprint (" not Ġcop r ime ")ĊĊ Ġ Ġexit ()ĊĊĊĊ d _l is Ġ= Ġos a _k ( 1 0 ** 6 + 1 0 )ĊĊ tmp Ġ= Ġset ()ĊĊ for Ġi Ġin Ġnum _l is :ĊĊ Ġ Ġnum Ġ= Ġi ĊĊ Ġ Ġnew _tmp Ġ= Ġset ()ĊĊ Ġ Ġwhile Ġnum Ġ> Ġ 1 :ĊĊ ĠĠĠ Ġd Ġ= Ġd _l is [num ]ĊĊ ĠĠĠ Ġnew _tmp .add (d )ĊĊ ĠĠĠ Ġnum Ġ//= Ġd ĊĊ Ġ Ġfor Ġj Ġin Ġnew _tmp :ĊĊ ĠĠĠ Ġif Ġj Ġin Ġtmp :ĊĊ ĠĠĠĠĠ Ġc Ġ= ĠFalse ĊĊ ĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠ Ġtmp .add (j )ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ Ġcontinue ĊĊ Ġ Ġbreak ĊĊĊĊ if Ġc :ĊĊ Ġ Ġprint (" pair wise Ġcop r ime ")ĊĊ else :ĊĊ Ġ Ġprint (" set wise Ġcop r ime ")


Input:
n = int(input())

edges = []

for id in range(n-1):

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

    edges.append([a-1, b-1, id])

edges.sort()

used = [0]*(n)

ans = [0]*(n-1)

num = 1

prev = 0

for edge in edges:

    _from, to, id = edge

    if _from != prev:

        num = 1

    if used[_from] == num:

        num += 1

    ans[id] = num

    used[to] = num

    num += 1

    prev = _from

print((max(ans)))

for color in ans:

    print(color)

n Ġ= Ġint (input ())ĊĊ edges Ġ= Ġ[] ĊĊĊĊ for Ġid Ġin Ġrange (n - 1 ):ĊĊ ĠĠĠ Ġa , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġedges .append ([ a - 1 , Ġb - 1 , Ġid ])ĊĊ ĊĊ edges .sort ()ĊĊĊĊ used Ġ= Ġ[ 0 ]*( n )ĊĊ ans Ġ= Ġ[ 0 ]*( n - 1 )ĊĊ num Ġ= Ġ 1 ĊĊ prev Ġ= Ġ 0 ĊĊ for Ġedge Ġin Ġedges :ĊĊ ĠĠĠ Ġ_ from , Ġto , Ġid Ġ= Ġedge ĊĊ ĠĠĠ Ġif Ġ_ from Ġ!= Ġprev :ĊĊ ĠĠĠĠĠĠĠ Ġnum Ġ= Ġ 1 ĊĊ ĠĠĠ Ġif Ġused [_ from ] Ġ== Ġnum :ĊĊ ĠĠĠĠĠĠĠ Ġnum Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġans [id ] Ġ= Ġnum ĊĊ ĠĠĠ Ġused [to ] Ġ= Ġnum ĊĊ ĠĠĠ Ġnum Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġprev Ġ= Ġ_ from ĊĊĊĊ print (( max (ans )))ĊĊ for Ġcolor Ġin Ġans :ĊĊ ĠĠĠ Ġprint (color )Ċ


Input:
for i in range(0, int(input())):

    sidelen = [int(j) for j in input().split(" ")]

    sidelen.sort(reverse=True)

    if(sidelen[0]**2 == sidelen[1]**2 + sidelen[2]**2):

        print("YES")

    else:

        print("NO")

for Ġi Ġin Ġrange ( 0 , Ġint (input ())) :ĊĊ ĠĠĠ Ġsid elen Ġ= Ġ[ int (j ) Ġfor Ġj Ġin Ġinput (). split (" Ġ") ]ĊĊ ĠĠĠ Ġsid elen .sort (reverse =True )ĊĊ ĠĠĠ Ġif (sid elen [ 0 ]** 2 Ġ== Ġsid elen [ 1 ]** 2 Ġ+ Ġsid elen [ 2 ]** 2 ):ĊĊ ĠĠĠĠĠĠĠ Ġprint (" YES ")ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint (" NO ")


Input:
n = int(input())

s = input().split()

s = set(s)

print(('Four' if len(s) == 4 else 'Three'))

n Ġ= Ġint (input ())ĊĊ s Ġ= Ġinput (). split ()ĊĊ s Ġ= Ġset (s )ĊĊ print ((' Four ' Ġif Ġlen (s ) Ġ== Ġ 4 Ġelse Ġ' Three '))


Input:
dX = [2,2,2,1,0,-1,-2,-2,-2,-1,0,1]

dY = [-1,0,1,2,2,2,1,0,-1,-2,-2,-2]

def solve(x,y,XY):

	xy = XY[:]

	if len(xy) == 0: return "OK"

	sx,sy = xy.pop(0),xy.pop(0)

	for dx,dy in zip(dX,dY):

		if doa(x+dx,y+dy,sx,sy):

			r = solve(x+dx,y+dy,xy)

			if r: return r

def doa(x,y,sx,sy):

	if not (0 <= x <= 9 and 0 <= y <= 9): return False

	return True if abs(x-sx) < 2 and abs(y-sy) < 2 else False

while 1:

	x,y = list(map(int,input().split()))

	if x == y == 0: break

	n = input()

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

	ans = solve(x,y,xy)

	print(ans if ans else "NA")

d X Ġ= Ġ[ 2 , 2 , 2 , 1 , 0 ,- 1 ,- 2 ,- 2 ,- 2 ,- 1 , 0 , 1 ]ĊĊ d Y Ġ= Ġ[- 1 , 0 , 1 , 2 , 2 , 2 , 1 , 0 ,- 1 ,- 2 ,- 2 ,- 2 ]ĊĊ def Ġsolve (x ,y , XY ):ĊĊ ĉ xy Ġ= ĠXY [: ]ĊĊ ĉif Ġlen (xy ) Ġ== Ġ 0 : Ġreturn Ġ" OK "ĊĊ ĉs x ,s y Ġ= Ġxy .pop ( 0 ), xy .pop ( 0 )ĊĊ ĉfor Ġdx , dy Ġin Ġzip (d X ,d Y ):ĊĊ ĉ ĉif Ġdo a (x + dx ,y + dy ,s x ,s y ): ĠĊĊ ĉĉ ĉr Ġ= Ġsolve (x + dx ,y + dy , xy )ĊĊ ĉĉ ĉif Ġr : Ġreturn Ġr ĊĊĊĊ def Ġdo a (x ,y ,s x ,s y ):ĊĊ ĉif Ġnot Ġ( 0 Ġ<= Ġx Ġ<= Ġ 9 Ġand Ġ 0 Ġ<= Ġy Ġ<= Ġ 9 ): Ġreturn ĠFalse ĊĊ ĉreturn ĠTrue Ġif Ġabs (x -s x ) Ġ< Ġ 2 Ġand Ġabs (y -s y ) Ġ< Ġ 2 Ġelse ĠFalse ĊĊĊĊ while Ġ 1 :ĊĊ ĉx ,y Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĉif Ġx Ġ== Ġy Ġ== Ġ 0 : Ġbreak ĊĊ ĉn Ġ= Ġinput ()ĊĊ ĉ xy Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĉans Ġ= Ġsolve (x ,y , xy )ĊĊ ĉprint (ans Ġif Ġans Ġelse Ġ" NA ")


Input:
import sys

input = sys.stdin.readline

sys.setrecursionlimit(1000000)

from collections import deque

def getN():

    return int(input())

def getList():

    return list(map(int, input().split()))

import math

n = getN()

nums = getList()

# nums.sort(reverse=True)

mx = max(nums)

mn = (mx+1) // 2

mndx = (mx % 2) + 1

from collections import Counter

cnt = Counter(nums)

for i in range(mn+1, mx+1):

    if cnt[i] < 2:

        print("Impossible")

        sys.exit()

if cnt[mn] != mndx:

    print("Impossible")

else:

    print("Possible")

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ sys .set rec ursion limit ( 1 0 0 0 0 0 0 )ĊĊ from Ġcollections Ġimport Ġdeque ĊĊ def Ġget N ():ĊĊ ĠĠĠ Ġreturn Ġint (input ())ĊĊ def ĠgetList ():ĊĊ ĠĠĠ Ġreturn Ġlist (map (int , Ġinput (). split ()))ĊĊ import Ġmath ĊĊĊĊ n Ġ= Ġget N ()ĊĊ nums Ġ= ĠgetList ()ĊĊĊĊ # Ġnums .sort (reverse =True )ĊĊ mx Ġ= Ġmax (nums )ĊĊ mn Ġ= Ġ( mx + 1 ) Ġ// Ġ 2 ĊĊ m ndx Ġ= Ġ( mx Ġ% Ġ 2 ) Ġ+ Ġ 1 ĊĊĊĊ from Ġcollections Ġimport ĠCounter ĊĊĊĊ cnt Ġ= ĠCounter (nums )ĊĊĊĊ for Ġi Ġin Ġrange (m n + 1 , Ġmx + 1 ):ĊĊ ĠĠĠ Ġif Ġcnt [i ] Ġ< Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (" Impossible ")ĊĊ ĠĠĠĠĠĠĠ Ġsys .exit ()ĊĊĊĊ if Ġcnt [m n ] Ġ!= Ġm ndx :ĊĊ ĠĠĠ Ġprint (" Impossible ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" Possible ")


Input:
import sys

if __name__ == '__main__':

    import doctest

    doctest.testmod()

    S = int(sys.stdin.read())

    h = S / 3600

    m = (S % 3600) / 60

    s = S % 60

    print("%d:%d:%d" % (h, m, s))

import Ġsys ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġimport Ġdo ctest ĊĊ ĠĠĠ Ġdo ctest .test mod ()ĊĊ ĠĠĠ ĠS Ġ= Ġint (sys .stdin .read ())ĊĊ ĠĠĠ Ġh Ġ= ĠS Ġ/ Ġ 3 6 0 0 ĊĊ ĠĠĠ Ġm Ġ= Ġ( S Ġ% Ġ 3 6 0 0 ) Ġ/ Ġ 6 0 ĊĊ ĠĠĠ Ġs Ġ= ĠS Ġ% Ġ 6 0 ĊĊ ĠĠĠ Ġprint ("% d :% d :% d " Ġ% Ġ( h , Ġm , Ġs ))Ċ


Input:
n = int(input())

s = []

for i in range(1, 10):

  for j in range(1, 10):

    s.append(i*j)

if n in s:

  print("Yes")

else:

  print("No")

n Ġ= Ġint (input ())ĊĊ s Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange ( 1 , Ġ 1 0 ):ĊĊ Ġ Ġfor Ġj Ġin Ġrange ( 1 , Ġ 1 0 ):ĊĊ ĠĠĠ Ġs .append (i *j )ĊĊ if Ġn Ġin Ġs :ĊĊ Ġ Ġprint (" Yes ")ĊĊ else :ĊĊ Ġ Ġprint (" No ")


Input:
import math

N=int(input())

ans=math.factorial(N)

print((ans%(10**9 +7)))

import Ġmath ĊĊ N =int (input ())ĊĊ ans = math .factor ial (N )ĊĊ print (( ans %( 1 0 ** 9 Ġ+ 7 )))


Input:
from collections import deque

n,*t=list(map(int,open(0).read().split()))

con=[[] for _ in range(n)]

dist_f_k=[0]*n

for a,b,c in zip(t[:3*n-3:3],t[1::3],t[2::3]):

	con[a-1].append((b-1,c))

	con[b-1].append((a-1,c))

k=t[3*n-2]

que=deque([k-1])

while que:

	cur=que.popleft()

	for nxt,dd in con[cur]:

		if dist_f_k[nxt]==0 and nxt!=k-1:

			que.append(nxt)

			dist_f_k[nxt]=dist_f_k[cur]+dd

for x,y in zip(t[3*n-1::2],t[3*n::2]):

	print((dist_f_k[x-1]+dist_f_k[y-1]))

from Ġcollections Ġimport Ġdeque ĊĊ n ,* t =list (map (int , open ( 0 ). read (). split ()))ĊĊ con =[ [] Ġfor Ġ_ Ġin Ġrange (n )]ĊĊ dist _f _k =[ 0 ]* n ĊĊĊĊ for Ġa ,b ,c Ġin Ġzip (t [: 3 *n - 3 : 3 ], t [ 1 :: 3 ], t [ 2 :: 3 ]) :ĊĊ ĉcon [a - 1 ]. append (( b - 1 ,c ))ĊĊ ĉcon [b - 1 ]. append (( a - 1 ,c )) ĊĊĊĊ k =t [ 3 *n - 2 ]ĊĊ que = deque ([ k - 1 ])ĊĊ while Ġque :ĊĊ ĉcur = que .p opleft ()ĊĊ ĉfor Ġnxt , dd Ġin Ġcon [cur ]:ĊĊ ĉ ĉif Ġdist _f _k [n xt ]== 0 Ġand Ġnxt != k - 1 :ĊĊ ĉĉ ĉ que .append (n xt )ĊĊ ĉĉ ĉdist _f _k [n xt ]= dist _f _k [cur ]+ dd ĊĊĊĊ for Ġx ,y Ġin Ġzip (t [ 3 *n - 1 :: 2 ], t [ 3 *n :: 2 ]) :ĊĊ ĉprint (( dist _f _k [x - 1 ]+ dist _f _k [y - 1 ]))


Input:
S = input()

T = input()

N = len(S)

cnt = 0

for i in range(N):

    cnt += (S[i] != T[i])

print(cnt)

S Ġ= Ġinput ()ĊĊ T Ġ= Ġinput ()ĊĊ N Ġ= Ġlen (S )ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġcnt Ġ+= Ġ( S [i ] Ġ!= ĠT [i ])ĊĊ ĊĊ print (cnt )Ċ


Input:
n, q = [ int( val ) for val in input( ).split( " " ) ]

ps = [0]*n

t = [0]*n

for i in range( n ):

	ps[i], t[i] = input( ).split( " " )

output = []

qsum = 0

while t:

	psi = ps.pop( 0 )

	ti = int( t.pop( 0 ) )

	if ti <= q:

		qsum += ti

		output.append( psi+" "+str( qsum ) )

	else:

		t.append( ti - q )

		ps.append( psi )

		qsum += q

print(( "\n".join( output ) ))

n , Ġq Ġ= Ġ[ Ġint ( Ġval Ġ) Ġfor Ġval Ġin Ġinput ( Ġ). split ( Ġ" Ġ" Ġ) Ġ]ĊĊ ps Ġ= Ġ[ 0 ]* n ĊĊ t Ġ= Ġ[ 0 ]* n ĊĊ for Ġi Ġin Ġrange ( Ġn Ġ):ĊĊ ĉps [i ], Ġt [i ] Ġ= Ġinput ( Ġ). split ( Ġ" Ġ" Ġ)ĊĊ ĊĊĊĊ output Ġ= Ġ[]ĊĊ q sum Ġ= Ġ 0 ĊĊ while Ġt :ĊĊ ĉ psi Ġ= Ġps .pop ( Ġ 0 Ġ)ĊĊ ĉti Ġ= Ġint ( Ġt .pop ( Ġ 0 Ġ) Ġ)ĊĊ ĉif Ġti Ġ<= Ġq :ĊĊ ĉ ĉq sum Ġ+= Ġti ĉĊĊ ĉ ĉoutput .append ( Ġpsi +" Ġ"+ str ( Ġq sum Ġ) Ġ)ĊĊ ĉelse :ĊĊ ĉ ĉt .append ( Ġti Ġ- Ġq Ġ)ĊĊ ĉ ĉps .append ( Ġpsi Ġ)ĊĊ ĉ ĉq sum Ġ+= Ġq ĊĊĊĊ print (( Ġ"\ n ". join ( Ġoutput Ġ) Ġ))


Input:
N,K = list(map(int, input().split(' ')))

a=list(range(1,N+1))

for i in range(K):

  count=int(input())

  b=input().split(' ')

  for j in range(count):

    if int(b[j]) in a:

      a.remove(int(b[j]))

print((len(a)))

N ,K Ġ= Ġlist (map (int , Ġinput (). split (' Ġ' )))ĊĊ a =list (range ( 1 ,N + 1 ))ĊĊ for Ġi Ġin Ġrange (K ):ĊĊ Ġ Ġcount =int (input ())ĊĊ Ġ Ġb =input (). split (' Ġ')ĊĊ Ġ Ġfor Ġj Ġin Ġrange (count ):ĊĊ ĠĠĠ Ġif Ġint (b [j ]) Ġin Ġa :ĊĊ ĠĠĠĠĠ Ġa .remove (int (b [j ]))ĊĊ print (( len (a )))


Input:
res = []

while True:

    s = input()

    if s == '0':

        break

    res.append(sum([int(x) for x in s]))

for e in res:

    print(e)

res Ġ= Ġ[]ĊĊ while ĠTrue :ĊĊ ĠĠĠ Ġs Ġ= Ġinput ()ĊĊ ĠĠĠ Ġif Ġs Ġ== Ġ' 0 ':ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ ĠĠĠ Ġres .append (sum ([ int (x ) Ġfor Ġx Ġin Ġs ])) ĊĊĊĊ for Ġe Ġin Ġres :ĊĊ ĠĠĠ Ġprint (e )


Input: import re;print((max(list(map(len,re.split('[^ACGT]',input()))))))

import Ġre ; print (( max (list (map (len ,re .split ('[ ^ AC GT ]', input ())) ))))


Input:
import math

n=int(input())

waru=10**9+7

li=[]

li2=[]

for i in range(2,n+1):

    tmp=math.factorial(n)

    flag=1

    for j in range(len(li)):

        if i%li[j]==0:

            flag=0

            break

    if flag==1:

        li.append(i)

        li2.append(0)

        while tmp%i==0:

            li2[len(li)-1]+=1

            tmp=tmp//i

ans=1

# print(li)

# print(li2)

for i in range(len(li2)):

    ans*=li2[i]+1

print((ans%waru))

import Ġmath ĊĊ n =int (input ())ĊĊ war u = 1 0 ** 9 + 7 ĊĊĊĊ li =[] ĊĊ li 2 =[] ĊĊĊĊ for Ġi Ġin Ġrange ( 2 ,n + 1 ):ĊĊ ĠĠĠ Ġtmp = math .factor ial (n )ĊĊ ĠĠĠ Ġflag = 1 ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (len (li )) :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi % li [j ]== 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġflag = 0 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġif Ġflag == 1 :ĊĊ ĠĠĠĠĠĠĠ Ġli .append (i )ĊĊ ĠĠĠĠĠĠĠ Ġli 2 .append ( 0 )ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġtmp %i == 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġli 2 [len (li )- 1 ]+= 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġtmp =tmp // i ĊĊ ans = 1 ĊĊ # Ġprint (li )ĊĊ # Ġprint (li 2 )ĊĊ for Ġi Ġin Ġrange (len (li 2 )) :ĊĊ ĠĠĠ Ġans *= li 2 [i ]+ 1 ĊĊ print (( ans % war u ))


Input:
N = int(input())

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

ans = 0

check = [0]*30

for i in range(1, 31):

    check[i-1] = 2**i

for i in A:

    if i % 2 == 0:

        j = 0

        while check[j] <= i:

            if i % check[j] == 0:

                add = check[j]

            else:

                break

            j += 1

        ans += j

print(ans)

N Ġ= Ġint (input ())ĊĊ A Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ ans Ġ= Ġ 0 ĊĊ check Ġ= Ġ[ 0 ]* 3 0 ĊĊ for Ġi Ġin Ġrange ( 1 , Ġ 3 1 ):ĊĊ ĠĠĠ Ġcheck [i - 1 ] Ġ= Ġ 2 ** i ĊĊĊĊ for Ġi Ġin ĠA :ĊĊ ĠĠĠ Ġif Ġi Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġcheck [j ] Ġ<= Ġi :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi Ġ% Ġcheck [j ] Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġadd Ġ= Ġcheck [j ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġj Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġj ĊĊ ĠĠĠĠĠĠĠĠĊĊ print (ans )


Input:
N = int(input())

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

M = int(input())

p = []

x = []

ans = []

for i in range(M):

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

    ans.append(sum(T[:p-1])+x+sum(T[p:]))

for _ in ans:

    print(_)

N Ġ= Ġint (input ())ĊĊ T Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ M Ġ= Ġint (input ())ĊĊ p Ġ= Ġ[]ĊĊ x Ġ= Ġ[]ĊĊ ans Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠ Ġp , Ġx Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġans .append (sum (T [: p - 1 ])+ x + sum (T [p : ])) ĊĊĊĊ for Ġ_ Ġin Ġans :ĊĊ ĠĠĠ Ġprint (_)


Input:
import math

N = int(input())

print((math.factorial(N)%(10**9+7)))

import Ġmath ĊĊ N Ġ= Ġint (input ())ĊĊ print (( math .factor ial (N ) %( 1 0 ** 9 + 7 )))


Input:
def main():

    import math

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

    a=[]

    for i in range(M):

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

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

        c=0

        for j in range(len(tmpc)):

            c+=2**(tmpc[j]-1)

        tmp[1]=c

        a+=[tmp]

    dp=[[10**10 for j in range(2**N)] for i in range(M)]

    dp[0][0]=0

    dp[0][a[0][1]]=a[0][0]

    for i in range(1,M):

        dp[i]=dp[i-1]

        for j in range(2**N):

            z,p=a[i][0],a[i][1]

            q=j|p

            x=dp[i-1][j]+z

            if dp[i][q]>x: dp[i][q]=x

    ans=dp[M-1][2**N-1]

    print((ans if ans<10**10 else -1))

if __name__ == '__main__':

    main()

def Ġmain ():ĊĊ ĠĠĠ Ġimport Ġmath ĊĊ ĠĠĠ ĠN ,M =list (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġa =[] ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠĠĠĠĠ Ġtmp =list (map (int ,input (). split ()))ĊĊ ĠĠĠĠĠĠĠ Ġtmp c =list (map (int ,input (). split ()))ĊĊ ĠĠĠĠĠĠĠ Ġc = 0 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (len (tmp c )) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġc += 2 **( tmp c [j ]- 1 )ĊĊ ĠĠĠĠĠĠĠ Ġtmp [ 1 ]= c ĊĊ ĠĠĠĠĠĠĠ Ġa + =[ tmp ] ĊĊĊĊĊĊ ĠĠĠ Ġdp =[[ 1 0 ** 1 0 Ġfor Ġj Ġin Ġrange ( 2 ** N )] Ġfor Ġi Ġin Ġrange (M )]ĊĊ ĠĠĠ Ġdp [ 0 ][ 0 ]= 0 ĊĊ ĠĠĠ Ġdp [ 0 ][ a [ 0 ][ 1 ]]= a [ 0 ][ 0 ] ĊĊĊĊĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 ,M ):ĊĊ ĠĠĠĠĠĠĠ Ġdp [i ]= dp [i - 1 ]ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 2 ** N ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġz ,p =a [i ][ 0 ], a [i ][ 1 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġq =j | p ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġx = dp [i - 1 ][ j ]+ z ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġdp [i ][ q ]> x : Ġdp [i ][ q ]= x ĊĊĊĊ ĠĠĠ Ġans = dp [M - 1 ][ 2 ** N - 1 ]ĊĊ ĠĠĠ Ġprint (( ans Ġif Ġans < 1 0 ** 1 0 Ġelse Ġ- 1 )) ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
#!/usr/bin/env pypy3

# N,M = map(int,sys.stdin.readline().split())

# a = tuple(map(int,sys.stdin.readline().split())) # single line with multi param

# a = tuple(int(sys.stdin.readline()) for _ in range(N)) # multi line with single param

# a = tuple(tuple(map(int,sys.stdin.readline().rstrip().split())) for _ in range(N)) # multi line with multi param

# s = sys.stdin.readline().rstrip()

# N = int(sys.stdin.readline())

# INF = float("inf")

import math,sys

n = int(sys.stdin.readline())

a = tuple(map(int,sys.stdin.readline().split()))

#n = int(input())

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

g = math.gcd(a[0],a[1])

for i in range(2,n):

    g = math.gcd(g,a[i])

M = max(a)

acc = a[0]

for i in range(n):

    acc = math.gcd(acc,a[i])

if acc != 1:

    print("not coprime")

    exit()

LIMIT=max(a)

minPrime = [0]*(LIMIT+1)

minPrime[1] = 1

def make():

    for i in range(2,LIMIT+1):

        if minPrime[i] == 0:

            minPrime[i] = i

            #print(i)

            for j in range(i+i,LIMIT+1,i):

                #print(i,j)

                if minPrime[j] == 0:

                    minPrime[j] = i

make()

def factrial(N):

     ret = []

     while minPrime[N] != N:

         ret.append(minPrime[N])

         N = N//minPrime[N]

     if N != 1:

         ret.append(N)

     return ret

judge = set([])

pc = True

pairwise = True

p = set() #all prime

for e in a:

    if not pairwise:

        break

    asf = set(factrial(e))

    if judge & asf != set():

        pc = False

    #     #pairwise = False

    #     print("setwise coprime")

    #     exit(0)

    judge |= asf

# for i in a:

#     if not pc:

#         break

#     asf = set(factrial(i))

#     if judge & asf != set():

#         pc = False

#     judge |= asf

if pc:

    print("pairwise coprime")

elif g == 1:

    print("setwise coprime")

else:

    print("not coprime")

#!/ usr /bin /env Ġp ypy 3 ĊĊ # ĠN ,M Ġ= Ġmap (int , sys .stdin .readline (). split ())ĊĊ # Ġa Ġ= Ġtuple (map (int , sys .stdin .readline (). split ())) Ġ# Ġsingle Ġline Ġwith Ġmulti Ġparam ĊĊ # Ġa Ġ= Ġtuple (int (sys .stdin .readline ()) Ġfor Ġ_ Ġin Ġrange (N )) Ġ# Ġmulti Ġline Ġwith Ġsingle Ġparam ĊĊ # Ġa Ġ= Ġtuple (tuple (map (int , sys .stdin .readline (). rstrip (). split ())) Ġfor Ġ_ Ġin Ġrange (N )) Ġ# Ġmulti Ġline Ġwith Ġmulti Ġparam ĊĊ # Ġs Ġ= Ġsys .stdin .readline (). rstrip ()ĊĊ # ĠN Ġ= Ġint (sys .stdin .readline ())ĊĊ # ĠINF Ġ= Ġfloat (" inf ")ĊĊ import Ġmath , sys ĊĊĊĊ n Ġ= Ġint (sys .stdin .readline ())ĊĊ a Ġ= Ġtuple (map (int , sys .stdin .readline (). split ()))ĊĊ # n Ġ= Ġint (input ())ĊĊ #a Ġ= Ġlist (map (int ,input (). split ()))ĊĊ g Ġ= Ġmath .g cd (a [ 0 ], a [ 1 ])ĊĊ for Ġi Ġin Ġrange ( 2 ,n ):ĊĊ ĠĠĠ Ġg Ġ= Ġmath .g cd (g ,a [i ])ĊĊ M Ġ= Ġmax (a )ĊĊ acc Ġ= Ġa [ 0 ]ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġacc Ġ= Ġmath .g cd (acc ,a [i ])ĊĊ if Ġacc Ġ!= Ġ 1 :ĊĊ ĠĠĠ Ġprint (" not Ġcop r ime ")ĊĊ ĠĠĠ Ġexit ()ĊĊĊĊ LIMIT =max (a )ĊĊ min Prime Ġ= Ġ[ 0 ]*( LIMIT + 1 )ĊĊ min Prime [ 1 ] Ġ= Ġ 1 ĊĊ def Ġmake ():ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 2 ,L IMIT + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġmin Prime [i ] Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmin Prime [i ] Ġ= Ġi ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġ# print (i )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (i +i ,L IMIT + 1 ,i ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġ# print (i ,j )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġmin Prime [j ] Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġmin Prime [j ] Ġ= Ġi ĊĊ make ()ĊĊ def Ġfact rial (N ):ĊĊ ĠĠĠĠ Ġret Ġ= Ġ[]ĊĊ ĠĠĠĠ Ġwhile Ġmin Prime [N ] Ġ!= ĠN :ĊĊ ĠĠĠĠĠĠĠĠ Ġret .append (min Prime [N ])ĊĊ ĠĠĠĠĠĠĠĠ ĠN Ġ= ĠN // min Prime [N ]ĊĊ ĠĠĠĠ Ġif ĠN Ġ!= Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠ Ġret .append (N )ĊĊ ĠĠĠĠ Ġreturn Ġret ĊĊĊĊ judge Ġ= Ġset ([] )ĊĊ pc Ġ= ĠTrue ĊĊĊĊ pair wise Ġ= ĠTrue ĊĊ p Ġ= Ġset () Ġ# all Ġprime ĊĊĊĊ for Ġe Ġin Ġa :ĊĊ ĠĠĠ Ġif Ġnot Ġpairwise :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġas f Ġ= Ġset (f act rial (e ))ĊĊ ĠĠĠ Ġif Ġjudge Ġ& Ġas f Ġ!= Ġset ():ĊĊ ĠĠĠĠĠĠĠ Ġpc Ġ= ĠFalse ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġ# pair wise Ġ= ĠFalse ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġprint (" set wise Ġcop r ime ")ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġexit ( 0 )ĊĊ ĠĠĠ Ġjudge Ġ|= Ġas f ĊĊ # Ġfor Ġi Ġin Ġa :ĊĊ # ĠĠĠĠ Ġif Ġnot Ġpc :ĊĊ # ĠĠĠĠĠĠĠĠ Ġbreak ĊĊ # ĠĠĠĠ Ġas f Ġ= Ġset (f act rial (i )) ĊĊĊĊ # ĠĠĠĠ Ġif Ġjudge Ġ& Ġas f Ġ!= Ġset ():ĊĊ # ĠĠĠĠĠĠĠĠ Ġpc Ġ= ĠFalse ĊĊ # ĠĠĠĠ Ġjudge Ġ|= Ġas f ĊĊ if Ġpc :ĊĊ ĠĠĠ Ġprint (" pair wise Ġcop r ime ")ĊĊ elif Ġg Ġ== Ġ 1 :ĊĊ ĠĠĠ Ġprint (" set wise Ġcop r ime ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" not Ġcop r ime ")Ċ


Input:
alph = input()

if alph.isupper():

    print("A")

else:

    print("a")

alph Ġ= Ġinput ()ĊĊ if Ġalph .is upper ():ĊĊ ĠĠĠ Ġprint (" A ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" a ")Ċ


Input:
n, m, k = list(map(int, input().split()))

mod = 1000000007

def pow(x, n):

    ret = 1

    while n > 0:

        if (n & 1) == 1:

            ret = (ret * x) % mod

        x = (x * x) % mod

        n >>= 1

    return ret

fac = [1]

inv = [1]

for i in range(1, n * m + 1):

    fac.append((fac[-1] * i) % mod)

    inv.append(pow(fac[i], mod - 2))

def cmb(n, k):

    return (fac[n] * inv[k] * inv[n - k]) % mod

def doit(n, m, k):

    ret = 0

    for d in range(m):

        ret = (ret + d * (m - d)) % mod

    return (ret * n * n * cmb(n * m - 2, k - 2)) % mod

print(((doit(n, m, k) + doit(m, n, k)) % mod))

n , Ġm , Ġk Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ mod Ġ= Ġ 1 0 0 0 0 0 0 0 0 7 ĊĊ def Ġpow (x , Ġn ):ĊĊ ĠĠĠ Ġret Ġ= Ġ 1 ĊĊ ĠĠĠ Ġwhile Ġn Ġ> Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ( n Ġ& Ġ 1 ) Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġret Ġ= Ġ( ret Ġ* Ġx ) Ġ% Ġmod ĊĊ ĠĠĠĠĠĠĠ Ġx Ġ= Ġ( x Ġ* Ġx ) Ġ% Ġmod ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ>>= Ġ 1 ĊĊ ĠĠĠ Ġreturn Ġret ĊĊĊĊ fac Ġ= Ġ[ 1 ]ĊĊ inv Ġ= Ġ[ 1 ]ĊĊ for Ġi Ġin Ġrange ( 1 , Ġn Ġ* Ġm Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġfac .append (( fac [- 1 ] Ġ* Ġi ) Ġ% Ġmod )ĊĊ ĠĠĠ Ġinv .append (pow (f ac [i ], Ġmod Ġ- Ġ 2 )) ĊĊĊĊ def Ġcmb (n , Ġk ):ĊĊ ĠĠĠ Ġreturn Ġ( fac [n ] Ġ* Ġinv [k ] Ġ* Ġinv [n Ġ- Ġk ]) Ġ% Ġmod ĊĊĊĊ def Ġdoit (n , Ġm , Ġk ):ĊĊ ĠĠĠ Ġret Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġd Ġin Ġrange (m ):ĊĊ ĠĠĠĠĠĠĠ Ġret Ġ= Ġ( ret Ġ+ Ġd Ġ* Ġ( m Ġ- Ġd )) Ġ% Ġmod ĊĊ ĠĠĠ Ġreturn Ġ( ret Ġ* Ġn Ġ* Ġn Ġ* Ġcmb (n Ġ* Ġm Ġ- Ġ 2 , Ġk Ġ- Ġ 2 )) Ġ% Ġmod ĊĊĊĊ print ((( do it (n , Ġm , Ġk ) Ġ+ Ġdoit (m , Ġn , Ġk )) Ġ% Ġmod ))


Input:
s=int(input())

p=10**9+7

if s<=2:

    print((0))

    exit()

n=s//3

ans=0

def f(n,k,p):

    if k==0:

        return 1

    elif k%2==0:

        return (f(n,k//2,p)**2)%p

    else:

        return (n*f(n,k-1,p))%p

for k in range(1,n+1):

    a=1

    b=1

    for j in range(k-1):

        a=(a*(s-3*k+1+j))%p

        b=(b*(j+1))%p

    ans=(ans+a*f(b,p-2,p))%p

print((ans%p))

s =int (input ())ĊĊ p = 1 0 ** 9 + 7 ĊĊ if Ġs <= 2 :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠ Ġexit ()ĊĊ n =s // 3 ĊĊ ans = 0 ĊĊ def Ġf (n ,k ,p ):ĊĊ ĠĠĠ Ġif Ġk == 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 1 ĊĊ ĠĠĠ Ġelif Ġk % 2 == 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ( f (n ,k // 2 ,p )** 2 )% p ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ( n *f (n ,k - 1 ,p )) % p ĊĊĊĊ for Ġk Ġin Ġrange ( 1 ,n + 1 ):ĊĊ ĠĠĠ Ġa = 1 ĊĊ ĠĠĠ Ġb = 1 ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (k - 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġa =( a *( s - 3 *k + 1 +j )) % p ĊĊ ĠĠĠĠĠĠĠ Ġb =( b *( j + 1 )) % p ĊĊ ĠĠĠ Ġans =( ans +a *f (b ,p - 2 ,p )) % p ĊĊĊĊ print (( ans %p ))ĊĊĊ


Input: a,b,c,x,y=list(map(int,input().split()));print((min(k*c*2+a*max(x-k,0)+b*max(y-k,0)for k in range(max(x,y)*3))))

a ,b ,c ,x ,y =list (map (int ,input (). split ())); print (( min (k *c * 2 +a * max (x -k , 0 )+ b * max (y -k , 0 ) for Ġk Ġin Ġrange (max (x ,y )* 3 ))))