Input:
import math

import string

import collections

from collections import Counter

def readints():

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

def nCr(n, r):

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

def has_duplicates2(seq):

    seen = []

    for item in seq:

        if not(item in seen):

            seen.append(item)

    return len(seq) != len(seen)

def divisor(n):

    divisor = []

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

        if n % i == 0:

            divisor.append(i)

    return divisor

# coordinates

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

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

a, b, c, d = list(map(int, input()))

#print(a, b, c, d)

if a+b+c+d == 7:

    print((str(a)+'+'+str(b)+'+'+str(c)+'+'+str(d)+'=7'))

    exit()

if a+b-c+d == 7:

    print((str(a)+'+'+str(b)+'-'+str(c)+'+'+str(d)+'=7'))

    exit()

if a+b+c-d == 7:

    print((str(a)+'+'+str(b)+'+'+str(c)+'-'+str(d)+'=7'))

    exit()

if a+b-c-d == 7:

    print((str(a)+'+'+str(b)+'-'+str(c)+'-'+str(d)+'=7'))

    exit()

if a-b+c+d == 7:

    print((str(a)+'-'+str(b)+'+'+str(c)+'+'+str(d)+'=7'))

    exit()

if a-b-c+d == 7:

    print((str(a)+'-'+str(b)+'-'+str(c)+'+'+str(d)+'=7'))

    exit()

if a-b+c-d == 7:

    print((str(a)+'-'+str(b)+'+'+str(c)+'-'+str(d)+'=7'))

    exit()

if a-b-c-d == 7:

    print((str(a)+'-'+str(b)+'-'+str(c)+'-'+str(d)+'=7'))

    exit()

import Ġmath ĊĊ import Ġstring ĊĊ import Ġcollections ĊĊ from Ġcollections Ġimport ĠCounter ĊĊĊĊĊĊ def Ġread ints ():ĊĊ ĠĠĠ Ġreturn Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊĊĊ def Ġn Cr (n , Ġr ):ĊĊ ĠĠĠ Ġreturn Ġmath .factor ial (n )// ( math .factor ial (n -r )* math .factor ial (r )) ĊĊĊĊĊĊ def Ġhas _duplicates 2 (seq ):ĊĊ ĠĠĠ Ġseen Ġ= Ġ[]ĊĊ ĠĠĠ Ġfor Ġitem Ġin Ġseq :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġnot (item Ġin Ġseen ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġseen .append (item )ĊĊ ĠĠĠ Ġreturn Ġlen (seq ) Ġ!= Ġlen (se en )ĊĊĊĊĊĊ def Ġdivisor (n ):ĊĊ ĠĠĠ Ġdivisor Ġ= Ġ[]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġn + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdivisor .append (i )ĊĊ ĠĠĠ Ġreturn Ġdivisor ĊĊĊĊĊĊ # Ġcoordinates ĊĊ dx Ġ= Ġ[- 1 , Ġ- 1 , Ġ- 1 , Ġ 0 , Ġ 0 , Ġ 1 , Ġ 1 , Ġ 1 ]ĊĊ dy Ġ= Ġ[- 1 , Ġ 0 , Ġ 1 , Ġ- 1 , Ġ 1 , Ġ- 1 , Ġ 0 , Ġ 1 ]ĊĊ a , Ġb , Ġc , Ġd Ġ= Ġlist (map (int , Ġinput ()))ĊĊ #print (a , Ġb , Ġc , Ġd )ĊĊ if Ġa +b +c +d Ġ== Ġ 7 :ĊĊ ĠĠĠ Ġprint (( str (a )+' +' + str (b )+' +' + str (c )+' +' + str (d )+' = 7 '))ĊĊ ĠĠĠ Ġexit ()ĊĊ if Ġa +b -c +d Ġ== Ġ 7 :ĊĊ ĠĠĠ Ġprint (( str (a )+' +' + str (b )+' -'+ str (c )+' +' + str (d )+' = 7 '))ĊĊ ĠĠĠ Ġexit ()ĊĊ if Ġa +b +c -d Ġ== Ġ 7 :ĊĊ ĠĠĠ Ġprint (( str (a )+' +' + str (b )+' +' + str (c )+' -'+ str (d )+' = 7 '))ĊĊ ĠĠĠ Ġexit ()ĊĊ if Ġa +b -c -d Ġ== Ġ 7 :ĊĊ ĠĠĠ Ġprint (( str (a )+' +' + str (b )+' -'+ str (c )+' -'+ str (d )+' = 7 '))ĊĊ ĠĠĠ Ġexit ()ĊĊ if Ġa -b +c +d Ġ== Ġ 7 :ĊĊ ĠĠĠ Ġprint (( str (a )+' -'+ str (b )+' +' + str (c )+' +' + str (d )+' = 7 '))ĊĊ ĠĠĠ Ġexit ()ĊĊ if Ġa -b -c +d Ġ== Ġ 7 :ĊĊ ĠĠĠ Ġprint (( str (a )+' -'+ str (b )+' -'+ str (c )+' +' + str (d )+' = 7 '))ĊĊ ĠĠĠ Ġexit ()ĊĊ if Ġa -b +c -d Ġ== Ġ 7 :ĊĊ ĠĠĠ Ġprint (( str (a )+' -'+ str (b )+' +' + str (c )+' -'+ str (d )+' = 7 '))ĊĊ ĠĠĠ Ġexit ()ĊĊ if Ġa -b -c -d Ġ== Ġ 7 :ĊĊ ĠĠĠ Ġprint (( str (a )+' -'+ str (b )+' -'+ str (c )+' -'+ str (d )+' = 7 '))ĊĊ ĠĠĠ Ġexit ()Ċ


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

d=0

while d<10**5:

    if a%2==1 or b%2==1 or c%2==1:break

    a,b,c=b/2+c/2,a/2+c/2,a/2+b/2

    d+=1

else:d=-1

print(d)

a ,b ,c =list (map (int , Ġinput (). split ()))ĊĊ d = 0 ĊĊ while Ġd < 1 0 ** 5 :ĊĊ ĠĠĠ Ġif Ġa % 2 == 1 Ġor Ġb % 2 == 1 Ġor Ġc % 2 == 1 : break ĊĊ ĠĠĠ Ġa ,b ,c =b / 2 +c / 2 ,a / 2 +c / 2 ,a / 2 +b / 2 ĊĊ ĠĠĠ Ġd += 1 ĊĊ else :d =- 1 ĊĊ print (d )


Input:
import statistics

N = int(input())

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

ans = 0

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

  a[i-1] -= i

b = statistics.median(a)

for i in range(N):

  ans += abs(a[i]-b)

print((int(ans)))

import Ġstatistics ĊĊ N Ġ= Ġint (input ())ĊĊ a Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ ans Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange ( 1 ,N + 1 ):ĊĊ Ġ Ġa [i - 1 ] Ġ-= Ġi ĊĊĊĊ b Ġ= Ġstatistics .median (a )ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ Ġ Ġans Ġ+= Ġabs (a [i ]- b )ĊĊ print (( int (ans )))


Input:
n = int(input())

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

ans = 0

nodes_min = [0] * (n + 1)

nodes_max = [0] * (n + 1)

nodes_min[n] = leaves[n]

nodes_max[n] = leaves[n]

for depth in range(n, 0, -1):

    root_min = nodes_min[depth] // 2 + nodes_min[depth] % 2

    nodes_min[depth - 1] = leaves[depth - 1] + root_min

    root_max = nodes_max[depth]

    nodes_max[depth - 1] = leaves[depth - 1] + root_max

nodes = [0] * (n + 1)

nodes[0] = 1

if nodes[0] < nodes_min[0]:

    print((-1))

else:

    for depth in range(n):

        roots = nodes[depth]-leaves[depth]

        nodes[depth + 1] = min(roots * 2, nodes_max[depth + 1])

        if nodes[depth+1] < nodes_min[depth+1]:

            print((-1))

            break

    else:

        print((sum(nodes)))

n Ġ= Ġint (input ())ĊĊ le aves Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ nodes _min Ġ= Ġ[ 0 ] Ġ* Ġ( n Ġ+ Ġ 1 )ĊĊ nodes _max Ġ= Ġ[ 0 ] Ġ* Ġ( n Ġ+ Ġ 1 )ĊĊ nodes _min [n ] Ġ= Ġleaves [n ]ĊĊ nodes _max [n ] Ġ= Ġleaves [n ]ĊĊĊĊ for Ġdepth Ġin Ġrange (n , Ġ 0 , Ġ- 1 ):ĊĊ ĠĠĠ Ġroot _min Ġ= Ġnodes _min [ depth ] Ġ// Ġ 2 Ġ+ Ġnodes _min [ depth ] Ġ% Ġ 2 ĊĊ ĠĠĠ Ġnodes _min [ depth Ġ- Ġ 1 ] Ġ= Ġleaves [ depth Ġ- Ġ 1 ] Ġ+ Ġroot _min ĊĊ ĠĠĠ Ġroot _max Ġ= Ġnodes _max [ depth ]ĊĊ ĠĠĠ Ġnodes _max [ depth Ġ- Ġ 1 ] Ġ= Ġleaves [ depth Ġ- Ġ 1 ] Ġ+ Ġroot _max ĊĊ nodes Ġ= Ġ[ 0 ] Ġ* Ġ( n Ġ+ Ġ 1 )ĊĊ nodes [ 0 ] Ġ= Ġ 1 ĊĊ if Ġnodes [ 0 ] Ġ< Ġnodes _min [ 0 ]:ĊĊ ĠĠĠ Ġprint ((- 1 ))ĊĊ else :ĊĊ ĠĠĠ Ġfor Ġdepth Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġroots Ġ= Ġnodes [ depth ]- le aves [ depth ]ĊĊ ĠĠĠĠĠĠĠ Ġnodes [ depth Ġ+ Ġ 1 ] Ġ= Ġmin ( roots Ġ* Ġ 2 , Ġnodes _max [ depth Ġ+ Ġ 1 ])ĊĊ ĠĠĠĠĠĠĠ Ġif Ġnodes [ depth + 1 ] Ġ< Ġnodes _min [ depth + 1 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint ((- 1 ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint (( sum (nodes )))Ċ


Input:
N = int(input())

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

dp = [0] * 10 ** 7

ans = 0

for i in range(N):

    x = i + 1 - A[i]

    if x >= 0:

        ans += dp[x]

    y = i + 1 + A[i]

    if y < 10 ** 7:

        dp[y] += 1

print(ans)

N Ġ= Ġint (input ())ĊĊ A Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ dp Ġ= Ġ[ 0 ] Ġ* Ġ 1 0 Ġ** Ġ 7 ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġx Ġ= Ġi Ġ+ Ġ 1 Ġ- ĠA [i ]ĊĊ ĠĠĠ Ġif Ġx Ġ>= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġdp [x ]ĊĊ ĠĠĠ Ġy Ġ= Ġi Ġ+ Ġ 1 Ġ+ ĠA [i ]ĊĊ ĠĠĠ Ġif Ġy Ġ< Ġ 1 0 Ġ** Ġ 7 :ĊĊ ĠĠĠĠĠĠĠ Ġdp [y ] Ġ+= Ġ 1 ĊĊĊĊ print (ans )Ċ


Input:
a,b=2,1

for i in[0]*int(input()):a,b=b,a+b

print(a)

a ,b = 2 , 1 ĊĊ for Ġi Ġin [ 0 ]* int (input ()): a ,b =b ,a +b ĊĊ print (a )


Input:
S = int(input())

mod = 10**9+7

dp = [0]*(S+1)

dp[0] = 1

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

    for j in range(0,(i-3)+1):

        dp[i] += dp[j]

        dp[i] %= mod

print((dp[S]))

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


Input:
# ABC 120 C

import re

S = input()

l0 = 0

l1 = 0

for i in range(len(S)):

    if S[i] == '0':

        l0 += 1

    elif S[i] == '1':

        l1 += 1

print((min(l0, l1) * 2))

# ĠABC Ġ 1 2 0 ĠC ĊĊĊĊ import Ġre ĊĊĊĊ S Ġ= Ġinput ()ĊĊĊĊ l 0 Ġ= Ġ 0 ĊĊ l 1 Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (len (S )) :ĊĊ ĠĠĠ Ġif ĠS [i ] Ġ== Ġ' 0 ':ĊĊ ĠĠĠĠĠĠĠ Ġl 0 Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġelif ĠS [i ] Ġ== Ġ' 1 ':ĊĊ ĠĠĠĠĠĠĠ Ġl 1 Ġ+= Ġ 1 ĊĊĊĊ print (( min (l 0 , Ġl 1 ) Ġ* Ġ 2 ))Ċ


Input:
def iput(): return int(input())

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

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

def solve():

    a, b = mput()

    print((a*b))

    return 0

if __name__ == "__main__":

    solve()

def Ġip ut (): Ġreturn Ġint (input ())ĊĊ def Ġm put (): Ġreturn Ġlist (map (int , Ġinput (). split ()))ĊĊ def Ġl put (): Ġreturn Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ def Ġsolve ():ĊĊ ĠĠĠ Ġa , Ġb Ġ= Ġm put ()ĊĊ ĠĠĠ Ġprint (( a *b ))ĊĊ ĠĠĠ Ġreturn Ġ 0 ĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġsolve ()


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

if (b - a) == (c - b):

    print("YES")

else:

    print("NO")

a , Ġb , Ġc Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ if Ġ( b Ġ- Ġa ) Ġ== Ġ( c Ġ- Ġb ):ĊĊ ĠĠĠ Ġprint (" YES ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" NO ")


Input:
import math

print((math.factorial(int(input()))%1000000007))


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

count = 0

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

    j = str(i)

    if j==''.join(reversed(j)):

        count += 1

print(count)

a ,b Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ count Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (a ,b + 1 ):ĊĊ ĠĠĠ Ġj Ġ= Ġstr (i )ĊĊ ĠĠĠ Ġif Ġj ==' '. join (re versed (j )) :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ print (count )


Input:
#!/usr/bin/env pypy3

import math

print((math.factorial(int(input())) % 1000000007))


Input:
(N, K), *AB = [list(map(int, s.split())) for s in open(0)]

for a, b in sorted(AB):

    K -= b

    if K <= 0:

        print(a)

        break

(N , ĠK ), Ġ* AB Ġ= Ġ[ list (map (int , Ġs .split ())) Ġfor Ġs Ġin Ġopen ( 0 )]ĊĊ for Ġa , Ġb Ġin Ġsorted ( AB ):ĊĊ ĠĠĠ ĠK Ġ-= Ġb ĊĊ ĠĠĠ Ġif ĠK Ġ<= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (a )ĊĊ ĠĠĠĠĠĠĠ Ġbreak Ċ


Input:
mod = int(1e9+7)

n = int(input())

power = 1

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

    power = power * i % mod

print(power)

mod Ġ= Ġint ( 1 e 9 + 7 )ĊĊ n Ġ= Ġint (input ())ĊĊ ĊĊ power Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġrange ( 1 , Ġn + 1 ):ĊĊ ĠĠĠ Ġpower Ġ= Ġpower Ġ* Ġi Ġ% Ġmod ĊĊ print (power )


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

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

V = 0

for i in range(N):

  V += L[i][1]

dp = [[10**9+1] * (V + 1) for i in range(N+1)]

dp[0][0] = 0

for i in range(N):

    for j in range(V+1):

        if j - L[i][1] >= 0:

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

        else:

          dp[i+1][j] = dp[i][j]

ans = 0

for j in range(V+1):

    if  W >= dp[-1][j]:

        ans = max(ans, j)

print(ans)

N , ĠW Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ L Ġ= Ġ[ list (map (int , Ġinput (). split ())) Ġfor Ġi Ġin Ġrange (N )]ĊĊ V Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ Ġ ĠV Ġ+= ĠL [i ][ 1 ]ĊĊĊĊ dp Ġ= Ġ[[ 1 0 ** 9 + 1 ] Ġ* Ġ( V Ġ+ Ġ 1 ) Ġfor Ġi Ġin Ġrange (N + 1 )]ĊĊ dp [ 0 ][ 0 ] Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (V + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġj Ġ- ĠL [i ][ 1 ] Ġ>= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠ Ġdp [i + 1 ][ j ] Ġ= Ġmin (dp [i ][ j ], Ġdp [i ][ j -L [i ][ 1 ]] Ġ+ ĠL [i ][ 0 ])ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠ Ġdp [i + 1 ][ j ] Ġ= Ġdp [i ][ j ]ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġj Ġin Ġrange (V + 1 ):ĊĊ ĠĠĠ Ġif Ġ ĠW Ġ>= Ġdp [- 1 ][ j ]:ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġmax (ans , Ġj )ĊĊ print (ans )


Input:
s = input()

start = -1

end = 0

for i in range(len(s)):

    if s[i] == 'A' and start < 0:

        start = i

    elif s[i] == 'Z':

        end = i

print((end - start + 1))

s Ġ= Ġinput ()ĊĊĊĊ start Ġ= Ġ- 1 ĊĊ end Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (len (s )) :ĊĊ ĠĠĠ Ġif Ġs [i ] Ġ== Ġ' A ' Ġand Ġstart Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġstart Ġ= Ġi ĊĊ ĠĠĠ Ġelif Ġs [i ] Ġ== Ġ' Z ':ĊĊ ĠĠĠĠĠĠĠ Ġend Ġ= Ġi ĊĊ print (( end Ġ- Ġstart Ġ+ Ġ 1 ))Ċ


Input:
while 1:

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

 if n+x==0:break

 print((len([1 for i in range(3,n+1)for j in range(2,x-i)if x-i-j<j<i])))

while Ġ 1 :ĊĊ Ġn ,x =list (map (int ,input (). split ()))ĊĊ Ġif Ġn +x == 0 : break ĊĊ Ġprint (( len ([ 1 Ġfor Ġi Ġin Ġrange ( 3 ,n + 1 ) for Ġj Ġin Ġrange ( 2 ,x -i ) if Ġx -i -j <j <i ])))


Input:
def main():

    from sys import stdin

    input = stdin.readline

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

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

    for i in range(r):

        l[i] -= 1

    d = [[10**8] * n for _ in range(n)]

    for _ in range(m):

        i, j, k = list(map(int, input().split()))

        d[i-1][j-1] = k

        d[j-1][i-1] = k

    # Warshall-Floyd algorithm

    for k in range(n):

        for i in range(n):

            for j in range(n):

                if d[i][j] > d[i][k] + d[k][j]:

                    d[i][j] = d[i][k] + d[k][j]

    # full search

    # 8! = 40320

    from itertools import permutations

    answer = 10**8

    for i in permutations(l):

        ans = 0

        for j in range(r-1):

            ans += d[i[j]][i[j+1]]

        if ans < answer:

            answer = ans

    print(answer)

main()

def Ġmain ():ĊĊ ĠĠĠ Ġfrom Ġsys Ġimport Ġstdin ĊĊ ĠĠĠ Ġinput Ġ= Ġstdin .readline ĊĊĊĊ ĠĠĠ Ġn , Ġm , Ġr Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġl Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (r ):ĊĊ ĠĠĠĠĠĠĠ Ġl [i ] Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġd Ġ= Ġ[[ 1 0 ** 8 ] Ġ* Ġn Ġfor Ġ_ Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġ_ Ġin Ġrange (m ):ĊĊ ĠĠĠĠĠĠĠ Ġi , Ġj , Ġk Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠĠĠĠĠ Ġd [i - 1 ][ j - 1 ] Ġ= Ġk ĊĊ ĠĠĠĠĠĠĠ Ġd [j - 1 ][ i - 1 ] Ġ= Ġk ĊĊĊĊ ĠĠĠ Ġ# ĠWar shall -F loyd Ġalgorithm ĊĊ ĠĠĠ Ġfor Ġk Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġd [i ][ j ] Ġ> Ġd [i ][ k ] Ġ+ Ġd [k ][ j ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġd [i ][ j ] Ġ= Ġd [i ][ k ] Ġ+ Ġd [k ][ j ]ĊĊĊĊ ĠĠĠ Ġ# Ġfull Ġsearch ĊĊ ĠĠĠ Ġ# Ġ 8 ! Ġ= Ġ 4 0 3 2 0 ĊĊ ĠĠĠ Ġfrom Ġitertools Ġimport Ġpermutations ĊĊĊĊ ĠĠĠ Ġanswer Ġ= Ġ 1 0 ** 8 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġpermutations (l ):ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (r - 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġd [i [j ]][ i [j + 1 ]]ĊĊ ĠĠĠĠĠĠĠ Ġif Ġans Ġ< Ġanswer :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġanswer Ġ= Ġans ĊĊĊĊ ĠĠĠ Ġprint (answer )ĊĊĊĊ main ()Ċ


Input:
from collections import Counter

S = input()[::-1]

memo = [0]

d = 0

mod = 2019

for s in S:

    tmp = int(s) * pow(10, d, mod) % mod

    tmp = memo[-1] + tmp

    memo.append(tmp % mod)

    d += 1

c = Counter(memo)

ans = sum(v * (v - 1) // 2 for v in list(c.values()))

print(ans)

from Ġcollections Ġimport ĠCounter ĊĊ S Ġ= Ġinput ()[ ::- 1 ]ĊĊĊĊ memo Ġ= Ġ[ 0 ]ĊĊ d Ġ= Ġ 0 ĊĊ mod Ġ= Ġ 2 0 1 9 ĊĊĊĊ for Ġs Ġin ĠS :ĊĊ ĠĠĠ Ġtmp Ġ= Ġint (s ) Ġ* Ġpow ( 1 0 , Ġd , Ġmod ) Ġ% Ġmod ĊĊ ĠĠĠ Ġtmp Ġ= Ġmemo [- 1 ] Ġ+ Ġtmp ĊĊ ĠĠĠ Ġmemo .append (tmp Ġ% Ġmod )ĊĊ ĠĠĠ Ġd Ġ+= Ġ 1 ĊĊĊĊ c Ġ= ĠCounter (m emo )ĊĊ ans Ġ= Ġsum (v Ġ* Ġ( v Ġ- Ġ 1 ) Ġ// Ġ 2 Ġfor Ġv Ġin Ġlist (c .values ()))ĊĊ print (ans )


Input:
a = input()

print(('A' if not a.islower() else 'a'))

a Ġ= Ġinput ()ĊĊ print ((' A ' Ġif Ġnot Ġa .is lower () Ġelse Ġ' a '))Ċ


Input:
N=int(input())

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

for i in range(N):

  for j in range(1,31):

    if a[i]%(2**j)!=0:

      a[i]=j-1

      break

print((sum(a)))

N =int (input ())ĊĊ a =list (map (int ,input (). split ()))ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ Ġ Ġfor Ġj Ġin Ġrange ( 1 , 3 1 ):ĊĊ ĠĠĠ Ġif Ġa [i ] %( 2 ** j )!= 0 :ĊĊ ĠĠĠĠĠ Ġa [i ]= j - 1 ĊĊ ĠĠĠĠĠ Ġbreak ĊĊ print (( sum (a )))


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

cnt = 0

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

    i = str(i)

    if i[0] == i[-1] and i[1] == i[-2]:

        cnt += 1

print(cnt)

a , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ cnt Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (a , Ġb + 1 ):ĊĊ ĠĠĠ Ġi Ġ= Ġstr (i )ĊĊ ĠĠĠ Ġif Ġi [ 0 ] Ġ== Ġi [- 1 ] Ġand Ġi [ 1 ] Ġ== Ġi [- 2 ]:ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊĊĊ print (cnt )Ċ


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

cnt = 0

for i in range(k + 1):

    for j in range(k + 1):

        if i + j > s:

            break

        elif s - i - j <= k:

            cnt += 1

print(cnt)

k , Ġs Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (k Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (k Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi Ġ+ Ġj Ġ> Ġs :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġs Ġ- Ġi Ġ- Ġj Ġ<= Ġk :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ print (cnt )Ċ


Input:
from collections import Counter

s = input()

mod1 = 673

mod2 = 3

num1 = 0

num2 = 0

li1 = []

li2 = []

pw1 = 10

pw2 = 10

for i, e in enumerate(s, 1):

    num1 *= 10

    num1 += int(e)

    num1 %= mod1

    inv = pow(pw1, mod1 - 2, mod1)

    li1.append(num1 * inv % mod1)

    num2 *= 10

    num2 += int(e)

    num2 %= mod2

    inv = pow(pw2, mod2 - 2, mod2)

    li2.append(num2 * inv % mod2)

    pw1 *= 10

    pw1 %= mod1

    pw2 *= 10

    pw2 %= mod2

li = [0] + [10 * e1 + e2 for e1, e2 in zip(li1, li2)]

c = Counter(li)

ans = 0

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

    ans += v * (v - 1) // 2

print(ans)

from Ġcollections Ġimport ĠCounter ĊĊĊĊ s Ġ= Ġinput ()ĊĊ mod 1 Ġ= Ġ 6 7 3 ĊĊ mod 2 Ġ= Ġ 3 ĊĊĊĊ num 1 Ġ= Ġ 0 ĊĊ num 2 Ġ= Ġ 0 ĊĊ li 1 Ġ= Ġ[]ĊĊ li 2 Ġ= Ġ[]ĊĊ pw 1 Ġ= Ġ 1 0 ĊĊ pw 2 Ġ= Ġ 1 0 ĊĊ for Ġi , Ġe Ġin Ġenumerate (s , Ġ 1 ):ĊĊ ĠĠĠ Ġnum 1 Ġ*= Ġ 1 0 ĊĊ ĠĠĠ Ġnum 1 Ġ+= Ġint (e )ĊĊ ĠĠĠ Ġnum 1 Ġ%= Ġmod 1 ĊĊ ĠĠĠ Ġinv Ġ= Ġpow (p w 1 , Ġmod 1 Ġ- Ġ 2 , Ġmod 1 )ĊĊ ĠĠĠ Ġli 1 .append (num 1 Ġ* Ġinv Ġ% Ġmod 1 )ĊĊĊĊ ĠĠĠ Ġnum 2 Ġ*= Ġ 1 0 ĊĊ ĠĠĠ Ġnum 2 Ġ+= Ġint (e )ĊĊ ĠĠĠ Ġnum 2 Ġ%= Ġmod 2 ĊĊ ĠĠĠ Ġinv Ġ= Ġpow (p w 2 , Ġmod 2 Ġ- Ġ 2 , Ġmod 2 )ĊĊ ĠĠĠ Ġli 2 .append (num 2 Ġ* Ġinv Ġ% Ġmod 2 )ĊĊĊĊ ĠĠĠ Ġpw 1 Ġ*= Ġ 1 0 ĊĊ ĠĠĠ Ġpw 1 Ġ%= Ġmod 1 ĊĊ ĠĠĠ Ġpw 2 Ġ*= Ġ 1 0 ĊĊ ĠĠĠ Ġpw 2 Ġ%= Ġmod 2 ĊĊĊĊ li Ġ= Ġ[ 0 ] Ġ+ Ġ[ 1 0 Ġ* Ġe 1 Ġ+ Ġe 2 Ġfor Ġe 1 , Ġe 2 Ġin Ġzip (li 1 , Ġli 2 )]ĊĊ c Ġ= ĠCounter (li )ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġv Ġin Ġlist (c .values ()) :ĊĊ ĠĠĠ Ġans Ġ+= Ġv Ġ* Ġ( v Ġ- Ġ 1 ) Ġ// Ġ 2 ĊĊĊĊ print (ans )Ċ


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

c = int(c*2)

m = float('inf')

for i in range(10**5+1):

    m = min(m, a*max(0, x-i)+b*max(0,y-i)+c*i)

print(m)

a , Ġb , Ġc , Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split (' Ġ' )) )ĊĊĊĊ c Ġ= Ġint (c * 2 )ĊĊ m Ġ= Ġfloat (' inf ')ĊĊ for Ġi Ġin Ġrange ( 1 0 ** 5 + 1 ):ĊĊ ĠĠĠ Ġm Ġ= Ġmin (m , Ġa * max ( 0 , Ġx -i )+ b * max ( 0 ,y -i )+ c *i )ĊĊ print (m )


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

s=list(range(l,r+1))[:2019]

print((min(i*j%2019for i in s for j in s if i<j)))

l ,r =list (map (int ,input (). split ()))ĊĊ s =list (range (l ,r + 1 )) [: 2 0 1 9 ]ĊĊ print (( min (i *j % 2 0 1 9 for Ġi Ġin Ġs Ġfor Ġj Ġin Ġs Ġif Ġi <j )))


Input:
s = input()

cnt = 0

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

    if s[i] == 'W' and s[i + 1] == 'B':

        cnt += 1

    if s[i] == 'B' and s[i + 1] == 'W':

        cnt += 1

print(cnt)

s Ġ= Ġinput ()ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (len (s ) Ġ- Ġ 1 ):ĊĊ ĠĠĠ Ġif Ġs [i ] Ġ== Ġ' W ' Ġand Ġs [i Ġ+ Ġ 1 ] Ġ== Ġ' B ':ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġs [i ] Ġ== Ġ' B ' Ġand Ġs [i Ġ+ Ġ 1 ] Ġ== Ġ' W ':ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ print (cnt )


Input:
import math

mod = 10 ** 9 + 7

n = int(input())

print((math.factorial(n) % mod))

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


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

count = 0

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

    if(str(i) == str(i)[::-1]):

        count += 1

print(count)

A , ĠB Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ count Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (A , ĠB + 1 ):ĊĊ ĠĠĠ Ġif (str (i ) Ġ== Ġstr (i )[ ::- 1 ]) :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ print (count )Ċ


Input:
import math

import string

def readints():

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

def nCr(n, r):

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

def has_duplicates2(seq):

    seen = []

    for item in seq:

        if not(item in seen):

            seen.append(item)

    return len(seq) != len(seen)

def divisor(n):

    divisor = []

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

        if n % i == 0:

            divisor.append(i)

    return divisor

# coordinates

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

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

n = int(input())

a = readints()

def func(l):

    if len(l) == n:

        for i in range(len(l)):

            if l[i] % 2 == 0:

                return 1

        return 0

    return func(l+[(a[len(l)])])+func(l+[(a[len(l)]-1)])+func(l+[(a[len(l)]+1)])

print((func([])))

import Ġmath ĊĊ import Ġstring ĊĊĊĊĊĊ def Ġread ints ():ĊĊ ĠĠĠ Ġreturn Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊĊĊ def Ġn Cr (n , Ġr ):ĊĊ ĠĠĠ Ġreturn Ġmath .factor ial (n )// ( math .factor ial (n -r )* math .factor ial (r )) ĊĊĊĊĊĊ def Ġhas _duplicates 2 (seq ):ĊĊ ĠĠĠ Ġseen Ġ= Ġ[]ĊĊ ĠĠĠ Ġfor Ġitem Ġin Ġseq :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġnot (item Ġin Ġseen ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġseen .append (item )ĊĊ ĠĠĠ Ġreturn Ġlen (seq ) Ġ!= Ġlen (se en )ĊĊĊĊĊĊ def Ġdivisor (n ):ĊĊ ĠĠĠ Ġdivisor Ġ= Ġ[]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġn + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdivisor .append (i )ĊĊ ĠĠĠ Ġreturn Ġdivisor ĊĊĊĊĊĊ # Ġcoordinates ĊĊ dx Ġ= Ġ[- 1 , Ġ- 1 , Ġ- 1 , Ġ 0 , Ġ 0 , Ġ 1 , Ġ 1 , Ġ 1 ]ĊĊ dy Ġ= Ġ[- 1 , Ġ 0 , Ġ 1 , Ġ- 1 , Ġ 1 , Ġ- 1 , Ġ 0 , Ġ 1 ]ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ a Ġ= Ġread ints () ĊĊĊĊĊĊ def Ġfunc (l ):ĊĊ ĠĠĠ Ġif Ġlen (l ) Ġ== Ġn :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (len (l )) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġl [i ] Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġ 1 ĊĊĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 0 ĊĊ ĠĠĠ Ġreturn Ġfunc (l + [( a [len (l )]) ])+ func (l + [( a [len (l )] - 1 )]) + func (l + [( a [len (l )] + 1 )] )ĊĊĊĊĊĊ print (( func ([] )))Ċ


Input:
import math

N = int(input())

num = math.factorial(N)

k, r = divmod(num, 10**9 + 7)

print(r)

import Ġmath ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ ĊĊ num Ġ= Ġmath .factor ial (N )ĊĊĊĊ k , Ġr Ġ= Ġdiv mod (num , Ġ 1 0 ** 9 Ġ+ Ġ 7 )ĊĊ print (r )


Input:
def main():

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

    def trial_division(n):

        divs = []

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

            if n % i == 0:

                divs.append(i)

                if i != n//i:

                    divs.append(n//i)

        divs.sort(reverse=True)

        return divs

    divs = trial_division(M)

    for d in divs:

        if d*N <= M:

            return print(d)

if __name__ == '__main__':

    main()

def Ġmain ():ĊĊ ĠĠĠ ĠN , ĠM Ġ= Ġ( int (i ) Ġfor Ġi Ġin Ġinput (). split ())ĊĊ ĊĊ ĠĠĠ Ġdef Ġtrial _div ision (n ):ĊĊ ĠĠĠĠĠĠĠ Ġdiv s Ġ= Ġ[]ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġint (n ** 0 . 5 )+ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġn Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdiv s .append (i )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi Ġ!= Ġn // i :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdiv s .append (n // i )ĊĊ ĠĠĠĠĠĠĠ Ġdiv s .sort (reverse =True )ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġdiv s ĊĊ ĠĠĠ Ġdiv s Ġ= Ġtrial _div ision (M )ĊĊ ĠĠĠ Ġfor Ġd Ġin Ġdiv s :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġd *N Ġ<= ĠM :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġprint (d )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
import math

N = int(input())

C = 10**9 + 7

print((math.factorial(N) % C))

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


Input:
import sys

input = sys.stdin.readline

import bisect

n = int(input())

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

l = int(input())

U = 17

dp = [[0]*n for _ in range(U+1)]

for i, x in enumerate(X):

  t = bisect.bisect_left(X, x+l)

  dp[0][i] = bisect.bisect_right(X, x+l) - 1

for k in range(U):

  for i in range(n):

    dp[k+1][i] = dp[k][dp[k][i]]

def test(x, a, b):

  for i in range(U, -1, -1):

    if x >> i & 1:

      a = dp[i][a]

  return a >= b

def solve(a, b):

  if a > b:

    a, b = b, a

  ng = 0

  ok = n-1

  while ok - ng > 1:

    mid = (ng + ok) // 2

    if test(mid, a, b):

      ok = mid

    else:

      ng = mid

  print(ok)

q = int(input())

for _ in range(q):

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

  a -= 1

  b -= 1

  solve(a, b)

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ import Ġbis ect ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ X Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ l Ġ= Ġint (input ())ĊĊ U Ġ= Ġ 1 7 ĊĊ dp Ġ= Ġ[[ 0 ]* n Ġfor Ġ_ Ġin Ġrange (U + 1 )]ĊĊ for Ġi , Ġx Ġin Ġenumerate (X ):ĊĊ Ġ Ġt Ġ= Ġbis ect .b is ect _left (X , Ġx +l )ĊĊ Ġ Ġdp [ 0 ][ i ] Ġ= Ġbis ect .b is ect _right (X , Ġx +l ) Ġ- Ġ 1 ĊĊ for Ġk Ġin Ġrange (U ):ĊĊ Ġ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġdp [k + 1 ][ i ] Ġ= Ġdp [k ][ dp [k ][ i ]]ĊĊ def Ġtest (x , Ġa , Ġb ):ĊĊ Ġ Ġfor Ġi Ġin Ġrange (U , Ġ- 1 , Ġ- 1 ):ĊĊ ĠĠĠ Ġif Ġx Ġ>> Ġi Ġ& Ġ 1 :ĊĊ ĠĠĠĠĠ Ġa Ġ= Ġdp [i ][ a ]ĊĊ Ġ Ġreturn Ġa Ġ>= Ġb ĊĊ def Ġsolve (a , Ġb ):ĊĊ Ġ Ġif Ġa Ġ> Ġb :ĊĊ ĠĠĠ Ġa , Ġb Ġ= Ġb , Ġa ĊĊ Ġ Ġng Ġ= Ġ 0 ĊĊ Ġ Ġok Ġ= Ġn - 1 ĊĊ Ġ Ġwhile Ġok Ġ- Ġng Ġ> Ġ 1 :ĊĊ ĠĠĠ Ġmid Ġ= Ġ( ng Ġ+ Ġok ) Ġ// Ġ 2 ĊĊ ĠĠĠ Ġif Ġtest (mid , Ġa , Ġb ):ĊĊ ĠĠĠĠĠ Ġok Ġ= Ġmid ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠ Ġng Ġ= Ġmid ĊĊ Ġ Ġprint (ok )ĊĊ q Ġ= Ġint (input ())ĊĊ for Ġ_ Ġin Ġrange (q ):ĊĊ Ġ Ġa , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ Ġ Ġa Ġ-= Ġ 1 ĊĊ Ġ Ġb Ġ-= Ġ 1 ĊĊ Ġ Ġsolve (a , Ġb )


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

arr = [like + i for i in range(n)]

arr.sort(key=lambda x:abs(x))

print((sum(arr[1:])))

n , Ġlike Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ arr Ġ= Ġ[ like Ġ+ Ġi Ġfor Ġi Ġin Ġrange (n )] ĊĊĊĊ arr .sort (key =lambda Ġx : abs (x )) ĊĊĊĊ print (( sum (arr [ 1 :] )))Ċ


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

ans = float('inf')

for i in range(max(X,Y)+1):

    cost = 2 * C * i + max(0,X-i)*A +max(0,Y-i)*B

    ans = min(ans,cost)

print(ans)

A , ĠB , ĠC , ĠX , ĠY Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ans Ġ= Ġfloat (' inf ')ĊĊ for Ġi Ġin Ġrange (max (X ,Y )+ 1 ):ĊĊ ĠĠĠ Ġcost Ġ= Ġ 2 Ġ* ĠC Ġ* Ġi Ġ+ Ġmax ( 0 ,X -i )* A Ġ+ max ( 0 ,Y -i )* B ĊĊ ĠĠĠ Ġans Ġ= Ġmin (ans ,c ost )ĊĊ print (ans )


Input:
#coding: UTF-8

import math

N=int(input())

def prime_list(k):

    lis=[True for i in range(1,k+1)]

    lis[0]=False

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

        j=2

        while j*j<=i:

            if i%j==0:

                lis[i-1]=False

                break

            else:

                j+=1

    return lis

#    print(lis)

def p_fact(k,N):

    plist=prime_list(k)

    lis=[0]*N

    for i in range(0,k):

        n=0

        if plist[i]:

            while k%(i+1)==0:

                n+=1

                k=k/(i+1)

        lis[i]=n

    return lis

out_lis=[0]*N

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

    input_lis=p_fact(i,N)

    out_lis=[out_lis[j]+input_lis[j] for j in range(0,N)]

#print(out_lis)

out=1

for i in range(0,N):

    out=out*(out_lis[i]+1)

print((out%1000000007))

# coding : ĠUTF - 8 ĊĊ import Ġmath ĊĊ N =int (input ())ĊĊ def Ġprime _list (k ):ĊĊ ĠĠĠ Ġlis =[ True Ġfor Ġi Ġin Ġrange ( 1 ,k + 1 )]ĊĊ ĠĠĠ Ġlis [ 0 ]= False ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 2 ,k + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġj = 2 ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġj *j <= i :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi % j == 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġlis [i - 1 ]= False ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġj += 1 ĊĊ ĠĠĠ Ġreturn Ġlis ĊĊ # ĠĠĠ Ġprint (l is )ĊĊ def Ġp _fact (k ,N ):ĊĊ ĠĠĠ Ġplist = prime _list (k )ĊĊ ĠĠĠ Ġlis =[ 0 ]* N ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 0 ,k ):ĊĊ ĠĠĠĠĠĠĠ Ġn = 0 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġplist [i ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġwhile Ġk %( i + 1 )== 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġn += 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġk =k /( i + 1 )ĊĊ ĠĠĠĠĠĠĠ Ġlis [i ]= n ĊĊ ĠĠĠ Ġreturn Ġlis ĊĊ out _l is =[ 0 ]* N ĊĊ for Ġi Ġin Ġrange ( 1 ,N + 1 ):ĊĊ ĠĠĠ Ġinput _l is =p _fact (i ,N )ĊĊ ĠĠĠ Ġout _l is =[ out _l is [j ]+ input _l is [j ] Ġfor Ġj Ġin Ġrange ( 0 ,N )]ĊĊ #print (out _l is )ĊĊ out = 1 ĊĊ for Ġi Ġin Ġrange ( 0 ,N ):ĊĊ ĠĠĠ Ġout =out *( out _l is [i ]+ 1 )ĊĊ print (( out % 1 0 0 0 0 0 0 0 0 7 ))


Input:
import sys

import queue

N = 3

f= ''.join(sys.stdin.readline().split())

f+= ''.join(sys.stdin.readline().split())

f+= ''.join(sys.stdin.readline().split())

dd = [[-1, 0], [0, -1], [1, 0], [0, 1]]

Q = queue.Queue()

V = dict()

Q.put([f,f.index('0'),0])

V[f] = True

while not Q.empty():

    u = Q.get()

    if u[0] == '123456780':  break

    sx, sy = u[1]//N, u[1]%N

    for dx, dy in dd:

        tx, ty = sx+dx, sy+dy

        if tx<0 or ty<0 or tx>=N or ty>=N: continue

        v = u[:]

        n1, n2 = u[1], tx*N+ty

        v[1] = n2

        if n1>n2: n1, n2 = n2, n1

        v[0] = v[0][0:n1]+v[0][n2]+v[0][n1+1:n2]+v[0][n1]+v[0][n2+1:]

        if not V.get(v[0], False):

            V[v[0]] = True

            v[2] += 1

            Q.put(v)

print((u[2]))

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


Input:
def main():

    S = input()

    w1 = 'dream'[::-1]

    w2 = 'dreamer'[::-1]

    w3 = 'erase'[::-1]

    w4 = 'eraser'[::-1]

    # print(w1,w2,w3,w4)

    S = S[::-1]

    # print(S)

    # words = ['dream', 'dreamer', 'erase', 'eraser']

    words = [w1, w2, w3, w4]

    T = ''

    while S != T:

        cand = []

        for w in words:

            new_t = T + w

            cand.append(new_t)

        # print('cand', cand)

        ans = False

        for c in cand:

            if c == S[:len(c)]:

                T = c

                ans = True

        if not ans:

            break

    if S == T:

        print('YES')

    else:

        print("NO")

if __name__ == "__main__":

    main()

def Ġmain ():ĊĊ ĠĠĠ ĠS Ġ= Ġinput ()ĊĊ ĠĠĠ Ġw 1 Ġ= Ġ' dream ' [::- 1 ]ĊĊ ĠĠĠ Ġw 2 Ġ= Ġ' dream er ' [::- 1 ]ĊĊ ĠĠĠ Ġw 3 Ġ= Ġ' erase ' [::- 1 ]ĊĊ ĠĠĠ Ġw 4 Ġ= Ġ' eras er ' [::- 1 ]ĊĊ ĠĠĠ Ġ# Ġprint (w 1 ,w 2 ,w 3 ,w 4 )ĊĊ ĠĠĠ ĠS Ġ= ĠS [::- 1 ]ĊĊ ĠĠĠ Ġ# Ġprint (S )ĊĊĊĊ ĠĠĠ Ġ# Ġwords Ġ= Ġ[' dream ', Ġ' dream er ', Ġ' erase ', Ġ' eras er ']ĊĊ ĠĠĠ Ġwords Ġ= Ġ[ w 1 , Ġw 2 , Ġw 3 , Ġw 4 ]ĊĊ ĠĠĠ ĠT Ġ= Ġ''ĊĊ ĠĠĠ Ġwhile ĠS Ġ!= ĠT :ĊĊ ĠĠĠĠĠĠĠ Ġcand Ġ= Ġ[]ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġw Ġin Ġwords :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġnew _t Ġ= ĠT Ġ+ Ġw ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcand .append (new _t ) ĠĊĊ ĠĠĠĠĠĠĠ Ġ# Ġprint (' c and ', Ġcand )ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġc Ġin Ġcand :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġc Ġ== ĠS [: len (c )] :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠT Ġ= Ġc ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= ĠTrue ĊĊĊĊ ĠĠĠĠĠĠĠ Ġif Ġnot Ġans :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ ĠĠĠ Ġif ĠS Ġ== ĠT :ĊĊ ĠĠĠĠĠĠĠ Ġprint (' YES ')ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint (" NO ")ĊĊ ĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()


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

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

INF = 10**9

dp = [[INF for j in range(401)] for i in range(401)]

dp[0][0] = 0

maxa = maxb = 0

for a,b,c in src:

    for ai in range(maxa,-1,-1):

        for bi in range(maxb,-1,-1):

            dp[ai+a][bi+b] = min(dp[ai+a][bi+b], dp[ai][bi] + c)

    maxa += a

    maxb += b

ans = INF

for i in range(1,401):

    if MA*i > 400 or MB*i > 400: break

    ans = min(ans, dp[MA*i][MB*i])

print((-1 if ans == INF else ans))

N , MA , MB Ġ= Ġlist (map (int ,input (). split ()))ĊĊ src Ġ= Ġ[ tuple (map (int ,input (). split ())) Ġfor Ġi Ġin Ġrange (N )] ĊĊĊĊ INF Ġ= Ġ 1 0 ** 9 ĊĊ dp Ġ= Ġ[[ INF Ġfor Ġj Ġin Ġrange ( 4 0 1 )] Ġfor Ġi Ġin Ġrange ( 4 0 1 )]ĊĊ dp [ 0 ][ 0 ] Ġ= Ġ 0 ĊĊ max a Ġ= Ġmax b Ġ= Ġ 0 ĊĊ for Ġa ,b ,c Ġin Ġsrc :ĊĊ ĠĠĠ Ġfor Ġai Ġin Ġrange (max a ,- 1 ,- 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġbi Ġin Ġrange (max b ,- 1 ,- 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdp [ ai +a ][ bi +b ] Ġ= Ġmin (dp [ ai +a ][ bi +b ], Ġdp [ ai ][ bi ] Ġ+ Ġc )ĊĊ ĠĠĠ Ġmax a Ġ+= Ġa ĊĊ ĠĠĠ Ġmax b Ġ+= Ġb ĊĊĊĊ ans Ġ= ĠINF ĊĊ for Ġi Ġin Ġrange ( 1 , 4 0 1 ):ĊĊ ĠĠĠ Ġif ĠMA *i Ġ> Ġ 4 0 0 Ġor ĠMB *i Ġ> Ġ 4 0 0 : Ġbreak ĊĊ ĠĠĠ Ġans Ġ= Ġmin (ans , Ġdp [ MA *i ][ MB *i ])ĊĊ print ((- 1 Ġif Ġans Ġ== ĠINF Ġelse Ġans ))


Input:
s = input()

a = s.find('A')

z = s[::-1].find('Z')

ans = len(s)-a-z

print(ans)

#print(*ans, sep='\n')

s Ġ= Ġinput ()ĊĊ a Ġ= Ġs .find (' A ')ĊĊ z Ġ= Ġs [::- 1 ]. find (' Z ')ĊĊ ans Ġ= Ġlen (s )- a -z ĊĊĊĊ print (ans )ĊĊĊĊ #print (* ans , Ġsep ='\ n ')


Input: _,t=open(0);n=eval(t.replace(' ','|'));print((len(bin(n&-n))-3))

_, t =open ( 0 ); n = eval (t .replace (' Ġ',' | ')); print (( len (bin (n & - n ))- 3 ))


Input:
import statistics

N = int(input())

A = [int(a)-i-1 for i,a in enumerate(input().split(),1)]

b = statistics.median_low(A)

c = statistics.median_high(A)

d = sum([abs(x-b) for x in A])

e = sum([abs(x-c) for x in A])

print((min(d,e)))

import Ġstatistics ĊĊ N Ġ= Ġint (input ())ĊĊ A Ġ= Ġ[ int (a )- i - 1 Ġfor Ġi ,a Ġin Ġenumerate (input (). split (), 1 )]ĊĊ b Ġ= Ġstatistics .median _low (A )ĊĊ c Ġ= Ġstatistics .median _high (A )ĊĊ d Ġ= Ġsum ([ abs (x -b ) Ġfor Ġx Ġin ĠA ])ĊĊ e Ġ= Ġsum ([ abs (x -c ) Ġfor Ġx Ġin ĠA ])ĊĊ print (( min (d ,e )))


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

c = 0

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

  new = list(reversed(list(str(i))))

  if new == list(str(i)):

    c += 1

print(c)

a ,b Ġ= Ġlist (map (int ,input (). split ()))ĊĊ c Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (a ,b + 1 ):ĊĊ Ġ Ġnew Ġ= Ġlist (re versed (list (str (i ))))ĊĊ Ġ Ġif Ġnew Ġ== Ġlist (str (i )) :ĊĊ ĠĠĠ Ġc Ġ+= Ġ 1 ĊĊ ĠĠĠĠĊĊ ĠĠĠĠĊĊ print (c )


Input:
import sys

input = sys.stdin.readline

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

hole = [0] * (N+1)

for i in range(M):

    hole[int(input())] = 1

if N == 1:

    print((1))

    exit()

if N == 2:

    if hole[1] == 1:

        print((1))

        exit()

    if hole[1] == 0:

        print((2))

        exit()

flg_one = False

flg_two = False

first = 1

second = 2

if hole[1] == 1:

    first = 0

    second = 1

    flg_one = True

if hole[2] == 1:

    first = 1

    second = 0

    flg_two = True

if flg_one and flg_two:

    print((0))

    exit()

for i in range(3,N):

    if hole[i] == 1:

        first = second

        second = 0

        continue

    tmp = first + second

    tmp %= 1000000007

    first = second

    second = tmp

tmp = first + second

tmp %= 1000000007

print(tmp)

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ N , ĠM Ġ= Ġlist (map (int ,input (). split ()))ĊĊ hole Ġ= Ġ[ 0 ] Ġ* Ġ( N + 1 )ĊĊ for Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠ Ġhole [int (input ()) ] Ġ= Ġ 1 ĊĊ if ĠN Ġ== Ġ 1 :ĊĊ ĠĠĠ Ġprint (( 1 ))ĊĊ ĠĠĠ Ġexit ()ĊĊ if ĠN Ġ== Ġ 2 :ĊĊ ĠĠĠ Ġif Ġhole [ 1 ] Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (( 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊ ĠĠĠ Ġif Ġhole [ 1 ] Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (( 2 ))ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊ fl g _one Ġ= ĠFalse ĊĊ fl g _two Ġ= ĠFalse ĊĊ first Ġ= Ġ 1 ĊĊ second Ġ= Ġ 2 ĊĊ if Ġhole [ 1 ] Ġ== Ġ 1 :ĊĊ ĠĠĠ Ġfirst Ġ= Ġ 0 ĊĊ ĠĠĠ Ġsecond Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfl g _one Ġ= ĠTrue ĊĊ if Ġhole [ 2 ] Ġ== Ġ 1 :ĊĊ ĠĠĠ Ġfirst Ġ= Ġ 1 ĊĊ ĠĠĠ Ġsecond Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfl g _two Ġ= ĠTrue ĊĊ if Ġfl g _one Ġand Ġfl g _two :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠ Ġexit ()ĊĊĊĊ for Ġi Ġin Ġrange ( 3 ,N ):ĊĊ ĠĠĠ Ġif Ġhole [i ] Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġfirst Ġ= Ġsecond ĊĊ ĠĠĠĠĠĠĠ Ġsecond Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġtmp Ġ= Ġfirst Ġ+ Ġsecond ĊĊ ĠĠĠ Ġtmp Ġ%= Ġ 1 0 0 0 0 0 0 0 0 7 ĊĊ ĠĠĠ Ġfirst Ġ= Ġsecond ĊĊ ĠĠĠ Ġsecond Ġ= Ġtmp ĊĊ tmp Ġ= Ġfirst Ġ+ Ġsecond ĊĊ tmp Ġ%= Ġ 1 0 0 0 0 0 0 0 0 7 ĊĊ print (tmp )


Input:
#!usr/bin/env python3

from collections import defaultdict

from collections import deque

from heapq import heappush, heappop

import sys

import math

import bisect

import random

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

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

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

def S(): return list(sys.stdin.readline())[:-1]

def IR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = I()

    return l

def LIR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = LI()

    return l

def SR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = S()

    return l

def LSR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = SR()

    return l

mod = 1000000007

#A

def A():

    s = S()

    t = S()

    if s+t == t[::-1]+s[::-1]:

        print("YES")

    else:

        print("NO")

#B

def B():

    n = I()

    for i in range(int(n**0.5)+2)[::-1]:

        if i*i <= n:

            print((i*i))

            quit()

#C

def C():

    n = I()

    a = LI()

    b = LI()

    c = LI()

    q = [0 for i in range(n)]

    ans = 0

    a.sort()

    b.sort()

    c.sort()

    for i in range(n):

        j = bisect.bisect_left(a,b[i])

        q[i] = j

    for i in range(n-1):

        q[i+1] += q[i]

    q.insert(0,0)

    for i in range(n):

        j = bisect.bisect_left(b,c[i])

        ans += q[j]

    print(ans)

#D

def D():

    def dijkstra():

        d = [float("inf") for i in range(k)]

        q = [[0,1]]

        d[1] = 0

        while q:

            dx,x = heappop(q)

            for y,dy in v[x]:

                if d[y] > dx+dy:

                    d[y] = dx+dy

                    heappush(q,[d[y],y])

        print((d[0]+1))

    k = I()

    if k == 1:

        print((1))

        quit()

    v = [[] for i in range(k)]

    for i in range(1,k):

        v[i].append([(i+1)%k,1])

        v[i].append([i*10%k,0])

    dijkstra()

#E

def E():

    return

#F

def F():

    return

#G

def G():

    return

#H

def H():

    return

#Solve

if __name__ == "__main__":

    D()

#! usr /bin /env Ġpython 3 ĊĊ from Ġcollections Ġimport Ġdefaultdict ĊĊ from Ġcollections Ġimport Ġdeque ĊĊ from Ġheapq Ġimport Ġhe app ush , Ġhe app op ĊĊ import Ġsys ĊĊ import Ġmath ĊĊ import Ġbis ect ĊĊ import Ġrandom ĊĊ def ĠLI (): Ġreturn Ġlist (map (int , Ġsys .stdin .readline (). split ()))ĊĊ def ĠI (): Ġreturn Ġint (sys .stdin .readline ())ĊĊ def ĠLS (): return Ġlist (map (list , Ġsys .stdin .readline (). split ()))ĊĊ def ĠS (): Ġreturn Ġlist (sys .stdin .readline ()) [:- 1 ]ĊĊ def ĠIR (n ):ĊĊ ĠĠĠ Ġl Ġ= Ġ[ None Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): l [i ] Ġ= ĠI ()ĊĊ ĠĠĠ Ġreturn Ġl ĊĊ def ĠL IR (n ):ĊĊ ĠĠĠ Ġl Ġ= Ġ[ None Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): l [i ] Ġ= ĠLI ()ĊĊ ĠĠĠ Ġreturn Ġl ĊĊ def ĠSR (n ):ĊĊ ĠĠĠ Ġl Ġ= Ġ[ None Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): l [i ] Ġ= ĠS ()ĊĊ ĠĠĠ Ġreturn Ġl ĊĊ def ĠL SR (n ):ĊĊ ĠĠĠ Ġl Ġ= Ġ[ None Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): l [i ] Ġ= ĠSR ()ĊĊ ĠĠĠ Ġreturn Ġl ĊĊ mod Ġ= Ġ 1 0 0 0 0 0 0 0 0 7 ĊĊĊĊ # A ĊĊ def ĠA ():ĊĊ ĠĠĠ Ġs Ġ= ĠS ()ĊĊ ĠĠĠ Ġt Ġ= ĠS ()ĊĊ ĠĠĠ Ġif Ġs +t Ġ== Ġt [::- 1 ]+ s [::- 1 ]:ĊĊ ĠĠĠĠĠĠĠ Ġprint (" YES ")ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint (" NO ")ĊĊ ĊĊ # B ĊĊ def ĠB ():ĊĊ ĠĠĠ Ġn Ġ= ĠI ()ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (int (n ** 0 . 5 )+ 2 )[ ::- 1 ]:ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi *i Ġ<= Ġn :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (( i *i ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġquit ()ĊĊ # C ĊĊ def ĠC ():ĊĊ ĠĠĠ Ġn Ġ= ĠI ()ĊĊ ĠĠĠ Ġa Ġ= ĠLI ()ĊĊ ĠĠĠ Ġb Ġ= ĠLI ()ĊĊ ĠĠĠ Ġc Ġ= ĠLI ()ĊĊ ĠĠĠ Ġq Ġ= Ġ[ 0 Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġa .sort ()ĊĊ ĠĠĠ Ġb .sort ()ĊĊ ĠĠĠ Ġc .sort ()ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= Ġbis ect .b is ect _left (a ,b [i ])ĊĊ ĠĠĠĠĠĠĠ Ġq [i ] Ġ= Ġj ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n - 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġq [i + 1 ] Ġ+= Ġq [i ]ĊĊ ĠĠĠ Ġq .insert ( 0 , 0 )ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= Ġbis ect .b is ect _left (b ,c [i ])ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġq [j ]ĊĊ ĠĠĠ Ġprint (ans )ĊĊ # D ĊĊ def ĠD ():ĊĊ ĠĠĠ Ġdef Ġdi jk stra ():ĊĊ ĠĠĠĠĠĠĠ Ġd Ġ= Ġ[ float (" inf ") Ġfor Ġi Ġin Ġrange (k )]ĊĊ ĠĠĠĠĠĠĠ Ġq Ġ= Ġ[[ 0 , 1 ]]ĊĊ ĠĠĠĠĠĠĠ Ġd [ 1 ] Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġq :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdx ,x Ġ= Ġhe app op (q )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġy , dy Ġin Ġv [x ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġd [y ] Ġ> Ġdx + dy :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġd [y ] Ġ= Ġdx + dy ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġhe app ush (q ,[ d [y ], y ])ĊĊ ĠĠĠĠĠĠĠ Ġprint (( d [ 0 ]+ 1 ))ĊĊ ĠĠĠ Ġk Ġ= ĠI ()ĊĊ ĠĠĠ Ġif Ġk Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (( 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġquit ()ĊĊ ĠĠĠ Ġv Ġ= Ġ[[] Ġfor Ġi Ġin Ġrange (k )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 ,k ):ĊĊ ĠĠĠĠĠĠĠ Ġv [i ]. append ([( i + 1 )% k , 1 ])ĊĊ ĠĠĠĠĠĠĠ Ġv [i ]. append ([ i * 1 0 % k , 0 ])ĊĊ ĠĠĠ Ġdi jk stra ()ĊĊ # E ĊĊ def ĠE ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # F ĊĊ def ĠF ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # G ĊĊ def ĠG ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # H ĊĊ def ĠH ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # S olve ĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ ĠD ()Ċ


Input:
import math

x = int(input())

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

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


Input:
# coding: utf-8

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

    k = int(args[0])

    l = 9*(k//7 if k % 7 == 0 else k)

    if l % 2 == 0 or l % 5 == 0:

        return '-1'

    r = phi = l

    for i in range(2, int(-pow(l, 1/2))):

        if r % i == 0:

            phi = phi//i*(i-1)

            while r % i:

                r //= i

    a = 10 % l

    ret = 1

    while(a != 1):

        a = a*10 % l

        ret += 1

        if phi < ret:

            ret = -1

            break

    return str(ret)

if __name__ == "__main__":

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

# Ġcoding : Ġutf - 8 ĊĊĊĊĊĊ def Ġsolve (* args : Ġstr ) Ġ-> Ġstr :ĊĊ ĠĠĠ Ġk Ġ= Ġint (args [ 0 ])ĊĊ ĊĊ ĠĠĠ Ġl Ġ= Ġ 9 *( k // 7 Ġif Ġk Ġ% Ġ 7 Ġ== Ġ 0 Ġelse Ġk )ĊĊ ĠĠĠ Ġif Ġl Ġ% Ġ 2 Ġ== Ġ 0 Ġor Ġl Ġ% Ġ 5 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ'- 1 'ĊĊĊĊ ĠĠĠ Ġr Ġ= Ġphi Ġ= Ġl ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 2 , Ġint (- pow (l , Ġ 1 / 2 ))) :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġr Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġphi Ġ= Ġphi // i *( i - 1 )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġwhile Ġr Ġ% Ġi :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġr Ġ//= Ġi ĊĊĊĊ ĠĠĠ Ġa Ġ= Ġ 1 0 Ġ% Ġl ĊĊ ĠĠĠ Ġret Ġ= Ġ 1 ĊĊ ĠĠĠ Ġwhile (a Ġ!= Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġa Ġ= Ġa * 1 0 Ġ% Ġl ĊĊ ĠĠĠĠĠĠĠ Ġret Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġphi Ġ< Ġret :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġret Ġ= Ġ- 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ ĠĠĠ Ġreturn Ġstr (ret )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġprint (( solve (*( open ( 0 ). read (). split lines ())) ))Ċ


Input:
import sys

sys.setrecursionlimit(100000)

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

fib={0:0,1:1,2:1}

for i in range(3,100003):

    fib[i]=fib[i-1]+fib[i-2]

  #  fib.append(fib[i-1]+fib[i-2])

n,m=intinput()

mod=10**9+7

a=[int(sys.stdin.readline()) for _ in range(m)]

if m!=0:

    l=[a[0]]

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

        l.append(a[i+1]-a[i]-1)

    l.append(n-a[-1])

    k=1

    for i in l:

        k=fib[i]*k%mod

    print((k%mod))

else:

    print((fib[n+1]%mod))

import Ġsys ĊĊ sys .set rec ursion limit ( 1 0 0 0 0 0 )ĊĊĊĊ def Ġint input (): Ġreturn Ġlist (map (int , sys .stdin .readline (). split ())) ĊĊĊĊ fib ={ 0 : 0 , 1 : 1 , 2 : 1 }ĊĊ for Ġi Ġin Ġrange ( 3 , 1 0 0 0 0 3 ):ĊĊ ĠĠĠ Ġfib [i ]= fib [i - 1 ]+ fib [i - 2 ]ĊĊ Ġ Ġ# Ġ Ġfib .append (f ib [i - 1 ]+ fib [i - 2 ])ĊĊ ĊĊ n ,m =int input ()ĊĊ mod = 1 0 ** 9 + 7 ĊĊ a =[ int (sys .stdin .readline ()) Ġfor Ġ_ Ġin Ġrange (m )]ĊĊ if Ġm != 0 :ĊĊ ĠĠĠ Ġl =[ a [ 0 ]]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (len (a )- 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġl .append (a [i + 1 ]- a [i ]- 1 )ĊĊ ĠĠĠ Ġl .append (n -a [- 1 ])ĊĊ ĠĠĠ Ġk = 1 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġl :ĊĊ ĠĠĠĠĠĠĠ Ġk =f ib [i ]* k % mod ĊĊ ĠĠĠ Ġprint (( k % mod ))ĊĊ else :ĊĊ ĠĠĠ Ġprint (( fib [n + 1 ]% mod ))


Input:
N = int(input())

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

answer = 10 ** 9

for i in range(1,101):

    tmp = 0

    for a in A:

        tmp += abs(a-i) ** 2

    answer = min(answer,tmp)

print(answer)

N Ġ= Ġint (input ())ĊĊ A Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ answer Ġ= Ġ 1 0 Ġ** Ġ 9 ĊĊ for Ġi Ġin Ġrange ( 1 , 1 0 1 ):ĊĊ ĠĠĠ Ġtmp Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġa Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġtmp Ġ+= Ġabs (a -i ) Ġ** Ġ 2 ĊĊ ĠĠĠ Ġanswer Ġ= Ġmin (answer ,tmp )ĊĊ print (answer )


Input:
"""

challenge case

in:

3

1 3

2 3

out:

1

1

1

"""

from collections import deque

def main():

	N, *AB = list(map(int, open(0).read().split()))

	B = AB[1::2]

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

	for a, b in zip(*[iter(AB)] * 2):

		E[a] += b,

	Q = deque([1])

	C = [0] * (N + 1)

	while Q:

		v = Q.popleft()

		c = 0

		for u in E[v]:

			c += 1 + (c + 1 == C[v])

			C[u] = c

			Q += u,

	print((max(C)))

	for b in B:

		print((C[b]))

main()

"""ĊĊ challenge Ġcase ĊĊĊĊ in :ĊĊ 3 ĊĊ 1 Ġ 3 ĊĊ 2 Ġ 3 ĊĊĊĊ out :ĊĊ 1 ĊĊ 1 ĊĊ 1 ĊĊ """ ĊĊĊĊ from Ġcollections Ġimport Ġdeque ĊĊĊĊ def Ġmain ():ĊĊ ĉN , Ġ* AB Ġ= Ġlist (map (int , Ġopen ( 0 ). read (). split ()))ĊĊ ĉB Ġ= ĠAB [ 1 :: 2 ]ĊĊĊĊ ĉE Ġ= Ġ[[] Ġfor Ġ_ Ġin Ġrange (N Ġ+ Ġ 1 )]ĊĊ ĉfor Ġa , Ġb Ġin Ġzip (* [ iter ( AB )] Ġ* Ġ 2 ):ĊĊ ĉ ĉE [a ] Ġ+= Ġb ,ĊĊĊĊ ĉQ Ġ= Ġdeque ([ 1 ])ĊĊ ĉC Ġ= Ġ[ 0 ] Ġ* Ġ( N Ġ+ Ġ 1 )ĊĊ ĉwhile ĠQ :ĊĊ ĉ ĉv Ġ= ĠQ .p opleft ()ĊĊ ĉ ĉc Ġ= Ġ 0 ĊĊ ĉ ĉfor Ġu Ġin ĠE [v ]:ĊĊ ĉĉ ĉc Ġ+= Ġ 1 Ġ+ Ġ( c Ġ+ Ġ 1 Ġ== ĠC [v ])ĊĊ ĉĉ ĉC [u ] Ġ= Ġc ĊĊ ĉĉ ĉQ Ġ+= Ġu ,ĊĊĊĊ ĉprint (( max (C )))ĊĊ ĉfor Ġb Ġin ĠB :ĊĊ ĉ ĉprint (( C [b ])) ĊĊĊĊ main ()


Input:
import sys

input = sys.stdin.buffer.readline

from collections import defaultdict

import copy

def main():

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

    d = defaultdict(int)

    MOD = 10**9+7

    R = 10**5+100

    fac = [0 for _ in range(R+1)]

    fac[0],fac[1] = 1,1

    inv = copy.deepcopy(fac)

    invfac = copy.deepcopy(fac)

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

        fac[i] = (fac[i-1]*i)%MOD

        inv[i] = MOD-(MOD//i)*inv[MOD%i]%MOD

        invfac[i] = (invfac[i-1]*inv[i])%MOD

    def coef(x,y):

        num = (((fac[x+y]*invfac[y])%MOD)*invfac[x]%MOD)

        return num

    while M%2 == 0:

        d[2] += 1

        M //= 2

    f = 3

    while f ** 2 <= M:

        if M % f == 0:

            d[f] += 1

            M //= f

        else:

            f += 2

    if M != 1:

        d[M] += 1

    l = list(d.values())

    ans = 1

    for num in l:

        ans *= coef(num,N-1)

        ans %= MOD

    print(ans)

if __name__ == "__main__":

    main()

import Ġsys ĊĊ input Ġ= Ġsys .stdin .buffer .readline ĊĊ from Ġcollections Ġimport Ġdefaultdict ĊĊ import Ġcopy ĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠN ,M Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġd Ġ= Ġdefaultdict (int )ĊĊ ĠĠĠ ĠMOD Ġ= Ġ 1 0 ** 9 + 7 ĊĊ ĠĠĠ ĠR Ġ= Ġ 1 0 ** 5 + 1 0 0 ĊĊ ĠĠĠ Ġfac Ġ= Ġ[ 0 Ġfor Ġ_ Ġin Ġrange (R + 1 )]ĊĊ ĠĠĠ Ġfac [ 0 ], fac [ 1 ] Ġ= Ġ 1 , 1 ĊĊ ĠĠĠ Ġinv Ġ= Ġcopy .deepcopy (f ac )ĊĊ ĠĠĠ Ġinv fac Ġ= Ġcopy .deepcopy (f ac )ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 2 ,R + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġfac [i ] Ġ= Ġ( fac [i - 1 ]* i )% MOD ĊĊ ĠĠĠĠĠĠĠ Ġinv [i ] Ġ= ĠMOD -( MOD // i )* inv [ MOD %i ]% MOD ĊĊ ĠĠĠĠĠĠĠ Ġinv fac [i ] Ġ= Ġ( inv fac [i - 1 ]* inv [i ]) % MOD ĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠ Ġdef Ġcoef (x ,y ):ĊĊ ĠĠĠĠĠĠĠ Ġnum Ġ= Ġ((( fac [x +y ]* inv fac [y ]) % MOD )* inv fac [x ]% MOD )ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġnum ĊĊĊĊ ĠĠĠ Ġwhile ĠM % 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġd [ 2 ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ ĠM Ġ//= Ġ 2 ĊĊ ĠĠĠ Ġf Ġ= Ġ 3 ĊĊ ĠĠĠ Ġwhile Ġf Ġ** Ġ 2 Ġ<= ĠM :ĊĊ ĠĠĠĠĠĠĠ Ġif ĠM Ġ% Ġf Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġd [f ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠM Ġ//= Ġf ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġf Ġ+= Ġ 2 ĊĊ ĠĠĠ Ġif ĠM Ġ!= Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġd [M ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġl Ġ= Ġlist (d .values ())ĊĊ ĠĠĠ Ġans Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġnum Ġin Ġl :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ*= Ġcoef (num ,N - 1 )ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ%= ĠMOD ĊĊ ĠĠĠĠĠĠĠĠĊĊ ĠĠĠ Ġprint (ans )ĊĊ ĠĠĠĠĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()


Input:
from collections import Counter

d={chr(i):0 for i in range(2)}

s=Counter(input())

d=d.update(s)

print((min(s["0"],s["1"])*2))

from Ġcollections Ġimport ĠCounter ĊĊ d ={ chr (i ): 0 Ġfor Ġi Ġin Ġrange ( 2 )}ĊĊ s = Counter (input ())ĊĊ d =d .update (s )ĊĊ print (( min (s [" 0 "], s [" 1 "] )* 2 ))


Input:
from functools import reduce
def f(a,b): return [Card[a][0], Card[b][1]]

n = int(input())

Card = [[] for _ in [0]*n]

Cost = {}

for i in range(n):

  Card[i] = list(map(int, input().split()))

  Cost[(i, i)] = 0

for i in range(1, n):

  for j in range(0, n-i):

    a = j+i

    Cost[(j, a)] = min([reduce(lambda a,b: a*b, f(j, k) + f(k+1, a)) + Cost[(j, k)] + Cost[(k+1, a)] for k in range(j, j+i)])

print(Cost[0, n-1])

from Ġfunctools Ġimport Ġreduce Ċ def Ġf (a ,b ): Ġreturn Ġ[ Card [a ][ 0 ], ĠCard [b ][ 1 ]]ĊĊ n Ġ= Ġint (input ())ĊĊ Card Ġ= Ġ[[] Ġfor Ġ_ Ġin Ġ[ 0 ]* n ]ĊĊ Cost Ġ= Ġ{}ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ Ġ ĠCard [i ] Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ Ġ ĠCost [( i , Ġi )] Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 , Ġn ):ĊĊ Ġ Ġfor Ġj Ġin Ġrange ( 0 , Ġn -i ):ĊĊ ĠĠĠ Ġa Ġ= Ġj +i ĊĊ ĠĠĠ ĠCost [( j , Ġa )] Ġ= Ġmin ([ reduce (lambda Ġa ,b : Ġa *b , Ġf (j , Ġk ) Ġ+ Ġf (k + 1 , Ġa )) Ġ+ ĠCost [( j , Ġk )] Ġ+ ĠCost [( k + 1 , Ġa )] Ġfor Ġk Ġin Ġrange (j , Ġj +i )])ĊĊ print (C ost [ 0 , Ġn - 1 ])


Input:
def cmb(n, r, mod):

    if ( r<0 or r>n ):

        return 0

    r = min(r, n-r)

    return g1[n] * g2[r] * g2[n-r] % mod

A=2*10**5

mod = 10**9+7

g1 = [1, 1]

g2 = [1, 1]

inverse = [0, 1]

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

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

    inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )

    g2.append( (g2[-1] * inverse[-1]) % mod )

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

keisuu=cmb(N*M-2,K-2,mod)

sum_=0

for i in range(N):

    a=min(abs(i),abs(N-i-1))

    b=max(abs(i),abs(N-i-1))

    sum_+=(M**2)*((a*(a+1)//2)+(b*(b+1)//2))

for i in range(M):

    a=min(abs(i),abs(M-i-1))

    b=max(abs(i),abs(M-i-1))

    sum_+=(N**2)*((a*(a+1)//2)+(b*(b+1)//2))

print(((keisuu * (sum_//2))%mod))

def Ġcmb (n , Ġr , Ġmod ):ĊĊ ĠĠĠ Ġif Ġ( Ġr < 0 Ġor Ġr >n Ġ):ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 0 ĊĊ ĠĠĠ Ġr Ġ= Ġmin (r , Ġn -r )ĊĊ ĠĠĠ Ġreturn Ġg 1 [n ] Ġ* Ġg 2 [r ] Ġ* Ġg 2 [n -r ] Ġ% Ġmod ĊĊĊĊ A = 2 * 1 0 ** 5 ĊĊ mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊ g 1 Ġ= Ġ[ 1 , Ġ 1 ]ĊĊ g 2 Ġ= Ġ[ 1 , Ġ 1 ]ĊĊ inverse Ġ= Ġ[ 0 , Ġ 1 ]ĊĊĊĊ for Ġi Ġin Ġrange ( Ġ 2 , ĠA Ġ+ Ġ 1 Ġ):ĊĊ ĠĠĠ Ġg 1 .append ( Ġ( Ġg 1 [- 1 ] Ġ* Ġi Ġ) Ġ% Ġmod Ġ)ĊĊ ĠĠĠ Ġinverse .append ( Ġ( Ġ- inverse [ mod Ġ% Ġi ] Ġ* Ġ( mod // i ) Ġ) Ġ% Ġmod Ġ)ĊĊ ĠĠĠ Ġg 2 .append ( Ġ( g 2 [- 1 ] Ġ* Ġinverse [- 1 ]) Ġ% Ġmod Ġ)ĊĊ ĊĊ N ,M ,K =list (map (int ,input (). split ()))ĊĊ ke is uu =c mb (N *M - 2 ,K - 2 , mod )ĊĊĊĊ sum _= 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġa =min (abs (i ), abs (N -i - 1 ))ĊĊ ĠĠĠ Ġb =max (abs (i ), abs (N -i - 1 ))ĊĊ ĠĠĠ Ġsum _ +=( M ** 2 )* (( a *( a + 1 )// 2 )+( b *( b + 1 )// 2 ))ĊĊ for Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠ Ġa =min (abs (i ), abs (M -i - 1 ))ĊĊ ĠĠĠ Ġb =max (abs (i ), abs (M -i - 1 ))ĊĊ ĠĠĠ Ġsum _ +=( N ** 2 )* (( a *( a + 1 )// 2 )+( b *( b + 1 )// 2 ))ĊĊ print ((( ke is uu Ġ* Ġ( sum _ // 2 )) % mod ))


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

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

a.append(a[0]+k)

longd=0

for i in range(n):

    tmp=abs(a[i+1]-a[i])

    longd=max(longd,tmp)

print((k-longd))

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


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

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

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

def ism():return list(map(str,input().split()))

def isl():return list(map(str,input().split()))

n = ii()

D = iil()

ans = 0

for i in range(n):

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

#        print(i,j)

        ans += D[i]*D[j]

print(ans)

def Ġii (): return Ġint (input ())ĊĊ def Ġi im (): return Ġlist (map (int ,input (). split ()))ĊĊ def Ġi il (): return Ġlist (map (int ,input (). split ()))ĊĊ def Ġis m (): return Ġlist (map (str ,input (). split ()))ĊĊ def Ġisl (): return Ġlist (map (str ,input (). split ())) ĊĊĊĊ n Ġ= Ġii ()ĊĊ D Ġ= Ġi il ()ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (i + 1 ,n ):ĊĊ # ĠĠĠĠĠĠĠ Ġprint (i ,j )ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= ĠD [i ]* D [j ] ĠĊĊ print (ans )


Input:
S = input()

K = int(input())

a = list(set(S))

a.sort()

k = []

l = 0

while l < len(a):

    for i in range(len(S)):

        if S[i] == a[l]:

            for j in range(1,6):

                if i+j <= len(S):

                    k.append(S[i:i+j])

                else:

                    break

    l += 1

k = list(set(k))

k.sort()

print((k[K-1]))

S Ġ= Ġinput ()ĊĊ K Ġ= Ġint (input ())ĊĊ a Ġ= Ġlist (set (S ))ĊĊ a .sort ()ĊĊĊĊ k Ġ= Ġ[]ĊĊ l Ġ= Ġ 0 ĊĊ while Ġl Ġ< Ġlen (a ):ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (len (S )) :ĊĊ ĠĠĠĠĠĠĠ Ġif ĠS [i ] Ġ== Ġa [l ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 , 6 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi +j Ġ<= Ġlen (S ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġk .append (S [i :i +j ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġl Ġ+= Ġ 1 ĊĊĊĊ k Ġ= Ġlist (set (k ))ĊĊ k .sort ()ĊĊ print (( k [K - 1 ]))


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

l = len(s)

c = [0] * 2019

c[0] = 1

ten = 1

mod = 0

ans = 0

for i in range(l):

    mod = (mod + int(s[i]) * ten) % 2019

    ten = ten * 10 % 2019

    c[mod] += 1

for i in c:

    ans += i * (i - 1) // 2

print(ans)

s Ġ= Ġinput ()[ ::- 1 ]ĊĊ l Ġ= Ġlen (s )ĊĊ c Ġ= Ġ[ 0 ] Ġ* Ġ 2 0 1 9 ĊĊ c [ 0 ] Ġ= Ġ 1 ĊĊ ten Ġ= Ġ 1 ĊĊ mod Ġ= Ġ 0 ĊĊ ans Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (l ):ĊĊ ĠĠĠ Ġmod Ġ= Ġ( mod Ġ+ Ġint (s [i ]) Ġ* Ġten ) Ġ% Ġ 2 0 1 9 ĊĊ ĠĠĠ Ġten Ġ= Ġten Ġ* Ġ 1 0 Ġ% Ġ 2 0 1 9 ĊĊ ĠĠĠ Ġc [ mod ] Ġ+= Ġ 1 ĊĊĊĊ for Ġi Ġin Ġc :ĊĊ ĠĠĠ Ġans Ġ+= Ġi Ġ* Ġ( i Ġ- Ġ 1 ) Ġ// Ġ 2 ĊĊĊĊ print (ans )


Input:
S=input()

print((S.rfind('Z')-S.find('A')+1))

S =input ()ĊĊ print (( S .r find (' Z ') - S .find (' A ')+ 1 ))


Input:
#!usr/bin/env python3

from collections import defaultdict

from collections import deque

from heapq import heappush, heappop

import sys

import math

import bisect

import random

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

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

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

def S(): return list(sys.stdin.readline())[:-1]

def IR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = I()

    return l

def LIR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = LI()

    return l

def SR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = S()

    return l

def LSR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = LS()

    return l

sys.setrecursionlimit(1000000)

mod = 1000000007

#A

def A():

    return

#B

def B():

    return

#C

def C():

    return

#D

def D():

    return

#E

def E():

    return

#F

def F():

    a,b,c,X,Y = LI()

    ans = float("inf")

    for z in range(300001):

        if z%2 == 0:

            m = c*z

            x = z//2

            y = z//2

            m += a*max(0,X-x)

            m += b*max(0,Y-y)

            if m < ans:

                ans = m

    print(ans)

    return

#G

def G():

    n = I()

    x = LI()

    f = [(i,x[i]) for i in range(n)]

    f.sort(key = lambda x:x[1])

    g = [(f[i][0],i) for i in range(n)]

    g.sort(key = lambda x:x[0])

    for i in range(n):

        if g[i][1] < n//2:

            print((f[n//2][1]))

        else:

            print((f[n//2-1][1]))

    return

#H

def H():

    return

#I

def I_():

    return

#J

def J():

    return

#Solve

if __name__ == "__main__":

    F()

#! usr /bin /env Ġpython 3 ĊĊ from Ġcollections Ġimport Ġdefaultdict ĊĊ from Ġcollections Ġimport Ġdeque ĊĊ from Ġheapq Ġimport Ġhe app ush , Ġhe app op ĊĊ import Ġsys ĊĊ import Ġmath ĊĊ import Ġbis ect ĊĊ import Ġrandom ĊĊ def ĠLI (): Ġreturn Ġlist (map (int , Ġsys .stdin .readline (). split ()))ĊĊ def ĠI (): Ġreturn Ġint (sys .stdin .readline ())ĊĊ def ĠLS (): return Ġlist (map (list , Ġsys .stdin .readline (). split ()))ĊĊ def ĠS (): Ġreturn Ġlist (sys .stdin .readline ()) [:- 1 ]ĊĊ def ĠIR (n ):ĊĊ ĠĠĠ Ġl Ġ= Ġ[ None Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): l [i ] Ġ= ĠI ()ĊĊ ĠĠĠ Ġreturn Ġl ĊĊ def ĠL IR (n ):ĊĊ ĠĠĠ Ġl Ġ= Ġ[ None Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): l [i ] Ġ= ĠLI ()ĊĊ ĠĠĠ Ġreturn Ġl ĊĊ def ĠSR (n ):ĊĊ ĠĠĠ Ġl Ġ= Ġ[ None Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): l [i ] Ġ= ĠS ()ĊĊ ĠĠĠ Ġreturn Ġl ĊĊ def ĠL SR (n ):ĊĊ ĠĠĠ Ġl Ġ= Ġ[ None Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ): l [i ] Ġ= ĠLS ()ĊĊ ĠĠĠ Ġreturn Ġl ĊĊ sys .set rec ursion limit ( 1 0 0 0 0 0 0 )ĊĊ mod Ġ= Ġ 1 0 0 0 0 0 0 0 0 7 ĊĊĊĊ # A ĊĊ def ĠA ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # B ĊĊ def ĠB ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # C ĊĊ def ĠC ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # D ĊĊ def ĠD ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # E ĊĊ def ĠE ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # F ĊĊ def ĠF ():ĊĊ ĠĠĠ Ġa ,b ,c ,X ,Y Ġ= ĠLI ()ĊĊ ĠĠĠ Ġans Ġ= Ġfloat (" inf ")ĊĊ ĠĠĠ Ġfor Ġz Ġin Ġrange ( 3 0 0 0 0 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġz % 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġm Ġ= Ġc *z ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġx Ġ= Ġz // 2 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġy Ġ= Ġz // 2 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġm Ġ+= Ġa * max ( 0 ,X -x )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġm Ġ+= Ġb * max ( 0 ,Y -y )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġm Ġ< Ġans :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġm ĊĊ ĠĠĠ Ġprint (ans )ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # G ĊĊ def ĠG ():ĊĊ ĠĠĠ Ġn Ġ= ĠI ()ĊĊ ĠĠĠ Ġx Ġ= ĠLI ()ĊĊ ĠĠĠ Ġf Ġ= Ġ[( i ,x [i ]) Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġf .sort (key Ġ= Ġlambda Ġx :x [ 1 ])ĊĊ ĠĠĠ Ġg Ġ= Ġ[( f [i ][ 0 ], i ) Ġfor Ġi Ġin Ġrange (n )]ĊĊ ĠĠĠ Ġg .sort (key Ġ= Ġlambda Ġx :x [ 0 ])ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġg [i ][ 1 ] Ġ< Ġn // 2 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (( f [n // 2 ][ 1 ]))ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (( f [n // 2 - 1 ][ 1 ]))ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # H ĊĊ def ĠH ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # I ĊĊ def ĠI _ ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # J ĊĊ def ĠJ ():ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ # S olve ĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ ĠF ()Ċ


Input:
n = int(input()) % 1000

if n == 0:

    print((0))

else:

    print((1000 - n))

n Ġ= Ġint (input ()) Ġ% Ġ 1 0 0 0 ĊĊ if Ġn Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ else :ĊĊ ĠĠĠ Ġprint (( 1 0 0 0 Ġ- Ġn ))


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

ans =[]

if R - L <= 2019:

    for i in range(L,R+1):

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

            ans.append(i*j%2019)

else:

    for i in range(R-L-1010,R-L+1010):

        for j in range(i,R-L+1010):

            ans.append(i*j%2019)

print((min(ans)))

L Ġ, R Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊ ans Ġ= [] ĊĊ if ĠR Ġ- ĠL Ġ<= Ġ 2 0 1 9 :ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (L ,R + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (i + 1 ,R + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans .append (i *j % 2 0 1 9 )ĊĊĊĊ else :ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (R -L - 1 0 1 0 ,R -L + 1 0 1 0 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (i ,R -L + 1 0 1 0 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans .append (i *j % 2 0 1 9 )ĊĊĊĊ print (( min (ans )))Ċ


Input:
from collections import Counter

import heapq

n = int(input())

ss = []

for _ in range(n):

    ss.append(input().rstrip())

ctr = Counter(ss)

heap = [(-v, k) for k, v in list(ctr.items())]

heapq.heapify(heap)

maxv = heap[0][0]

while heap:

    c = heapq.heappop(heap)

    if c[0] != maxv:

        break

    print((c[1]))

from Ġcollections Ġimport ĠCounter ĊĊ import Ġheapq ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ ss Ġ= Ġ[]ĊĊ for Ġ_ Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġss .append (input (). rstrip ())ĊĊ ctr Ġ= ĠCounter (ss )ĊĊ heap Ġ= Ġ[ (- v , Ġk ) Ġfor Ġk , Ġv Ġin Ġlist ( ctr .items ()) ]ĊĊ heap q .heap ify (heap )ĊĊ max v Ġ= Ġheap [ 0 ][ 0 ]ĊĊ while Ġheap :ĊĊ ĠĠĠ Ġc Ġ= Ġheapq .he app op (heap )ĊĊ ĠĠĠ Ġif Ġc [ 0 ] Ġ!= Ġmax v :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġprint (( c [ 1 ]))Ċ


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

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

L, R = [None] * M, [None] * M

for i in range(M):

    L[i], R[i] = list(map(int, input().split()))

l = max(L)

r = min(R)

ans = max(r - l + 1, 0)

print(ans)

# Ġ-*- Ġcoding : Ġutf - 8 Ġ-*- ĊĊĊĊ N , ĠM Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ L , ĠR Ġ= Ġ[ None ] Ġ* ĠM , Ġ[ None ] Ġ* ĠM ĊĊ for Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠ ĠL [i ], ĠR [i ] Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ l Ġ= Ġmax (L )ĊĊ r Ġ= Ġmin (R )ĊĊĊĊ ans Ġ= Ġmax (r Ġ- Ġl Ġ+ Ġ 1 , Ġ 0 )ĊĊĊĊ print (ans )Ċ


Input:
import math

input_num = int(input())

num_sqrt = int(math.sqrt(input_num))

minimam = input_num

for i in range(num_sqrt+1,0,-1):

    q, mod = divmod(input_num, i)

    distance = q + i -2

    if mod == 0 and minimam > distance:

        minimam = distance

print(minimam)

import Ġmath ĊĊ input _num Ġ= Ġint (input ())ĊĊ num _sqrt Ġ= Ġint (math .sqrt (input _num )) ĊĊĊĊ min im am Ġ= Ġinput _num ĊĊ for Ġi Ġin Ġrange (num _sqrt + 1 , 0 ,- 1 ):ĊĊ ĠĠĠ Ġq , Ġmod Ġ= Ġdiv mod (input _num , Ġi )ĊĊ ĠĠĠ Ġdistance Ġ= Ġq Ġ+ Ġi Ġ- 2 ĊĊ ĠĠĠ Ġif Ġmod Ġ== Ġ 0 Ġand Ġminim am Ġ> Ġdistance :ĊĊ ĠĠĠĠĠĠĠ Ġminim am Ġ= Ġdistance ĊĊ print (min im am )


Input:
# C - Walk on Multiplication Table

# https://atcoder.jp/contests/abc144/tasks/abc144_c

n = int(input())

ans = 10 ** 12

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

  if n % i == 0:

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

print((ans - 2))

# ĠC Ġ- ĠWalk Ġon ĠMultip lication ĠTable ĊĊ # Ġhttps :// at coder .jp / cont ests / abc 1 4 4 /tasks / abc 1 4 4 _c ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ ĊĊ ans Ġ= Ġ 1 0 Ġ** Ġ 1 2 ĊĊ for Ġi Ġin Ġrange ( 1 , Ġ 1 0 Ġ** Ġ 6 Ġ+ Ġ 1 ):ĊĊ Ġ Ġif Ġn Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġans Ġ= Ġmin (ans , Ġn Ġ// Ġi Ġ+ Ġi )ĊĊĊĊ print (( ans Ġ- Ġ 2 ))


Input:
# AGC003B - Simplified mahjong

import sys

input = sys.stdin.readline

def main():

    # split in subsequences when 0 appears -> sum up cur // 2

    N = int(input())

    A = list(map(int, [input() for _ in range(N)])) + [0]

    ans, cur = 0, 0

    for i in A:

        if i:

            cur += i

        else:

            ans += cur // 2

            cur = 0

    print(ans)

if __name__ == "__main__":

    main()

# ĠAG C 0 0 3 B Ġ- ĠSimpl ified Ġmah jong ĊĊ import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġ# Ġsplit Ġin Ġsubsequ ences Ġwhen Ġ 0 Ġappears Ġ-> Ġsum Ġup Ġcur Ġ// Ġ 2 ĊĊ ĠĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠA Ġ= Ġlist (map (int , Ġ[ input () Ġfor Ġ_ Ġin Ġrange (N )] )) Ġ+ Ġ[ 0 ]ĊĊ ĠĠĠ Ġans , Ġcur Ġ= Ġ 0 , Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcur Ġ+= Ġi ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġcur Ġ// Ġ 2 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcur Ġ= Ġ 0 ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()


Input:
while True:

    (n, x) = [int(i) for i in input().split()]

    if n == x == 0:

        break

    count = 0

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

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

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

                if sum([a,b,c]) == x:

                    count += 1

    print(count)

while ĠTrue :ĊĊ ĠĠĠ Ġ( n , Ġx ) Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ ĠĠĠ Ġif Ġn Ġ== Ġx Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ ĠĠĠ Ġcount Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġa Ġin Ġrange ( 1 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġb Ġin Ġrange (a Ġ+ Ġ 1 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġc Ġin Ġrange (b Ġ+ Ġ 1 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġsum ([ a ,b ,c ]) Ġ== Ġx :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġprint (count )


Input:
from collections import deque

N = 3

m = {8: {7, 5}, 7: {8, 6, 4}, 6: {7, 3}, 5: {8, 4, 2}, 4: {7, 5, 3, 1}, 3: {6, 4, 0}, 2: {5, 1}, 1: {4, 2, 0},

     0: {3, 1}}

goal = 123456780

def g(i, j, a):

    t = a // (10 ** j) % 10

    return a - t * (10 ** j) + t * (10 ** i)

def solve():

    MAP = "".join(input().replace(" ", "") for _ in range(N))

    start = 8 - MAP.find("0")

    MAP = int(MAP)

    if MAP == goal:

        return 0

    dp = deque([(0, start, MAP)])

    LOG = {MAP}

    while dp:

        cnt, yx, M = dp.popleft()

        if M == goal:

            return cnt

        cnt += 1

        for nyx in m[yx]:

            CM = g(yx, nyx, M)

            if not CM in LOG:

                dp.append((cnt, nyx, CM))

                LOG.add(CM)

def MAIN():

    print((solve()))

MAIN()

from Ġcollections Ġimport Ġdeque ĊĊ N Ġ= Ġ 3 ĊĊ m Ġ= Ġ{ 8 : Ġ{ 7 , Ġ 5 }, Ġ 7 : Ġ{ 8 , Ġ 6 , Ġ 4 }, Ġ 6 : Ġ{ 7 , Ġ 3 }, Ġ 5 : Ġ{ 8 , Ġ 4 , Ġ 2 }, Ġ 4 : Ġ{ 7 , Ġ 5 , Ġ 3 , Ġ 1 }, Ġ 3 : Ġ{ 6 , Ġ 4 , Ġ 0 }, Ġ 2 : Ġ{ 5 , Ġ 1 }, Ġ 1 : Ġ{ 4 , Ġ 2 , Ġ 0 },ĊĊ ĠĠĠĠ Ġ 0 : Ġ{ 3 , Ġ 1 }}ĊĊ goal Ġ= Ġ 1 2 3 4 5 6 7 8 0 ĊĊ def Ġg (i , Ġj , Ġa ):ĊĊ ĠĠĠ Ġt Ġ= Ġa Ġ// Ġ( 1 0 Ġ** Ġj ) Ġ% Ġ 1 0 ĊĊ ĠĠĠ Ġreturn Ġa Ġ- Ġt Ġ* Ġ( 1 0 Ġ** Ġj ) Ġ+ Ġt Ġ* Ġ( 1 0 Ġ** Ġi )ĊĊ def Ġsolve ():ĊĊ ĠĠĠ ĠMAP Ġ= Ġ"". join (input (). replace (" Ġ", Ġ"") Ġfor Ġ_ Ġin Ġrange (N ))ĊĊ ĠĠĠ Ġstart Ġ= Ġ 8 Ġ- ĠMAP .find (" 0 ")ĊĊ ĠĠĠ ĠMAP Ġ= Ġint (M AP )ĊĊ ĠĠĠ Ġif ĠMAP Ġ== Ġgoal :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 0 ĊĊ ĠĠĠ Ġdp Ġ= Ġdeque ([( 0 , Ġstart , ĠMAP )])ĊĊ ĠĠĠ ĠLOG Ġ= Ġ{ MAP }ĊĊ ĠĠĠ Ġwhile Ġdp :ĊĊ ĠĠĠĠĠĠĠ Ġcnt , Ġy x , ĠM Ġ= Ġdp .p opleft ()ĊĊ ĠĠĠĠĠĠĠ Ġif ĠM Ġ== Ġgoal :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġcnt ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġny x Ġin Ġm [y x ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠCM Ġ= Ġg (y x , Ġny x , ĠM )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġnot ĠCM Ġin ĠLOG :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp .append (( cnt , Ġny x , ĠCM ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠLOG .add (C M )ĊĊ def ĠMAIN ():ĊĊ ĠĠĠ Ġprint (( solve ()))ĊĊ MAIN ()ĊĊĊ


Input:
inf = (5000 * 10 ** 5) * 3

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

ret = inf

for cnt_ab in range(max(x, y) * 2 + 1):

    d = cnt_ab // 2

    cnt_a = max(0, x - d)

    cnt_b = max(0, y - d)

    t = cnt_ab * c + cnt_a * a + cnt_b * b

    ret = min(ret, t)

print(ret)

inf Ġ= Ġ( 5 0 0 0 Ġ* Ġ 1 0 Ġ** Ġ 5 ) Ġ* Ġ 3 ĊĊĊĊ a , Ġb , Ġc , Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ret Ġ= Ġinf ĊĊ for Ġcnt _ab Ġin Ġrange (max (x , Ġy ) Ġ* Ġ 2 Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġd Ġ= Ġcnt _ab Ġ// Ġ 2 ĊĊĊĊ ĠĠĠ Ġcnt _a Ġ= Ġmax ( 0 , Ġx Ġ- Ġd )ĊĊ ĠĠĠ Ġcnt _b Ġ= Ġmax ( 0 , Ġy Ġ- Ġd )ĊĊĊĊ ĠĠĠ Ġt Ġ= Ġcnt _ab Ġ* Ġc Ġ+ Ġcnt _a Ġ* Ġa Ġ+ Ġcnt _b Ġ* Ġb ĊĊ ĠĠĠ Ġret Ġ= Ġmin (ret , Ġt )ĊĊ print (ret )Ċ


Input:
S = int(input())

f = [0]*(S+1)

f[0] = 1

if S >= 3: f[3] = 1

if S >= 4: f[4] = 1

if S >= 5: f[5] = 1

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

    f[i] = sum(f[i-j] for j in range(3, i+1))%(10**9+7)

print((f[S]))

S Ġ= Ġint (input ())ĊĊ f Ġ= Ġ[ 0 ]*( S + 1 )ĊĊ f [ 0 ] Ġ= Ġ 1 ĊĊ if ĠS Ġ>= Ġ 3 : Ġf [ 3 ] Ġ= Ġ 1 ĊĊ if ĠS Ġ>= Ġ 4 : Ġf [ 4 ] Ġ= Ġ 1 ĊĊ if ĠS Ġ>= Ġ 5 : Ġf [ 5 ] Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġrange ( 6 , ĠS + 1 ):ĊĊ ĠĠĠ Ġf [i ] Ġ= Ġsum (f [i -j ] Ġfor Ġj Ġin Ġrange ( 3 , Ġi + 1 )) %( 1 0 ** 9 + 7 )ĊĊ print (( f [S ]))Ċ


Input:
import sys

input = sys.stdin.buffer.readline

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

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

INF = 10 ** 15

dp = [[INF for j in range(401)] for i in range(401)]

dp[0][0] = 0

for a, b, c in ABC:

  for i in range(400, -1, -1):

    for j in range(400, -1, -1):

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

        dp[i + a][j + b] = min(dp[i + a][j + b], dp[i][j] + c)

answer = INF

for i in range(1, 401):

  for j in range(1, 401):

    if dp[i][j] != INF and i / j == Ma / Mb:

      answer = min(answer, dp[i][j])

print((answer if answer != INF else -1))

import Ġsys ĊĊ input Ġ= Ġsys .stdin .buffer .readline ĊĊĊĊ N , ĠMa , ĠMb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ABC Ġ= Ġ[ list (map (int , Ġinput (). split ())) Ġfor Ġ_ Ġin Ġrange (N )] ĊĊĊĊ INF Ġ= Ġ 1 0 Ġ** Ġ 1 5 ĊĊ dp Ġ= Ġ[[ INF Ġfor Ġj Ġin Ġrange ( 4 0 1 )] Ġfor Ġi Ġin Ġrange ( 4 0 1 )]ĊĊ dp [ 0 ][ 0 ] Ġ= Ġ 0 ĊĊĊĊ for Ġa , Ġb , Ġc Ġin ĠABC :ĊĊ Ġ Ġfor Ġi Ġin Ġrange ( 4 0 0 , Ġ- 1 , Ġ- 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 4 0 0 , Ġ- 1 , Ġ- 1 ):ĊĊ ĠĠĠĠĠ Ġif Ġdp [i ][ j ] Ġ!= ĠINF :ĊĊ ĠĠĠĠĠĠĠ Ġdp [i Ġ+ Ġa ][ j Ġ+ Ġb ] Ġ= Ġmin (dp [i Ġ+ Ġa ][ j Ġ+ Ġb ], Ġdp [i ][ j ] Ġ+ Ġc )ĊĊĊĊ answer Ġ= ĠINF ĊĊ for Ġi Ġin Ġrange ( 1 , Ġ 4 0 1 ):ĊĊ Ġ Ġfor Ġj Ġin Ġrange ( 1 , Ġ 4 0 1 ):ĊĊ ĠĠĠ Ġif Ġdp [i ][ j ] Ġ!= ĠINF Ġand Ġi Ġ/ Ġj Ġ== ĠMa Ġ/ ĠMb :ĊĊ ĠĠĠĠĠ Ġanswer Ġ= Ġmin (answer , Ġdp [i ][ j ])ĊĊ ĠĠĠĠĠĠĊĊ print (( answer Ġif Ġanswer Ġ!= ĠINF Ġelse Ġ- 1 ))


Input:
from sys import stdin, stdout, setrecursionlimit

from collections import deque, defaultdict, Counter

from heapq import heappush, heappop

from functools import lru_cache

import math

setrecursionlimit(10**6)

rl = lambda: stdin.readline()

rll = lambda: stdin.readline().split()

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

rlf = lambda: list(map(float, stdin.readline().split()))

INF, NINF = float('inf'), float('-inf')

MOD = 10**9 + 7

def main():

	s = int(rl())

	@lru_cache(None)

	def dp(currsum):

		if currsum == s: return 1

		cnt = 0

		for d in range(3, 2001):

			if currsum + d <= s:

				cnt += dp(currsum + d)

				cnt %= MOD

		return cnt

	print((dp(0)))

	stdout.close()

if __name__ == "__main__":

	main()

from Ġsys Ġimport Ġstdin , Ġstdout , Ġset rec ursion limit ĊĊ from Ġcollections Ġimport Ġdeque , Ġdefaultdict , ĠCounter ĊĊ from Ġheapq Ġimport Ġhe app ush , Ġhe app op ĊĊ from Ġfunctools Ġimport Ġl ru _cache ĊĊ import Ġmath ĊĊĊĊ set rec ursion limit ( 1 0 ** 6 )ĊĊ rl Ġ= Ġlambda : Ġstdin .readline ()ĊĊ r ll Ġ= Ġlambda : Ġstdin .readline (). split ()ĊĊ r li Ġ= Ġlambda : Ġlist (map (int , Ġstdin .readline (). split ()))ĊĊ rl f Ġ= Ġlambda : Ġlist (map (float , Ġstdin .readline (). split ())) ĊĊĊĊ INF , ĠN INF Ġ= Ġfloat (' inf '), Ġfloat ('- inf ')ĊĊ MOD Ġ= Ġ 1 0 ** 9 Ġ+ Ġ 7 ĊĊĊĊ def Ġmain ():ĊĊ ĉs Ġ= Ġint ( rl ())ĊĊ ĊĊ ĉ @ l ru _cache (None )ĊĊ ĉdef Ġdp (curr sum ):ĊĊ ĉ ĉif Ġcurr sum Ġ== Ġs : Ġreturn Ġ 1 ĊĊ ĉ ĉcnt Ġ= Ġ 0 ĊĊ ĉ ĉfor Ġd Ġin Ġrange ( 3 , Ġ 2 0 0 1 ):ĊĊ ĉĉ ĉif Ġcurr sum Ġ+ Ġd Ġ<= Ġs :ĊĊ ĉĉĉ ĉcnt Ġ+= Ġdp (curr sum Ġ+ Ġd )ĊĊ ĉĉĉ ĉcnt Ġ%= ĠMOD ĠĊĊ ĉ ĉreturn Ġcnt ĊĊ ĉprint (( dp ( 0 )))ĊĊ ĉstd out .close ()ĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĉmain ()


Input:
import math

n=int(input())

print(((2*n)//math.gcd(2,n)))

import Ġmath ĊĊ n =int (input ())ĊĊ print ((( 2 *n )// math .g cd ( 2 ,n )))


Input:
import sys

s = input()

ts = ['']

while True:

  nts= []

  for t in ts:

    for w in ['dreamer', 'eraser', 'dream', 'erase']:

      if s == t + w:

        print('YES')

        sys.exit()

      if s.startswith(t + w):

        nts.append(t + w)

  if len(nts) == 0:

    print('NO')

    sys.exit()

  ts = nts

import Ġsys ĊĊ s Ġ= Ġinput ()ĊĊ ts Ġ= Ġ[' ']ĊĊ while ĠTrue :ĊĊ Ġ Ġn ts = Ġ[]ĊĊ Ġ Ġfor Ġt Ġin Ġts :ĊĊ ĠĠĠ Ġfor Ġw Ġin Ġ[' dream er ', Ġ' eras er ', Ġ' dream ', Ġ' erase '] :ĊĊ ĠĠĠĠĠ Ġif Ġs Ġ== Ġt Ġ+ Ġw :ĊĊ ĠĠĠĠĠĠĠ Ġprint (' YES ')ĊĊ ĠĠĠĠĠĠĠ Ġsys .exit ()ĊĊ ĠĠĠĠĠ Ġif Ġs .startswith (t Ġ+ Ġw ):ĊĊ ĠĠĠĠĠĠĠ Ġn ts .append (t Ġ+ Ġw )ĊĊ Ġ Ġif Ġlen ( nts ) Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġprint (' NO ')ĊĊ ĠĠĠ Ġsys .exit ()ĊĊ Ġ Ġts Ġ= Ġn ts Ċ


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

a = [[0]*N]*K

a = [[0 for n in range(N)] for k in range(K)]

for k in range(K):

    d=int(input())

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

    for h in have_k:

        a[k][h-1]=1

an=[0]*N

for k in range(K):

  for n in range(N):

    an[n] = an[n]+a[k][n]

result=0

for i in an:

  if i == 0:

    result+=1

print(result)

N ,K =list (map (int ,input (). split ()))ĊĊ a Ġ= Ġ[[ 0 ]* N ]* K ĊĊ a Ġ= Ġ[[ 0 Ġfor Ġn Ġin Ġrange (N )] Ġfor Ġk Ġin Ġrange (K )] ĊĊĊĊ for Ġk Ġin Ġrange (K ):ĊĊ ĠĠĠ Ġd =int (input ())ĊĊ ĠĠĠ Ġhave _k =list (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġfor Ġh Ġin Ġhave _k :ĊĊ ĠĠĠĠĠĠĠ Ġa [k ][ h - 1 ]= 1 ĊĊĊĊ an =[ 0 ]* N ĊĊ for Ġk Ġin Ġrange (K ):ĊĊ Ġ Ġfor Ġn Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġan [n ] Ġ= Ġan [n ]+ a [k ][ n ]ĊĊĊĊ result = 0 ĊĊ for Ġi Ġin Ġan :ĊĊ Ġ Ġif Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġresult += 1 ĊĊĊĊ print (result )


Input:
import sys

sys.setrecursionlimit(1000000)

S = input()

T = ['dream', 'dreamer', 'erase', 'eraser']

lenT = [len(i) for i in T]

def dayDream(pin):

    global isDream               #;print('dayDream: ', pin, S[pin:])

    for i, d in enumerate(T):

        #print('d:', d)

        if S[pin:pin+lenT[i]] == d:

            pout = pin + lenT[i] #; print(d, pout)

            if pout == len(S):

                isDream = True   #; print('YES')

                return

            else:

                dayDream(pout)

    #print('dayDream return', pin)

    return

isDream = False

dayDream(0)

if isDream:

    print('YES')

else:

    print('NO')

import Ġsys ĊĊ sys .set rec ursion limit ( 1 0 0 0 0 0 0 )ĊĊĊĊ S Ġ= Ġinput ()ĊĊĊĊ T Ġ= Ġ[' dream ', Ġ' dream er ', Ġ' erase ', Ġ' eras er ']ĊĊ len T Ġ= Ġ[ len (i ) Ġfor Ġi Ġin ĠT ]ĊĊĊĊ def Ġday Dream (pin ):ĊĊ ĠĠĠ Ġglobal Ġis Dream ĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġ# ; print (' day Dream : Ġ', Ġpin , ĠS [p in : ])ĊĊ ĠĠĠ Ġfor Ġi , Ġd Ġin Ġenumerate (T ):ĊĊ ĠĠĠĠĠĠĠ Ġ# print (' d :', Ġd )ĊĊ ĠĠĠĠĠĠĠ Ġif ĠS [p in : pin +len T [i ]] Ġ== Ġd : ĠĠĠĠĠĠĠĠĠĠĠĠĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġp out Ġ= Ġpin Ġ+ Ġlen T [i ] Ġ# ; Ġprint (d , Ġp out )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġp out Ġ== Ġlen (S ): ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġis Dream Ġ= ĠTrue ĠĠ Ġ# ; Ġprint (' YES ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġday Dream (p out )ĊĊ ĠĠĠ Ġ# print (' day Dream Ġreturn ', Ġpin )ĊĊ ĠĠĠ Ġreturn ĊĊ ĠĠĠĠĊĊ is Dream Ġ= ĠFalse ĊĊ day Dream ( 0 )ĊĊ if Ġis Dream :ĊĊ ĠĠĠ Ġprint (' YES ')ĊĊ else :ĊĊ ĠĠĠ Ġprint (' NO ')


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

c=[0]*(n+2)

for i in range(m):

  l,r=list(map(int,input().split()))

  c[l-1]+=1

  c[r]-=1

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

  c[i]=c[i]+c[i-1]

ans=0

for i in range(n+2):

  if c[i]==m:

    ans+=1

print(ans)

n ,m =list (map (int ,input (). split ()))ĊĊ c =[ 0 ]*( n + 2 )ĊĊ for Ġi Ġin Ġrange (m ):ĊĊ Ġ Ġl ,r =list (map (int ,input (). split ()))ĊĊ Ġ Ġc [l - 1 ]+= 1 ĊĊ Ġ Ġc [r ]- = 1 ĊĊ for Ġi Ġin Ġrange ( 1 ,n + 2 ):ĊĊ Ġ Ġc [i ]= c [i ]+ c [i - 1 ]ĊĊ ans = 0 ĊĊ for Ġi Ġin Ġrange (n + 2 ):ĊĊ Ġ Ġif Ġc [i ]== m :ĊĊ ĠĠĠ Ġans += 1 ĊĊ print (ans )


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

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

b=[0 for x in range(n+1)]

l=list([0])

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

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

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

  l.append(b[i]%m)

d=list()

l.sort()

t,c=0,1

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

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

    c+=1

  else:

    if c!=1:

      t += c*(c-1)//2

      c=1

if c!=1:

  t += c*(c-1)//2

print(t)

n ,m =list (map (int ,input (). split ()))ĊĊ a =[ int (x ) Ġfor Ġx Ġin Ġinput (). split ()]ĊĊ b =[ 0 Ġfor Ġx Ġin Ġrange (n + 1 )]ĊĊ l =list ([ 0 ])ĊĊ ĊĊ for Ġi Ġin Ġrange ( 1 ,n + 1 ):ĊĊ Ġ Ġb [i ]= b [i - 1 ]+ a [i - 1 ]ĊĊĊĊ for Ġi Ġin Ġrange ( 1 ,n + 1 ):ĊĊ Ġ Ġl .append (b [i ]% m )ĊĊĊĊ d =list ()ĊĊ l .sort ()ĊĊ t ,c = 0 , 1 ĊĊ for Ġi Ġin Ġrange ( 1 ,n + 1 ):ĊĊ Ġ Ġif Ġl [i ]== l [i - 1 ]:ĊĊ ĠĠĠ Ġc += 1 ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ Ġif Ġc != 1 :ĊĊ ĠĠĠĠĠ Ġt Ġ+= Ġc *( c - 1 )// 2 ĊĊ ĠĠĠĠĠ Ġc = 1 ĊĊĊĊ if Ġc != 1 :ĊĊ Ġ Ġt Ġ+= Ġc *( c - 1 )// 2 ĠĠ ĊĊĊĊ print (t )Ċ


Input:
import copy

n=int(input())

org_set=set([i for i in range(1,10**5)])

edges=[]

relations={}

nodes=[]

for i in range(n-1):

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

    edges.append([a,b])

    relations.setdefault(a,[]).append(b)

    nodes.append([])

nodes.append([])

nodes.append([])

max_color=0

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

    targets=relations.get(start,[])

    color=1

    for target in targets:

        if color in nodes[start]:

            color+=1

        else:

            pass

        nodes[target].append(color)

        if color>=max_color:

            max_color=color

        color+=1

print(max_color)

for edge in edges:

    print((nodes[edge[1]][0]))

import Ġcopy ĊĊĊĊ n =int (input ())ĊĊ org _set =set ([ i Ġfor Ġi Ġin Ġrange ( 1 , 1 0 ** 5 )])ĊĊ edges =[] ĊĊ relations ={ }ĊĊ nodes =[] ĊĊ for Ġi Ġin Ġrange (n - 1 ):ĊĊ ĠĠĠ Ġa ,b =list (map (int ,input (). split (" Ġ" )))ĊĊ ĠĠĠ Ġedges .append ([ a ,b ])ĊĊ ĠĠĠ Ġrelations .setdefault (a , [] ). append (b )ĊĊ ĠĠĠ Ġnodes .append ([] )ĊĊ nodes .append ([] )ĊĊ nodes .append ([] )ĊĊĊĊ max _color = 0 ĊĊ for Ġstart Ġin Ġrange ( 1 ,n + 1 ):ĊĊ ĠĠĠ Ġtargets = relations .get (start , [] )ĊĊ ĠĠĠ Ġcolor = 1 ĊĊ ĠĠĠ Ġfor Ġtarget Ġin Ġtargets :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġcolor Ġin Ġnodes [start ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcolor += 1 ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġpass ĊĊ ĠĠĠĠĠĠĠ Ġnodes [target ]. append (color )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġcolor >= max _color :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmax _color =color ĊĊ ĠĠĠĠĠĠĠ Ġcolor += 1 ĊĊĊĊ print (max _color )ĊĊ for Ġedge Ġin Ġedges :ĊĊ ĠĠĠ Ġprint (( nodes [edge [ 1 ]][ 0 ]))


Input:
n=int(input())

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

k=[]

ans=0

for i in range(400005):

  k.append(0)

for i in range(n):

  if i-a[i]>=0:

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

  if a[i]+i<400005:

    k[a[i]+i]+=1

print(ans)

n =int (input ())ĊĊ a =list (map (int ,input (). split ()))ĊĊ k =[] ĊĊ ans = 0 ĊĊ for Ġi Ġin Ġrange ( 4 0 0 0 0 5 ):ĊĊ Ġ Ġk .append ( 0 )ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ Ġ Ġif Ġi -a [i ]>= 0 :ĊĊ ĠĠĠ Ġans += k [i -a [i ]]ĊĊ Ġ Ġif Ġa [i ]+ i < 4 0 0 0 0 5 :ĊĊ ĠĠĠ Ġk [a [i ]+ i ]+= 1 ĊĊ print (ans )


Input:
import sys

import os

import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())

il = lambda: list(map(int, sys.stdin.buffer.readline().split()))

iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()

isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

def main():

    if os.getenv("LOCAL"):

        sys.stdin = open("input.txt", "r")

    N = ii()

    ret = float('inf')

    I = int(math.sqrt(N)) * 10

    for i in range(1, I):

        if N%i == 0:

            j = N//i

            ret = min(ret, j + i - 2)

    print(ret)

if __name__ == '__main__':

    main()

import Ġsys ĊĊ import Ġos ĊĊ import Ġmath ĊĊĊĊ ii Ġ= Ġlambda : Ġint (sys .stdin .buffer .readline (). rstrip ())ĊĊ il Ġ= Ġlambda : Ġlist (map (int , Ġsys .stdin .buffer .readline (). split ()))ĊĊ il n Ġ= Ġlambda Ġn : Ġ[ int (sys .stdin .buffer .readline (). rstrip ()) Ġfor Ġ_ Ġin Ġrange (n )] ĊĊĊĊ iss Ġ= Ġlambda : Ġsys .stdin .buffer .readline (). decode (). rstrip ()ĊĊ is n Ġ= Ġlambda Ġn : Ġ[ sys .stdin .buffer .readline (). decode (). rstrip () Ġfor Ġ_ Ġin Ġrange (n )] ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġif Ġos .getenv (" LOCAL ") :ĊĊ ĠĠĠĠĠĠĠ Ġsys .stdin Ġ= Ġopen (" input .txt ", Ġ" r ")ĊĊ ĊĊ ĠĠĠ ĠN Ġ= Ġii ()ĊĊ ĠĠĠ Ġret Ġ= Ġfloat (' inf ')ĊĊ ĠĠĠ ĠI Ġ= Ġint (math .sqrt (N )) Ġ* Ġ 1 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , ĠI ):ĊĊ ĠĠĠĠĠĠĠ Ġif ĠN %i Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġj Ġ= ĠN // i ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġret Ġ= Ġmin (ret , Ġj Ġ+ Ġi Ġ- Ġ 2 )ĊĊĊĊ ĠĠĠ Ġprint (ret )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ