Input:
mod = 998244353

N = int(input())

X = []

for _ in range(N):

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

    X.append((x, x + d))

X = sorted(X, key = lambda x: x[0])

L = [(0, -(10**9+1), 10**9+1)]

P = [-1] * (N+1)

for i, (x, y) in enumerate(X):

    while L[-1][2] <= y:

        if L[-1][2] > x and P[i+1] < 0:

            P[i+1] = L[-1][0]

        L.pop()

    if P[i+1] < 0:

        P[i+1] = L[-1][0]

    L.append((i+1, x, y))

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

for i, p in enumerate(P):

    if p >= 0:

        C[p].append(i)

Y = [1] * (N+1)

for i in range(N+1)[::-1]:

    s = 1

    for j in C[i]:

        s = s * (Y[j] + 1) % mod

    Y[i] = s

print((Y[0]))

mod Ġ= Ġ 9 9 8 2 4 4 3 5 3 ĊĊ N Ġ= Ġint (input ())ĊĊ X Ġ= Ġ[]ĊĊ for Ġ_ Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġx , Ġd Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠX .append (( x , Ġx Ġ+ Ġd )) ĊĊĊĊ X Ġ= Ġsorted (X , Ġkey Ġ= Ġlambda Ġx : Ġx [ 0 ])ĊĊ L Ġ= Ġ[( 0 , Ġ-( 1 0 ** 9 + 1 ), Ġ 1 0 ** 9 + 1 )]ĊĊ P Ġ= Ġ[- 1 ] Ġ* Ġ( N + 1 )ĊĊ for Ġi , Ġ( x , Ġy ) Ġin Ġenumerate (X ):ĊĊ ĠĠĠ Ġwhile ĠL [- 1 ][ 2 ] Ġ<= Ġy :ĊĊ ĠĠĠĠĠĠĠ Ġif ĠL [- 1 ][ 2 ] Ġ> Ġx Ġand ĠP [i + 1 ] Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠP [i + 1 ] Ġ= ĠL [- 1 ][ 0 ]ĊĊ ĠĠĠĠĠĠĠ ĠL .pop ()ĊĊ ĠĠĠ Ġif ĠP [i + 1 ] Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ ĠP [i + 1 ] Ġ= ĠL [- 1 ][ 0 ]ĊĊ ĠĠĠ ĠL .append (( i + 1 , Ġx , Ġy )) ĊĊĊĊ C Ġ= Ġ[[] Ġfor Ġ_ Ġin Ġrange (N + 1 )]ĊĊ for Ġi , Ġp Ġin Ġenumerate (P ):ĊĊ ĠĠĠ Ġif Ġp Ġ>= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ ĠC [p ]. append (i )ĊĊĊĊ Y Ġ= Ġ[ 1 ] Ġ* Ġ( N + 1 )ĊĊ for Ġi Ġin Ġrange (N + 1 )[ ::- 1 ]:ĊĊ ĠĠĠ Ġs Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġj Ġin ĠC [i ]:ĊĊ ĠĠĠĠĠĠĠ Ġs Ġ= Ġs Ġ* Ġ( Y [j ] Ġ+ Ġ 1 ) Ġ% Ġmod ĊĊ ĠĠĠ ĠY [i ] Ġ= Ġs ĊĊĊĊ print (( Y [ 0 ]))


Input: print((sum(si != ti for si, ti in zip(input(), input()))))

print (( sum (si Ġ!= Ġti Ġfor Ġsi , Ġti Ġin Ġzip (input (), Ġinput ())) ))Ċ


Input:
n = int(input())

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

p = 10000000

for i in range(100):

    pi = 0

    for j in range(n):

        pi += (x[j] - (i + 1))**2

    if pi < p:

        p = pi

    # else:

    #     break

        # p[i] += (x[j]-(i+1))**2

print(p)

n Ġ= Ġint (input ())ĊĊ x Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ p Ġ= Ġ 1 0 0 0 0 0 0 0 ĊĊ for Ġi Ġin Ġrange ( 1 0 0 ):ĊĊ ĠĠĠ Ġpi Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġpi Ġ+= Ġ( x [j ] Ġ- Ġ( i Ġ+ Ġ 1 )) ** 2 ĊĊ ĠĠĠ Ġif Ġpi Ġ< Ġp :ĊĊ ĠĠĠĠĠĠĠ Ġp Ġ= Ġpi ĊĊ ĠĠĠ Ġ# Ġelse :ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġ# Ġp [i ] Ġ+= Ġ( x [j ] -( i + 1 )) ** 2 ĊĊ print (p )


Input:
def solve():

    N = int(input())

    numss = [[0]*(10) for _ in range(10)]

    for x in range(1, 10):

        for y in range(1, 10):

            num = 0

            for d in range(1, 5):

                for i in range(10**d):

                    j = x*10**(d+1) + i*10 + y

                    if 1 <= j <= N:

                        num += 1

                    else:

                        break

            j = x*10 + y

            if 1 <= j <= N:

                num += 1

            if x == y:

                j = x

                if 1 <= j <= N:

                    num += 1

            numss[x][y] = num

    ans = 0

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

        ss = str(A)

        ans += numss[int(ss[-1])][int(ss[0])]

    print(ans)

solve()

def Ġsolve ():ĊĊ ĠĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĊĊ ĠĠĠ Ġnum ss Ġ= Ġ[[ 0 ]*( 1 0 ) Ġfor Ġ_ Ġin Ġrange ( 1 0 )]ĊĊ ĠĠĠ Ġfor Ġx Ġin Ġrange ( 1 , Ġ 1 0 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġy Ġin Ġrange ( 1 , Ġ 1 0 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġnum Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġd Ġin Ġrange ( 1 , Ġ 5 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 0 ** d ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġj Ġ= Ġx * 1 0 **( d + 1 ) Ġ+ Ġi * 1 0 Ġ+ Ġy ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ 1 Ġ<= Ġj Ġ<= ĠN :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġnum Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġj Ġ= Ġx * 1 0 Ġ+ Ġy ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ 1 Ġ<= Ġj Ġ<= ĠN :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġnum Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx Ġ== Ġy :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġj Ġ= Ġx ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ 1 Ġ<= Ġj Ġ<= ĠN :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġnum Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġnum ss [x ][ y ] Ġ= Ġnum ĊĊĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor ĠA Ġin Ġrange ( 1 , ĠN + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġss Ġ= Ġstr (A )ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġnum ss [int (ss [- 1 ]) ][ int (ss [ 0 ]) ]ĊĊĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊĊĊ solve ()Ċ


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

from collections import deque

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

S = input()

A = set("ATCG")

ans = 0

mode = 0

for i, s in enumerate(S):

    if s in A:

        if mode == 0:

            mode = 1

            start = i

    else:

        if mode == 1:

            ans = max(i - start, ans)

            mode = 0

if mode == 1:

    ans = max(len(S) - start, ans)

print(ans)

# Ġ-*- Ġcoding : Ġutf - 8 Ġ-*-ĊĊ from Ġcollections Ġimport Ġdeque ĊĊ def Ġin pl (): Ġreturn Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ S Ġ= Ġinput ()ĊĊ A Ġ= Ġset (" AT CG ")ĊĊ ans Ġ= Ġ 0 ĊĊ mode Ġ= Ġ 0 ĊĊ for Ġi , Ġs Ġin Ġenumerate (S ):ĊĊ ĠĠĠ Ġif Ġs Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġmode Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmode Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġstart Ġ= Ġi ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġmode Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġmax (i Ġ- Ġstart , Ġans )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmode Ġ= Ġ 0 ĊĊ if Ġmode Ġ== Ġ 1 :ĊĊ ĠĠĠ Ġans Ġ= Ġmax (len (S ) Ġ- Ġstart , Ġans )ĊĊ print (ans )


Input:
N = int(input())

ans = 0

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

    if len(str(i)) % 2 == 1:

        ans += 1

print(ans)

N Ġ= Ġint (input ())ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 , ĠN Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġif Ġlen (str (i )) Ġ% Ġ 2 Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ print (ans )


Input:
S = input()

k = int(input())

A = set()

for l in range(k+1):

	for i in range(len(S)-l):

			A.add(S[i:i+l+1])

A = sorted(list(A))

print((A[k-1]))

S Ġ= Ġinput ()ĊĊ k Ġ= Ġint (input ())ĊĊ A Ġ= Ġset ()ĊĊ for Ġl Ġin Ġrange (k + 1 ):ĊĊ ĉfor Ġi Ġin Ġrange (len (S )- l ):ĊĊ ĉĉ ĉA .add (S [i :i +l + 1 ])ĊĊ A Ġ= Ġsorted (list (A ))ĊĊ print (( A [k - 1 ]))


Input:
import sys

input = sys.stdin.readline

from collections import *

K = int(input())

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

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

    if i%K==0:

        print('OK')

        exit()

print('NG')

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ from Ġcollections Ġimport Ġ* ĊĊĊĊ K Ġ= Ġint (input ())ĊĊ A , ĠB Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ for Ġi Ġin Ġrange (A , ĠB + 1 ):ĊĊ ĠĠĠ Ġif Ġi % K == 0 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (' OK ')ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊ ĠĠĠĠĊĊ print (' NG ')


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

U = 400

dp = [[[float("inf")]*(U+1) for _ in range(U+1)] for i in range(n+1)]

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

for i in range(n):

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

  for j in range(U+1):

    for k in range(U+1):

      if j<a or k<b:

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

      else:

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

ans = float("inf")

for i in range(1, 1+U//max(ma, mb)):

  na, nb = i*ma, i*mb

  ans = min(ans, dp[-1][na][nb])

if ans == float("inf"):

  print((-1))

else:

  print(ans)

n , Ġma , Ġmb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ U Ġ= Ġ 4 0 0 ĊĊ dp Ġ= Ġ[[[ float (" inf ")] *( U + 1 ) Ġfor Ġ_ Ġin Ġrange (U + 1 )] Ġfor Ġi Ġin Ġrange (n + 1 )]ĊĊ dp [ 0 ][ 0 ][ 0 ] Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ Ġ Ġa , Ġb , Ġc Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ Ġ Ġfor Ġj Ġin Ġrange (U + 1 ):ĊĊ ĠĠĠ Ġfor Ġk Ġin Ġrange (U + 1 ):ĊĊ ĠĠĠĠĠ Ġif Ġj <a Ġor Ġk <b :ĊĊ ĠĠĠĠĠĠĠ Ġdp [i + 1 ][ j ][ k ] Ġ= Ġdp [i ][ j ][ k ]ĊĊ ĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġdp [i + 1 ][ j ][ k ] Ġ= Ġmin (dp [i ][ j ][ k ], Ġdp [i ][ j -a ][ k -b ]+ c )ĊĊ ans Ġ= Ġfloat (" inf ")ĊĊ for Ġi Ġin Ġrange ( 1 , Ġ 1 + U // max (m a , Ġmb )) :ĊĊ Ġ Ġna , Ġnb Ġ= Ġi * ma , Ġi * mb ĊĊ Ġ Ġans Ġ= Ġmin (ans , Ġdp [- 1 ][ na ][ nb ])ĊĊ if Ġans Ġ== Ġfloat (" inf ") :ĊĊ Ġ Ġprint ((- 1 ))ĊĊ else :ĊĊ Ġ Ġprint (ans )


Input:
from heapq import heappush, heappop

k = int(input())

heap = [(1,1)]

dist = [float("inf")]*k

while heap:

    cost, cur = heappop(heap)

    if dist[cur] <= cost:

        continue

    dist[cur] = cost

    # +1

    nxt = (cur+1)%k

    heappush(heap, (cost+1, nxt))

    # *10

    nxt = cur*10 % k

    heappush(heap, (cost, nxt))

print((dist[0]))

from Ġheapq Ġimport Ġhe app ush , Ġhe app op ĊĊ k Ġ= Ġint (input ())ĊĊ ĊĊ heap Ġ= Ġ[( 1 , 1 )]ĊĊ dist Ġ= Ġ[ float (" inf ") ]* k ĊĊ while Ġheap :ĊĊ ĠĠĠ Ġcost , Ġcur Ġ= Ġhe app op (heap )ĊĊ ĠĠĠ Ġif Ġdist [cur ] Ġ<= Ġcost :ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġdist [cur ] Ġ= Ġcost ĊĊ ĠĠĠ Ġ# Ġ+ 1 ĊĊ ĠĠĠ Ġnxt Ġ= Ġ( cur + 1 )% k ĊĊ ĠĠĠ Ġhe app ush (heap , Ġ( cost + 1 , Ġnxt ))ĊĊ ĠĠĠ Ġ# Ġ* 1 0 ĊĊ ĠĠĠ Ġnxt Ġ= Ġcur * 1 0 Ġ% Ġk ĊĊ ĠĠĠ Ġhe app ush (heap , Ġ( cost , Ġnxt )) ĊĊĊĊ print (( dist [ 0 ]))


Input:
S = input()

T = input()

l = len(S)

res = 0

for n in range(l):

    if S[n] == T[n]:

        res += 1

print(res)

S Ġ= Ġinput ()ĊĊ T Ġ= Ġinput ()ĊĊĊĊ l Ġ= Ġlen (S )ĊĊ res Ġ= Ġ 0 ĊĊ for Ġn Ġin Ġrange (l ):ĊĊ ĠĠĠ Ġif ĠS [n ] Ġ== ĠT [n ]:ĊĊ ĠĠĠĠĠĠĠ Ġres Ġ+= Ġ 1 ĊĊ print (res )


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

max_iter = max(X, Y) * 2

ans = float("inf")

for i in range(max_iter):

    a = max(X - i, 0)

    b = max(Y - i, 0)

    price = 2*C * i + A * a + B * b

    ans = min(ans, price)

print(ans)

A , ĠB , ĠC , ĠX , ĠY Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ max _iter Ġ= Ġmax (X , ĠY ) Ġ* Ġ 2 ĊĊ ans Ġ= Ġfloat (" inf ")ĊĊ for Ġi Ġin Ġrange (max _iter ):ĊĊ ĠĠĠ Ġa Ġ= Ġmax (X Ġ- Ġi , Ġ 0 )ĊĊ ĠĠĠ Ġb Ġ= Ġmax (Y Ġ- Ġi , Ġ 0 )ĊĊ ĠĠĠ Ġprice Ġ= Ġ 2 *C Ġ* Ġi Ġ+ ĠA Ġ* Ġa Ġ+ ĠB Ġ* Ġb ĊĊ ĠĠĠ Ġans Ġ= Ġmin (ans , Ġprice )ĊĊĊĊ print (ans )


Input:
import math

import statistics

n = int(input())

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

a = [aa-i-1 for i, aa in enumerate(a)]

answer = n*10**20

median_low = statistics.median_low(a)

median_high = statistics.median_high(a)

for m in (median_low,median_high):

  ans=0

  for aa in a:

    ans += abs(aa-m)

  answer = min(ans,answer)

print(answer)

import Ġmath ĊĊ import Ġstatistics ĊĊ n Ġ= Ġint (input ())ĊĊ a Ġ= Ġlist (map (int ,input (). split ()))ĊĊ a Ġ= Ġ[ aa -i - 1 Ġfor Ġi , Ġaa Ġin Ġenumerate (a )]ĊĊ answer Ġ= Ġn * 1 0 ** 2 0 ĊĊ median _low Ġ= Ġstatistics .median _low (a )ĊĊ median _high Ġ= Ġstatistics .median _high (a )ĊĊĊĊ for Ġm Ġin Ġ( median _low , median _high ):ĊĊ Ġ Ġans = 0 ĊĊ Ġ Ġfor Ġaa Ġin Ġa :ĊĊ ĠĠĠ Ġans Ġ+= Ġabs (aa -m )ĊĊ Ġ Ġanswer Ġ= Ġmin (ans , answer )ĊĊ print (answer )Ċ


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

ans = a*x + b*y

for i in range(max(x,y) + 1):

	money = max(0,(x-i)*a) + max(0,(y-i)*b) + 2*i*c

	if money <= ans:

		ans = money

print(ans)

a ,b ,c ,x ,y Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ans Ġ= Ġa *x Ġ+ Ġb *y ĊĊ for Ġi Ġin Ġrange (max (x ,y ) Ġ+ Ġ 1 ):ĊĊ ĉm oney Ġ= Ġmax ( 0 ,( x -i )* a ) Ġ+ Ġmax ( 0 ,( y -i )* b ) Ġ+ Ġ 2 *i *c ĊĊ ĉif Ġmoney Ġ<= Ġans :ĊĊ ĉ ĉans Ġ= Ġmoney ĊĊ print (ans )


Input:
import sys

# from itertools import chain, accumulate

n, m, *abcdef = list(map(int, sys.stdin.buffer.read().split()))

ver_lines = []

hor_lines = []

x_list = set()

y_list = set()

n3 = n * 3

for a, b, c in zip(abcdef[0:n3:3], abcdef[1:n3:3], abcdef[2:n3:3]):

    y_list.add(a)

    y_list.add(b)

    x_list.add(c)

    ver_lines.append((a, b, c))

for d, e, f in zip(abcdef[n3 + 0::3], abcdef[n3 + 1::3], abcdef[n3 + 2::3]):

    y_list.add(d)

    x_list.add(e)

    x_list.add(f)

    hor_lines.append((d, e, f))

x_list.add(0)

y_list.add(0)

x_list = sorted(x_list)

y_list = sorted(y_list)

x_dict = {x: i for i, x in enumerate(x_list, start=1)}

y_dict = {y: i for i, y in enumerate(y_list, start=1)}

row_real = len(x_list)

col_real = len(y_list)

row = row_real + 2

col = col_real + 2

banned_up_ij = [[0] * row for _ in range(col)]

banned_down_ij = [[0] * row for _ in range(col)]

banned_left_ij = [[0] * col for _ in range(row)]

banned_right_ij = [[0] * col for _ in range(row)]

for a, b, c in ver_lines:

    if a > b:

        a, b = b, a

    ai = y_dict[a]

    bi = y_dict[b]

    j = x_dict[c]

    banned_left_ij[j][ai] += 1

    banned_left_ij[j][bi] -= 1

    banned_right_ij[j - 1][ai] += 1

    banned_right_ij[j - 1][bi] -= 1

for d, e, f in hor_lines:

    if e > f:

        e, f = f, e

    i = y_dict[d]

    ej = x_dict[e]

    fj = x_dict[f]

    banned_up_ij[i][ej] += 1

    banned_up_ij[i][fj] -= 1

    banned_down_ij[i - 1][ej] += 1

    banned_down_ij[i - 1][fj] -= 1

banned_up = [0] * (row * col)

banned_down = [0] * (row * col)

banned_left = [0] * (row * col)

banned_right = [0] * (row * col)

for i in range(col):

    ru = banned_up_ij[i]

    rd = banned_down_ij[i]

    ri = row * i

    banned_up[ri] = ru[0]

    banned_down[ri] = rd[0]

    for j in range(1, row):

        banned_up[ri + j] = banned_up[ri + j - 1] + ru[j]

        banned_down[ri + j] = banned_down[ri + j - 1] + rd[j]

for j in range(row):

    rl = banned_left_ij[j]

    rr = banned_right_ij[j]

    banned_left[j] = rl[0]

    banned_right[j] = rr[0]

    for i in range(1, col):

        ri0 = (i - 1) * row

        ri1 = i * row

        banned_left[ri1 + j] = banned_left[ri0 + j] + rl[i]

        banned_right[ri1 + j] = banned_right[ri0 + j] + rr[i]

# banned_up = list(chain.from_iterable(map(accumulate, banned_up_ij)))

# banned_down = list(chain.from_iterable(map(accumulate, banned_down_ij)))

# banned_left = list(chain.from_iterable(zip(*map(accumulate, banned_left_ij))))

# banned_right = list(chain.from_iterable(zip(*map(accumulate, banned_right_ij))))

# for i in range(col):

#     print(walls[i * row:(i + 1) * row])

s = row * y_dict[0] + x_dict[0]

enable = [-1] * row + ([-1] + [0] * (row - 2) + [-1]) * (col - 2) + [-1] * row

# for i in range(col):

#     print(enable[i * row:(i + 1) * row])

q = [s]

moves = [(-row, banned_up), (-1, banned_left), (1, banned_right), (row, banned_down)]

while q:

    c = q.pop()

    if enable[c] == 1:

        continue

    elif enable[c] == -1:

        print('INF')

        exit()

    enable[c] = 1

    for dc, banned in moves:

        if banned[c]:

            continue

        nc = c + dc

        if enable[nc] == 1:

            continue

        q.append(nc)

# for i in range(col):

#     print(enable[i * row:(i + 1) * row])

ans = 0

for i in range(col):

    ri = i * row

    for j in range(row):

        if enable[ri + j] != 1:

            continue

        t = y_list[i - 1]

        b = y_list[i]

        l = x_list[j - 1]

        r = x_list[j]

        ans += (b - t) * (r - l)

print(ans)

import Ġsys ĊĊ # Ġfrom Ġitertools Ġimport Ġchain , Ġaccumulate ĊĊĊĊ n , Ġm , Ġ* abcdef Ġ= Ġlist (map (int , Ġsys .stdin .buffer .read (). split ())) ĊĊĊĊ ver _lines Ġ= Ġ[]ĊĊ hor _lines Ġ= Ġ[]ĊĊ x _list Ġ= Ġset ()ĊĊ y _list Ġ= Ġset ()ĊĊ n 3 Ġ= Ġn Ġ* Ġ 3 ĊĊ for Ġa , Ġb , Ġc Ġin Ġzip ( abcdef [ 0 :n 3 : 3 ], Ġabc def [ 1 :n 3 : 3 ], Ġabc def [ 2 :n 3 : 3 ]) :ĊĊ ĠĠĠ Ġy _list .add (a )ĊĊ ĠĠĠ Ġy _list .add (b )ĊĊ ĠĠĠ Ġx _list .add (c )ĊĊ ĠĠĠ Ġver _lines .append (( a , Ġb , Ġc )) ĊĊĊĊ for Ġd , Ġe , Ġf Ġin Ġzip ( abcdef [n 3 Ġ+ Ġ 0 :: 3 ], Ġabc def [n 3 Ġ+ Ġ 1 :: 3 ], Ġabc def [n 3 Ġ+ Ġ 2 :: 3 ]) :ĊĊ ĠĠĠ Ġy _list .add (d )ĊĊ ĠĠĠ Ġx _list .add (e )ĊĊ ĠĠĠ Ġx _list .add (f )ĊĊ ĠĠĠ Ġhor _lines .append (( d , Ġe , Ġf ))ĊĊ x _list .add ( 0 )ĊĊ y _list .add ( 0 )ĊĊĊĊ x _list Ġ= Ġsorted (x _list )ĊĊ y _list Ġ= Ġsorted (y _list )ĊĊ x _dict Ġ= Ġ{ x : Ġi Ġfor Ġi , Ġx Ġin Ġenumerate (x _list , Ġstart = 1 )}ĊĊ y _dict Ġ= Ġ{ y : Ġi Ġfor Ġi , Ġy Ġin Ġenumerate (y _list , Ġstart = 1 )}ĊĊ row _real Ġ= Ġlen (x _list )ĊĊ col _real Ġ= Ġlen (y _list )ĊĊ row Ġ= Ġrow _real Ġ+ Ġ 2 ĊĊ col Ġ= Ġcol _real Ġ+ Ġ 2 ĊĊ b anned _up _ij Ġ= Ġ[[ 0 ] Ġ* Ġrow Ġfor Ġ_ Ġin Ġrange (col )]ĊĊ b anned _down _ij Ġ= Ġ[[ 0 ] Ġ* Ġrow Ġfor Ġ_ Ġin Ġrange (col )]ĊĊ b anned _left _ij Ġ= Ġ[[ 0 ] Ġ* Ġcol Ġfor Ġ_ Ġin Ġrange (row )]ĊĊ b anned _right _ij Ġ= Ġ[[ 0 ] Ġ* Ġcol Ġfor Ġ_ Ġin Ġrange (row )]ĊĊ for Ġa , Ġb , Ġc Ġin Ġver _lines :ĊĊ ĠĠĠ Ġif Ġa Ġ> Ġb :ĊĊ ĠĠĠĠĠĠĠ Ġa , Ġb Ġ= Ġb , Ġa ĊĊ ĠĠĠ Ġai Ġ= Ġy _dict [a ]ĊĊ ĠĠĠ Ġbi Ġ= Ġy _dict [b ]ĊĊ ĠĠĠ Ġj Ġ= Ġx _dict [c ]ĊĊ ĠĠĠ Ġbanned _left _ij [j ][ ai ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġbanned _left _ij [j ][ bi ] Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġbanned _right _ij [j Ġ- Ġ 1 ][ ai ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġbanned _right _ij [j Ġ- Ġ 1 ][ bi ] Ġ-= Ġ 1 ĊĊ for Ġd , Ġe , Ġf Ġin Ġhor _lines :ĊĊ ĠĠĠ Ġif Ġe Ġ> Ġf :ĊĊ ĠĠĠĠĠĠĠ Ġe , Ġf Ġ= Ġf , Ġe ĊĊ ĠĠĠ Ġi Ġ= Ġy _dict [d ]ĊĊ ĠĠĠ Ġej Ġ= Ġx _dict [e ]ĊĊ ĠĠĠ Ġfj Ġ= Ġx _dict [f ]ĊĊ ĠĠĠ Ġbanned _up _ij [i ][ ej ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġbanned _up _ij [i ][ f j ] Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġbanned _down _ij [i Ġ- Ġ 1 ][ ej ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġbanned _down _ij [i Ġ- Ġ 1 ][ f j ] Ġ-= Ġ 1 ĊĊĊĊ b anned _up Ġ= Ġ[ 0 ] Ġ* Ġ( row Ġ* Ġcol )ĊĊ b anned _down Ġ= Ġ[ 0 ] Ġ* Ġ( row Ġ* Ġcol )ĊĊ b anned _left Ġ= Ġ[ 0 ] Ġ* Ġ( row Ġ* Ġcol )ĊĊ b anned _right Ġ= Ġ[ 0 ] Ġ* Ġ( row Ġ* Ġcol )ĊĊ for Ġi Ġin Ġrange (col ):ĊĊ ĠĠĠ Ġru Ġ= Ġbanned _up _ij [i ]ĊĊ ĠĠĠ Ġrd Ġ= Ġbanned _down _ij [i ]ĊĊ ĠĠĠ Ġri Ġ= Ġrow Ġ* Ġi ĊĊ ĠĠĠ Ġbanned _up [ ri ] Ġ= Ġru [ 0 ]ĊĊ ĠĠĠ Ġbanned _down [ ri ] Ġ= Ġrd [ 0 ]ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 , Ġrow ):ĊĊ ĠĠĠĠĠĠĠ Ġbanned _up [ ri Ġ+ Ġj ] Ġ= Ġbanned _up [ ri Ġ+ Ġj Ġ- Ġ 1 ] Ġ+ Ġru [j ]ĊĊ ĠĠĠĠĠĠĠ Ġbanned _down [ ri Ġ+ Ġj ] Ġ= Ġbanned _down [ ri Ġ+ Ġj Ġ- Ġ 1 ] Ġ+ Ġrd [j ]ĊĊ for Ġj Ġin Ġrange (row ):ĊĊ ĠĠĠ Ġrl Ġ= Ġbanned _left _ij [j ]ĊĊ ĠĠĠ Ġrr Ġ= Ġbanned _right _ij [j ]ĊĊ ĠĠĠ Ġbanned _left [j ] Ġ= Ġrl [ 0 ]ĊĊ ĠĠĠ Ġbanned _right [j ] Ġ= Ġrr [ 0 ]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġcol ):ĊĊ ĠĠĠĠĠĠĠ Ġri 0 Ġ= Ġ( i Ġ- Ġ 1 ) Ġ* Ġrow ĊĊ ĠĠĠĠĠĠĠ Ġri 1 Ġ= Ġi Ġ* Ġrow ĊĊ ĠĠĠĠĠĠĠ Ġbanned _left [ ri 1 Ġ+ Ġj ] Ġ= Ġbanned _left [ ri 0 Ġ+ Ġj ] Ġ+ Ġrl [i ]ĊĊ ĠĠĠĠĠĠĠ Ġbanned _right [ ri 1 Ġ+ Ġj ] Ġ= Ġbanned _right [ ri 0 Ġ+ Ġj ] Ġ+ Ġrr [i ]ĊĊĊĊ # Ġbanned _up Ġ= Ġlist (chain .from _iter able (map ( accumulate , Ġbanned _up _ij )))ĊĊ # Ġbanned _down Ġ= Ġlist (chain .from _iter able (map ( accumulate , Ġbanned _down _ij )))ĊĊ # Ġbanned _left Ġ= Ġlist (chain .from _iter able (zip (* map ( accumulate , Ġbanned _left _ij ))))ĊĊ # Ġbanned _right Ġ= Ġlist (chain .from _iter able (zip (* map ( accumulate , Ġbanned _right _ij )))) ĊĊĊĊ # Ġfor Ġi Ġin Ġrange (col ):ĊĊ # ĠĠĠĠ Ġprint (w alls [i Ġ* Ġrow :( i Ġ+ Ġ 1 ) Ġ* Ġrow ])ĊĊ ĊĊ s Ġ= Ġrow Ġ* Ġy _dict [ 0 ] Ġ+ Ġx _dict [ 0 ]ĊĊ enable Ġ= Ġ[- 1 ] Ġ* Ġrow Ġ+ Ġ( [- 1 ] Ġ+ Ġ[ 0 ] Ġ* Ġ( row Ġ- Ġ 2 ) Ġ+ Ġ[- 1 ]) Ġ* Ġ( col Ġ- Ġ 2 ) Ġ+ Ġ[- 1 ] Ġ* Ġrow ĊĊĊĊ # Ġfor Ġi Ġin Ġrange (col ):ĊĊ # ĠĠĠĠ Ġprint (enable [i Ġ* Ġrow :( i Ġ+ Ġ 1 ) Ġ* Ġrow ])ĊĊ ĊĊ q Ġ= Ġ[ s ]ĊĊ moves Ġ= Ġ[ (- row , Ġbanned _up ), Ġ(- 1 , Ġbanned _left ), Ġ( 1 , Ġbanned _right ), Ġ( row , Ġbanned _down )]ĊĊ while Ġq :ĊĊ ĠĠĠ Ġc Ġ= Ġq .pop ()ĊĊ ĠĠĠ Ġif Ġenable [c ] Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġelif Ġenable [c ] Ġ== Ġ- 1 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (' INF ')ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊ ĠĠĠ Ġenable [c ] Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġdc , Ġbanned Ġin Ġmoves :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġbanned [c ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠ Ġnc Ġ= Ġc Ġ+ Ġdc ĊĊ ĠĠĠĠĠĠĠ Ġif Ġenable [ nc ] Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠ Ġq .append (nc )ĊĊ # Ġfor Ġi Ġin Ġrange (col ):ĊĊ # ĠĠĠĠ Ġprint (enable [i Ġ* Ġrow :( i Ġ+ Ġ 1 ) Ġ* Ġrow ])ĊĊ ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (col ):ĊĊ ĠĠĠ Ġri Ġ= Ġi Ġ* Ġrow ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (row ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġenable [ ri Ġ+ Ġj ] Ġ!= Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠ Ġt Ġ= Ġy _list [i Ġ- Ġ 1 ]ĊĊ ĠĠĠĠĠĠĠ Ġb Ġ= Ġy _list [i ]ĊĊ ĠĠĠĠĠĠĠ Ġl Ġ= Ġx _list [j Ġ- Ġ 1 ]ĊĊ ĠĠĠĠĠĠĠ Ġr Ġ= Ġx _list [j ]ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ( b Ġ- Ġt ) Ġ* Ġ( r Ġ- Ġl )ĊĊ print (ans )Ċ


Input:
def main():

    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[-1]))

if __name__ == "__main__":

    main()

def Ġmain ():ĊĊ ĠĠĠ Ġ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 [- 1 ])) ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
def slove():

    import sys

    import heapq

    import collections

    input = sys.stdin.readline

    x, y, z, k = list(map(int, input().rstrip('\n').split()))

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

    a.sort(reverse=True)

    b = list(map(int, input().rstrip('\n').split()))

    b.sort(reverse=True)

    c = list(map(int, input().rstrip('\n').split()))

    c.sort(reverse=True)

    q = [[-(a[0] + b[0] + c[0]), 0, 0, 0]]

    heapq.heapify(q)

    fq = collections.defaultdict(list)

    fq[(-(a[0] + b[0] + c[0]), 0, 0, 0), 1] = 1

    t = 0

    for _ in range(k):

        if len(q) != 0:

            p = heapq.heappop(q)

            t = p[0]

            aq = p[1]

            bq = p[2]

            cq = p[3]

            if aq + 1 < len(a):

                if (-(a[aq+1] + b[bq] + c[cq]), aq+1, bq, cq) not in fq:

                    heapq.heappush(q, [-(a[aq+1] + b[bq] + c[cq]), aq+1, bq, cq])

                    fq[(-(a[aq+1] + b[bq] + c[cq]), aq+1, bq, cq)] = 1

            if bq + 1 < len(b):

                if (-(a[aq] + b[bq+1] + c[cq]), aq, bq+1, cq) not in fq:

                    heapq.heappush(q, [-(a[aq] + b[bq+1] + c[cq]), aq, bq+1, cq])

                    fq[(-(a[aq] + b[bq+1] + c[cq]), aq, bq+1, cq)] = 1

            if cq + 1 < len(c):

                if (-(a[aq] + b[bq] + c[cq+1]), aq, bq, cq+1) not in fq:

                    heapq.heappush(q, [-(a[aq] + b[bq] + c[cq+1]), aq, bq, cq+1])

                    fq[(-(a[aq] + b[bq] + c[cq+1]), aq, bq, cq+1)] = 1

        print((-t))

if __name__ == '__main__':

    slove()

def Ġslo ve ():ĊĊ ĠĠĠ Ġimport Ġsys ĊĊ ĠĠĠ Ġimport Ġheapq ĊĊ ĠĠĠ Ġimport Ġcollections ĊĊ ĠĠĠ Ġinput Ġ= Ġsys .stdin .readline ĊĊ ĠĠĠ Ġx , Ġy , Ġz , Ġk Ġ= Ġlist (map (int , Ġinput (). rstrip ('\ n '). split ()))ĊĊ ĠĠĠ Ġa Ġ= Ġlist (map (int , Ġinput (). rstrip ('\ n '). split ()))ĊĊ ĠĠĠ Ġa .sort (reverse =True )ĊĊ ĠĠĠ Ġb Ġ= Ġlist (map (int , Ġinput (). rstrip ('\ n '). split ()))ĊĊ ĠĠĠ Ġb .sort (reverse =True )ĊĊ ĠĠĠ Ġc Ġ= Ġlist (map (int , Ġinput (). rstrip ('\ n '). split ()))ĊĊ ĠĠĠ Ġc .sort (reverse =True )ĊĊ ĠĠĠ Ġq Ġ= Ġ[[ -( a [ 0 ] Ġ+ Ġb [ 0 ] Ġ+ Ġc [ 0 ]), Ġ 0 , Ġ 0 , Ġ 0 ]]ĊĊ ĠĠĠ Ġheapq .heap ify (q )ĊĊ ĠĠĠ Ġfq Ġ= Ġcollections .default dict (list )ĊĊ ĠĠĠ Ġfq [ (-( a [ 0 ] Ġ+ Ġb [ 0 ] Ġ+ Ġc [ 0 ]), Ġ 0 , Ġ 0 , Ġ 0 ), Ġ 1 ] Ġ= Ġ 1 ĊĊ ĠĠĠ Ġt Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġ_ Ġin Ġrange (k ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġlen (q ) Ġ!= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġp Ġ= Ġheapq .he app op (q )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ= Ġp [ 0 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġa q Ġ= Ġp [ 1 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbq Ġ= Ġp [ 2 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcq Ġ= Ġp [ 3 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġa q Ġ+ Ġ 1 Ġ< Ġlen (a ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ( -( a [a q + 1 ] Ġ+ Ġb [b q ] Ġ+ Ġc [c q ]), Ġa q + 1 , Ġbq , Ġcq ) Ġnot Ġin Ġfq :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (q , Ġ[ -( a [a q + 1 ] Ġ+ Ġb [b q ] Ġ+ Ġc [c q ]), Ġa q + 1 , Ġbq , Ġcq ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfq [ (-( a [a q + 1 ] Ġ+ Ġb [b q ] Ġ+ Ġc [c q ]), Ġa q + 1 , Ġbq , Ġcq )] Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġbq Ġ+ Ġ 1 Ġ< Ġlen (b ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ( -( a [a q ] Ġ+ Ġb [b q + 1 ] Ġ+ Ġc [c q ]), Ġa q , Ġbq + 1 , Ġcq ) Ġnot Ġin Ġfq :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (q , Ġ[ -( a [a q ] Ġ+ Ġb [b q + 1 ] Ġ+ Ġc [c q ]), Ġa q , Ġbq + 1 , Ġcq ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfq [ (-( a [a q ] Ġ+ Ġb [b q + 1 ] Ġ+ Ġc [c q ]), Ġa q , Ġbq + 1 , Ġcq )] Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġcq Ġ+ Ġ 1 Ġ< Ġlen (c ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ( -( a [a q ] Ġ+ Ġb [b q ] Ġ+ Ġc [c q + 1 ]), Ġa q , Ġbq , Ġcq + 1 ) Ġnot Ġin Ġfq :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (q , Ġ[ -( a [a q ] Ġ+ Ġb [b q ] Ġ+ Ġc [c q + 1 ]), Ġa q , Ġbq , Ġcq + 1 ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfq [ (-( a [a q ] Ġ+ Ġb [b q ] Ġ+ Ġc [c q + 1 ]), Ġa q , Ġbq , Ġcq + 1 )] Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġprint ((- t )) ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġslo ve ()Ċ


Input:
N = int(input())

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

players = [0 for _ in range(N)]

for play in list(zip(*score)):

    for i, p in enumerate(play):

        if play.count(p) == 1:

            players[i] += p

print(*players, sep='\n')

N Ġ= Ġint (input ())ĊĊ score Ġ= Ġ[ list (map (int , Ġinput (). split ())) Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ players Ġ= Ġ[ 0 Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ for Ġplay Ġin Ġlist (zip (* score )) :ĊĊ ĠĠĠ Ġfor Ġi , Ġp Ġin Ġenumerate (play ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġplay .count (p ) Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġplayers [i ] Ġ+= Ġp ĊĊ print (* players , Ġsep ='\ n ')Ċ


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

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

dp = [False]*(k+1)

for stones in range(k+1):

    for x in arr:

        if stones >= x and dp[stones-x] == False:

            dp[stones] = True

if dp[k]:

    print("First")

else:

    print("Second")

n ,k Ġ= Ġlist (map (int ,input (). split ()))ĊĊ arr Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊ dp Ġ= Ġ[ False ]*( k + 1 )ĊĊĊĊ for Ġstones Ġin Ġrange (k + 1 ):ĊĊ ĠĠĠ Ġfor Ġx Ġin Ġarr :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġstones Ġ>= Ġx Ġand Ġdp [ stones -x ] Ġ== ĠFalse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdp [ stones ] Ġ= ĠTrue ĊĊĊĊ if Ġdp [k ]:ĊĊ ĠĠĠ Ġprint (" First ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" Second ")Ċ


Input:
W = input().lower()

s = []

while True:

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

    if(T[0] == "END_OF_TEXT"):

        break

    else:

        for i in range(len(T)):

            s.append(T[i].lower())

ans = 0

for i in range(len(s)):

    if(s[i] == W):

        ans += 1

print(ans)

W Ġ= Ġinput (). lower ()ĊĊ s Ġ= Ġ[]ĊĊ while ĠTrue :ĊĊ ĠĠĠ ĠT Ġ= Ġlist (map (str , Ġinput (). split ()))ĊĊ ĠĠĠ Ġif (T [ 0 ] Ġ== Ġ" END _OF _TEXT ") :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (len (T )) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġs .append (T [i ]. lower ())ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (len (s )) :ĊĊ ĠĠĠ Ġif (s [i ] Ġ== ĠW ):ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ print (ans )


Input:
import math

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

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


Input:
import sys

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines

N = int(readline())

S = read().split()

S = sorted(S)

ls = [[] for i in range(N + 1)]

max_num = 0

left = 0

right = 0

while right < N:

    while right < N and S[left] == S[right]:

        right += 1

    if (right  - left) >= max_num:

        ls[right - left].append(S[left].decode())

        max_num = right - left

    left = right

print(('\n'.join(ls[max_num])))

import Ġsys ĊĊ read Ġ= Ġsys .stdin .buffer .read ĊĊ read line Ġ= Ġsys .stdin .buffer .readline ĊĊ read lines Ġ= Ġsys .stdin .buffer .readlines ĊĊ N Ġ= Ġint (read line ())ĊĊ S Ġ= Ġread (). split ()ĊĊĊĊ S Ġ= Ġsorted (S )ĊĊ ls Ġ= Ġ[[] Ġfor Ġi Ġin Ġrange (N Ġ+ Ġ 1 )]ĊĊ max _num Ġ= Ġ 0 ĊĊ left Ġ= Ġ 0 ĊĊ right Ġ= Ġ 0 ĊĊ while Ġright Ġ< ĠN :ĊĊ ĠĠĠ Ġwhile Ġright Ġ< ĠN Ġand ĠS [left ] Ġ== ĠS [right ]:ĊĊ ĠĠĠĠĠĠĠ Ġright Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġ( right Ġ Ġ- Ġleft ) Ġ>= Ġmax _num :ĊĊ ĠĠĠĠĠĠĠ Ġls [right Ġ- Ġleft ]. append (S [left ]. decode ())ĊĊ ĠĠĠĠĠĠĠ Ġmax _num Ġ= Ġright Ġ- Ġleft ĊĊ ĠĠĠ Ġleft Ġ= Ġright ĊĊ ĠĠĠĠĊĊ print ( ('\ n '. join (ls [max _num ])))Ċ


Input:
# temp

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

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

dp = [0] + [float("inf")]*(10**5)

for i in range(n):

    for j in range(10**5,wv[i][1]-1,-1):

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

res = 0

for v,e in enumerate(dp):

    if e <= w:

        res = v

print(res)

# Ġtemp ĊĊ n ,w Ġ= Ġlist (map (int ,input (). split ()))ĊĊ w v Ġ= Ġ[ tuple (map (int ,input (). split ())) Ġfor Ġi Ġin Ġrange (n )] ĊĊĊĊ dp Ġ= Ġ[ 0 ] Ġ+ Ġ[ float (" inf ")] *( 1 0 ** 5 )ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 0 ** 5 ,w v [i ][ 1 ]- 1 ,- 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġdp [j ] Ġ= Ġmin (dp [j ], dp [j -w v [i ][ 1 ]] + w v [i ][ 0 ])ĊĊ ĊĊ res Ġ= Ġ 0 ĊĊ for Ġv ,e Ġin Ġenumerate (dp ):ĊĊ ĠĠĠ Ġif Ġe Ġ<= Ġw :ĊĊ ĠĠĠĠĠĠĠ Ġres Ġ= Ġv ĊĊ print (res )


Input:
def main():

  n = int(input())

  dp = [0]*(n+1)

  dp[0] = 1

  mod = pow(10, 9) + 7

  for i in range(n+1):

    for j in range(i-2):

      dp[i] += dp[j]

      dp[i] %= mod

  print((dp[n]))

if __name__ == "__main__":

  main()

def Ġmain ():ĊĊ Ġ Ġn Ġ= Ġint (input ())ĊĊ ĠĠĊĊ Ġ Ġdp Ġ= Ġ[ 0 ]*( n + 1 )ĊĊ Ġ Ġdp [ 0 ] Ġ= Ġ 1 ĊĊ Ġ Ġmod Ġ= Ġpow ( 1 0 , Ġ 9 ) Ġ+ Ġ 7 ĊĊ Ġ Ġfor Ġi Ġin Ġrange (n + 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (i - 2 ):ĊĊ ĠĠĠĠĠ Ġdp [i ] Ġ+= Ġdp [j ]ĊĊ ĠĠĠĠĠ Ġdp [i ] Ġ%= Ġmod ĊĊ ĠĠĊĊ Ġ Ġprint (( dp [n ])) ĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ Ġ Ġmain ()


Input:
class Queue:

    def __init__(self,values):

        self.values = values

    def empty(self):

        if len(self.values) == 0:

            return True

        else:

            return False

    def enqueue(self,v):

        self.values.append(v)

    def dequeue(self):

        if len(self.values) <= 0:

            raise

        else:

            v = self.values[0]

            del self.values[0]

            return v

n,q = list(map(int,input().split(' ')))

processes = []

for i in range(n):

    n,t = input().split(' ')

    processes.append((n,int(t)))

queue = Queue(processes)

clock = 0

done = []

while not queue.empty():

    p = queue.dequeue()

    n = p[0]

    t = p[1]

    if t <= q:

        clock+=t

        done.append((n,clock))

    else:

        queue.enqueue((n,t-q))

        clock+=q

for p in done:

    print(p[0],p[1])

class ĠQueue :ĊĊ ĠĠĠ Ġdef Ġ__ init __( self , values ):ĊĊ ĠĠĠĠĠĠĠ Ġself .values Ġ= Ġvalues ĊĊĊĊ ĠĠĠ Ġdef Ġempty (self ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġlen (self .values ) Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠTrue ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠFalse ĊĊĊĊ ĠĠĠ Ġdef Ġenqueue (self ,v ):ĊĊ ĠĠĠĠĠĠĠ Ġself .values .append (v )ĊĊĊĊ ĠĠĠ Ġdef Ġdequeue (self ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġlen (self .values ) Ġ<= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġraise ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġv Ġ= Ġself .values [ 0 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdel Ġself .values [ 0 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġv ĊĊĊĊ n ,q Ġ= Ġlist (map (int ,input (). split (' Ġ' )))ĊĊ process es Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġn ,t Ġ= Ġinput (). split (' Ġ')ĊĊ ĠĠĠ Ġprocesses .append (( n ,int (t )) )ĊĊĊĊ queue Ġ= ĠQueue (process es )ĊĊĊĊ clock Ġ= Ġ 0 ĊĊ done Ġ= Ġ[]ĊĊ while Ġnot Ġqueue .empty ():ĊĊ ĠĠĠ Ġp Ġ= Ġqueue .dequeue ()ĊĊ ĠĠĠ Ġn Ġ= Ġp [ 0 ]ĊĊ ĠĠĠ Ġt Ġ= Ġp [ 1 ]ĊĊ ĠĠĠ Ġif Ġt Ġ<= Ġq :ĊĊ ĠĠĠĠĠĠĠ Ġclock += t ĊĊ ĠĠĠĠĠĠĠ Ġdone .append (( n ,c lock ))ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġqueue .enqueue (( n ,t -q ))ĊĊ ĠĠĠĠĠĠĠ Ġclock += q ĊĊĊĊ for Ġp Ġin Ġdone :ĊĊ ĠĠĠ Ġprint (p [ 0 ], p [ 1 ])


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

if r - l > 2019:

    print((0))

else:

    tres = 2019

    for i in range(l,r):

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

            mod = (i % 2019) * (j % 2019) % 2019

            tres = min(tres,mod)

    print(tres)

l ,r Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊ if Ġr Ġ- Ġl Ġ> Ġ 2 0 1 9 :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ else :ĊĊ ĠĠĠ Ġtres Ġ= Ġ 2 0 1 9 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (l ,r ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (i + 1 ,r + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmod Ġ= Ġ( i Ġ% Ġ 2 0 1 9 ) Ġ* Ġ( j Ġ% Ġ 2 0 1 9 ) Ġ% Ġ 2 0 1 9 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġtres Ġ= Ġmin (t res , mod )ĊĊ ĠĠĠ Ġprint (t res )Ċ


Input:
# 2019-11-12 22:21:08(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

# from scipy.misc import comb # float

# import numpy as np

def main():

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

    all_words = []

    for i in range(1, len(s) + 1):

        for letters in itertools.product('ATCG', repeat=i):

            word = ''.join(letters)

            all_words.append(word)

    for i in range(len(all_words)-1, 0-1, -1):

        if all_words[i] in s:

            print((len(all_words[i])))

            sys.exit()

    print((0))

if __name__ == "__main__":

    main()

# Ġ 2 0 1 9 - 1 1 - 1 2 Ġ 2 2 : 2 1 : 0 8 (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 ĊĊ # Ġfrom Ġscipy .misc Ġimport Ġcomb Ġ# Ġfloat ĊĊ # Ġimport Ġnumpy Ġas Ġnp ĠĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġs Ġ= Ġsys .stdin .readline (). rstrip ()ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġall _words Ġ= Ġ[]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 , Ġlen (s ) Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġletters Ġin Ġitertools .product (' AT CG ', Ġrepeat =i ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġword Ġ= Ġ''. join ( letters )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġall _words .append (word )ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (len (all _words )- 1 , Ġ 0 - 1 , Ġ- 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġall _words [i ] Ġin Ġs :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (( len (all _words [i ])) )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsys .exit ()ĊĊ ĠĠĠ Ġprint (( 0 )) ĊĊĊĊĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
#                         author:  kagemeka

#                         created: 2019-11-08 14:51:29(JST)

## internal modules

import sys

# import collections

# import math

# import string

# import bisect

# import re

# import itertools

import statistics

# import functools

# import operator

## external modules

# import scipy.special   # if use comb function on AtCoder,

# import scipy.misc      # select scipy.misc.comb (old version)

def main():

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

    for i in range(n):

        a[i] -= (i + 1)

    if n % 2 != 0:

        b = statistics.median(a)

    else:

        if a.count(statistics.median_high(a)) >= a.count(statistics.median_low(a)):

            b = statistics.median_high(a)

        else:

            b = statistics.median_low(a)

    ans = sum([abs(a[i] - b) for i in range(n)])

    print(ans)

if __name__ == "__main__":

    # execute only if run as a script

    main()

# ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġauthor : Ġ Ġk agem eka ĠĊĊ # ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġcreated : Ġ 2 0 1 9 - 1 1 - 0 8 Ġ 1 4 : 5 1 : 2 9 (J ST )ĊĊ ## Ġinternal Ġmodules ĊĊ import Ġsys ĊĊ # Ġimport Ġcollections ĊĊ # Ġimport Ġmath ĊĊ # Ġimport Ġstring ĊĊ # Ġimport Ġbis ect ĊĊ # Ġimport Ġre ĊĊ # Ġimport Ġitertools ĊĊ import Ġstatistics ĊĊ # Ġimport Ġfunctools ĊĊ # Ġimport Ġoperator ĊĊ ## Ġexternal Ġmodules ĊĊ # Ġimport Ġscipy .special ĠĠ Ġ# Ġif Ġuse Ġcomb Ġfunction Ġon ĠAt Coder , ĠĊĊ # Ġimport Ġscipy .misc ĠĠĠĠĠ Ġ# Ġselect Ġscipy .misc .com b Ġ( old Ġversion ) ĠĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġn , Ġ* a Ġ= Ġ( int (x ) Ġfor Ġx Ġin Ġsys .stdin .read (). split ())ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġa [i ] Ġ-= Ġ( i Ġ+ Ġ 1 )ĊĊĊĊ ĠĠĠ Ġif Ġn Ġ% Ġ 2 Ġ!= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġb Ġ= Ġstatistics .median (a )ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġa .count (stat istics .median _high (a )) Ġ>= Ġa .count (stat istics .median _low (a )) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġb Ġ= Ġstatistics .median _high (a )ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġb Ġ= Ġstatistics .median _low (a )ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġans Ġ= Ġsum ([ abs (a [i ] Ġ- Ġb ) Ġfor Ġi Ġin Ġrange (n )])ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġ# Ġexecute Ġonly Ġif Ġrun Ġas Ġa Ġscript ĊĊ ĠĠĠ Ġmain () ĊĊĊĊĊ


Input:
def findSumDigit(num):

    global total

    total = ""

    while num > 0:

        total += str(num % 10)

        num //= 10

    return total

def main():

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

    ans = 0

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

        tmp = str(findSumDigit(i))

        if tmp == str(i):

            ans += 1

    print(ans)

if __name__ == '__main__':

    main()

def Ġfind Sum Digit (num ):ĊĊ ĠĠĠ Ġglobal Ġtotal ĊĊ ĠĠĠ Ġtotal Ġ= Ġ""ĊĊ ĠĠĠ Ġwhile Ġnum Ġ> Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġtotal Ġ+= Ġstr (num Ġ% Ġ 1 0 )ĊĊ ĠĠĠĠĠĠĠ Ġnum Ġ//= Ġ 1 0 ĊĊ ĠĠĠ Ġreturn Ġtotal ĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġa ,b Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (a ,b + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġtmp Ġ= Ġstr (find Sum Digit (i ))ĊĊ ĠĠĠĠĠĠĠ Ġif Ġtmp Ġ== Ġstr (i ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()


Input:
N = int(input())

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

now = a[0]

count = 1

c = 0

for i in range(10**6):

    if now != 2:

        count += 1

        now = a[now - 1]

    else:

        print(count)

        c = 1

        break

if c == 0:

    print((-1))

N Ġ= Ġint (input ())ĊĊ a Ġ= Ġ[ int (input ()) Ġfor Ġi Ġin Ġrange (N )]ĊĊ now Ġ= Ġa [ 0 ]ĊĊ count Ġ= Ġ 1 ĊĊ c Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 0 ** 6 ):ĊĊ ĠĠĠ Ġif Ġnow Ġ!= Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġnow Ġ= Ġa [now Ġ- Ġ 1 ]ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġprint (count )ĊĊ ĠĠĠĠĠĠĠ Ġc Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ if Ġc Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġprint ((- 1 ))Ċ


Input:
n=int(input())

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

def f():

 for i in range(n-1):

  d=a[i][:];d[3],d[4]=d[4],d[3]

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

   e=a[j][:];e[3],e[4]=e[4],e[3]

   for p in([0,1,2,3,4,5],[1,5,2,0,4,3],[2,1,5,3,0,4],[3,0,2,5,4,1],[4,1,0,3,5,2],[5,1,4,3,2,0]):

    f=[d[k]for k in p]

    if f[0]==e[0]and f[5]==e[5]:

     f=f[1:5]*2

     for k in range(4):

      if f[k:k+4]==e[1:5]:return'No'

 return'Yes'

print((f()))

n =int (input ())ĊĊ a =[ list (map (int ,input (). split ())) for Ġ_ Ġin Ġrange (n )]ĊĊ def Ġf ():ĊĊ Ġfor Ġi Ġin Ġrange (n - 1 ):ĊĊ Ġ Ġd =a [i ][: ]; d [ 3 ], d [ 4 ]= d [ 4 ], d [ 3 ]ĊĊ Ġ Ġfor Ġj Ġin Ġrange (i + 1 ,n ):ĊĊ ĠĠ Ġe =a [j ][: ]; e [ 3 ], e [ 4 ]= e [ 4 ], e [ 3 ]ĊĊ ĠĠ Ġfor Ġp Ġin ([ 0 , 1 , 2 , 3 , 4 , 5 ],[ 1 , 5 , 2 , 0 , 4 , 3 ],[ 2 , 1 , 5 , 3 , 0 , 4 ],[ 3 , 0 , 2 , 5 , 4 , 1 ],[ 4 , 1 , 0 , 3 , 5 , 2 ],[ 5 , 1 , 4 , 3 , 2 , 0 ]) :ĊĊ ĠĠĠ Ġf =[ d [k ] for Ġk Ġin Ġp ]ĊĊ ĠĠĠ Ġif Ġf [ 0 ]== e [ 0 ] and Ġf [ 5 ]== e [ 5 ]:ĊĊ ĠĠĠĠ Ġf =f [ 1 : 5 ]* 2 ĊĊ ĠĠĠĠ Ġfor Ġk Ġin Ġrange ( 4 ):ĊĊ ĠĠĠĠĠ Ġif Ġf [k :k + 4 ]== e [ 1 : 5 ]: return ' No 'ĊĊ Ġreturn ' Yes 'ĊĊ print (( f ()))Ċ


Input:
N = int(input())

ans = 0

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

    if len(str(i))%2==1:

        ans += 1

print(ans)

N Ġ= Ġint (input ())ĊĊ ĊĊ ans Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange ( 1 , ĠN + 1 ):ĊĊ ĠĠĠ Ġif Ġlen (str (i )) % 2 == 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊĊĊ print (ans )


Input:
import itertools

from collections import Counter

N = int(input())

src = [input() for i in range(N)]

ctr = Counter()

for s in src:

    ctr[s[0]] += 1

ans = 0

for ptn in itertools.combinations('MARCH',3):

    a,b,c = ptn

    ans += ctr[a]*ctr[b]*ctr[c]

print(ans)

import Ġitertools ĊĊ from Ġcollections Ġimport ĠCounter ĊĊ N Ġ= Ġint (input ())ĊĊ src Ġ= Ġ[ input () Ġfor Ġi Ġin Ġrange (N )]ĊĊ ctr Ġ= ĠCounter ()ĊĊ for Ġs Ġin Ġsrc :ĊĊ ĠĠĠ Ġctr [s [ 0 ]] Ġ+= Ġ 1 ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġp tn Ġin Ġitertools .com binations (' M ARCH ', 3 ):ĊĊ ĠĠĠ Ġa ,b ,c Ġ= Ġp tn ĊĊ ĠĠĠ Ġans Ġ+= Ġctr [a ]* ctr [b ]* ctr [c ]ĊĊ print (ans )


Input:
N = int(input())

count = 0

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

    num_dig = 0

    ii = i

    while ii > 0:

        ii = int(ii / 10)

        num_dig += 1

    if num_dig % 2 != 0:

        count += 1

print(count)

N Ġ= Ġint (input ())ĊĊ ĊĊ count Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 , ĠN Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġnum _d ig Ġ= Ġ 0 ĊĊ ĠĠĠ Ġii Ġ= Ġi ĊĊ ĠĠĠ Ġwhile Ġii Ġ> Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġii Ġ= Ġint (ii Ġ/ Ġ 1 0 )ĊĊ ĠĠĠĠĠĠĠ Ġnum _d ig Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġnum _d ig Ġ% Ġ 2 Ġ!= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊĊĊ print (count )


Input:
from string import ascii_lowercase as lower

print((lower[lower.find(input())+1]))

from Ġstring Ġimport Ġascii _lowercase Ġas Ġlower ĊĊ print (( lower [ lower .find (input ()) + 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] = SR()

    return l

mod = 1000000007

#A

"""

def gcd(a,b):

    if a == 0:

        return b

    return gcd(b%a,a)

n = I()

a = IR(n)

l = a[0]

for i in range(1,n):

    g = gcd(l,a[i])

    l *= a[i]//g

print(l)

"""

#B

n = I()

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

for i in range(n-1):

    a,b,c = LI()

    a -= 1

    b -= 1

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

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

Q,k = LI()

d = [-1 for i in range(n)]

d[k-1] = 0

q = deque()

q.append(k-1)

while q:

    x = q.pop()

    for y,c in v[x]:

        if d[y] == -1:

            d[y] = d[x]+c

            q.append(y)

for i in range(Q):

    x,y = LI()

    x -= 1

    y -= 1

    print((d[x]+d[y]))

#C

#D

#E

#F

#G

#H

#I

#J

#K

#L

#M

#N

#O

#P

#Q

#R

#S

#T

#! 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 Ġgcd (a ,b ):ĊĊ ĠĠĠ Ġif Ġa Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġb ĊĊ ĠĠĠ Ġreturn Ġgcd (b % a ,a )ĊĊ n Ġ= ĠI ()ĊĊ a Ġ= ĠIR (n )ĊĊ l Ġ= Ġa [ 0 ]ĊĊ for Ġi Ġin Ġrange ( 1 ,n ):ĊĊ ĠĠĠ Ġg Ġ= Ġgcd (l ,a [i ])ĊĊ ĠĠĠ Ġl Ġ*= Ġa [i ] // g ĊĊ print (l )ĊĊ """ ĊĊĊĊ # B ĊĊ n Ġ= ĠI ()ĊĊ v Ġ= Ġ[[] Ġfor Ġi Ġin Ġrange (n )]ĊĊ for Ġi Ġin Ġrange (n - 1 ):ĊĊ ĠĠĠ Ġa ,b ,c Ġ= ĠLI ()ĊĊ ĠĠĠ Ġa Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġb Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġv [a ]. append ([ b ,c ])ĊĊ ĠĠĠ Ġv [b ]. append ([ a ,c ])ĊĊ Q ,k Ġ= ĠLI ()ĊĊ d Ġ= Ġ[- 1 Ġfor Ġi Ġin Ġrange (n )]ĊĊ d [k - 1 ] Ġ= Ġ 0 ĊĊ q Ġ= Ġdeque ()ĊĊ q .append (k - 1 )ĊĊ while Ġq :ĊĊ ĠĠĠ Ġx Ġ= Ġq .pop ()ĊĊ ĠĠĠ Ġfor Ġy ,c Ġin Ġv [x ]:ĊĊ ĠĠĠĠĠĠĠ Ġif Ġd [y ] Ġ== Ġ- 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġd [y ] Ġ= Ġd [x ]+ c ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġq .append (y )ĊĊ for Ġi Ġin Ġrange (Q ):ĊĊ ĠĠĠ Ġx ,y Ġ= ĠLI ()ĊĊ ĠĠĠ Ġx Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġy Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġprint (( d [x ]+ d [y ]))ĊĊ # C ĊĊĊĊ # D ĊĊĊĊ # E ĊĊĊĊ # F ĊĊĊĊ # G ĊĊĊĊ # H ĊĊĊĊ # I ĊĊĊĊ # J ĊĊĊĊ # K ĊĊĊĊ # L ĊĊĊĊ # M ĊĊĊĊ # N ĊĊĊĊ # O ĊĊĊĊ # P ĊĊĊĊ # Q ĊĊĊĊ # R ĊĊĊĊ # S ĊĊĊĊ # T Ċ


Input:
import string

w = input()

for a in string.ascii_lowercase:

    cnt = 0

    for t in w:

        if t == a:

            cnt = cnt + 1

    if cnt % 2 == 1:

        print("No")

        exit()

print("Yes")

import Ġstring ĊĊ w Ġ= Ġinput ()ĊĊ for Ġa Ġin Ġstring .ascii _lowercase :ĊĊ ĠĠĠ Ġcnt Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġt Ġin Ġw :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġt Ġ== Ġa :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ= Ġcnt Ġ+ Ġ 1 ĊĊ ĠĠĠ Ġif Ġcnt Ġ% Ġ 2 Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (" No ")ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊĊĊ print (" Yes ")


Input:
mod = 10**9+7

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

l = [0]*n

for _ in range(m):

  l[int(input())-1] = 1

s = 0

t = 1

for i in range(n):

  if l[i] > 0:

    t, s = 0, t

  else:

    t, s = (s+t)%mod, t

print(t)

mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊ n , Ġm Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ l Ġ= Ġ[ 0 ]* n ĊĊ for Ġ_ Ġin Ġrange (m ):ĊĊ Ġ Ġl [int (input ()) - 1 ] Ġ= Ġ 1 ĊĊĊĊ s Ġ= Ġ 0 ĊĊ t Ġ= Ġ 1 ĊĊĊĊ for Ġi Ġin Ġrange (n ):ĊĊ Ġ Ġif Ġl [i ] Ġ> Ġ 0 :ĊĊ ĠĠĠ Ġt , Ġs Ġ= Ġ 0 , Ġt ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ Ġt , Ġs Ġ= Ġ( s +t )% mod , Ġt ĊĊĊĊ print (t )


Input:
N,M = [int(c) for c in input().split()]

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

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

for i in range(N):

    mi = 2*10**9

    for j in range(M):

        tmp = abs(ab[i][0]-cd[j][0])+abs(ab[i][1]-cd[j][1])

        if mi > tmp:

            mi = tmp

            ans = j+1

    print(ans)

N ,M Ġ= Ġ[ int (c ) Ġfor Ġc Ġin Ġinput (). split ()]ĊĊ ab Ġ= Ġ[ list (map (int ,input (). split ())) Ġfor Ġc Ġin Ġrange (N )]ĊĊ cd Ġ= Ġ[ list (map (int ,input (). split ())) Ġfor Ġc Ġin Ġrange (M )]ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġmi Ġ= Ġ 2 * 1 0 ** 9 ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (M ):ĊĊ ĠĠĠĠĠĠĠ Ġtmp Ġ= Ġabs (ab [i ][ 0 ]- cd [j ][ 0 ])+ abs (ab [i ][ 1 ]- cd [j ][ 1 ])ĊĊ ĠĠĠĠĠĠĠ Ġif Ġmi Ġ> Ġtmp :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmi Ġ= Ġtmp ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġj + 1 ĊĊ ĠĠĠ Ġprint (ans )Ċ


Input:
def test():

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

    count = 0

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

        j = list(map(int,list(str(i))))

        if j[0] == j[4] and j[1] == j[3]:

            count += 1

    print(count)

if __name__ == "__main__":

    test()

def Ġtest ():ĊĊ ĠĠĠ Ġa ,b Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġcount Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (a ,b + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= Ġlist (map (int ,list (str (i ))))ĊĊ ĠĠĠĠĠĠĠ Ġif Ġj [ 0 ] Ġ== Ġj [ 4 ] Ġand Ġj [ 1 ] Ġ== Ġj [ 3 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġprint (count )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġtest ()Ċ


Input:
from bisect import bisect_left

from bisect import bisect_right

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

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

a = sorted(a)

a_count = [0]*100010

a_sum = [0]*100010

for i in range(n):

    a_count[a[i]] += 1

    a_sum[a[i]] += a[i]

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

    a_count[i] += a_count[i+1]

    a_sum[i] += a_sum[i+1]

def chk(x):

    case = 0

    for i in range(n):

        if 0<= x-a[i]<= 10**5+5:

            case += a_count[x-a[i]]

        elif x-a[i] < 0:

            case += n

    if case >= m:

        ch = True

    else:

        ch = False

    return ch

l = 2*a[-1]+1    #NG

r = 1 #OK

while abs(r-l) > 1:

    kk = (r+l)//2

    if chk(kk):

        r = kk

    else:

        l = kk

ans = 0

sm = sum(a)

l = r

case = 0

for i in range(n):

    num = n-bisect_right(a,l-a[i]-1)

    case += num

    ans += num*a[i]*2

ans -= (case-m)*l

print(ans)

from Ġbis ect Ġimport Ġbis ect _left ĊĊ from Ġbis ect Ġimport Ġbis ect _right ĊĊĊĊ n ,m Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġsorted (a )ĊĊĊĊ a _count Ġ= Ġ[ 0 ]* 1 0 0 0 1 0 ĊĊ a _sum Ġ= Ġ[ 0 ]* 1 0 0 0 1 0 ĊĊĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġa _count [a [i ]] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġa _sum [a [i ]] Ġ+= Ġa [i ]ĊĊĊĊ for Ġi Ġin Ġrange ( 1 0 0 0 0 5 ,- 1 ,- 1 ):ĊĊ ĠĠĠ Ġa _count [i ] Ġ+= Ġa _count [i + 1 ]ĊĊ ĠĠĠ Ġa _sum [i ] Ġ+= Ġa _sum [i + 1 ]ĊĊĊĊ def Ġchk (x ):ĊĊ ĠĠĠ Ġcase Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ 0 <= Ġx -a [i ]<= Ġ 1 0 ** 5 + 5 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcase Ġ+= Ġa _count [x -a [i ]]ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġx -a [i ] Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcase Ġ+= Ġn ĊĊ ĠĠĠ Ġif Ġcase Ġ>= Ġm :ĊĊ ĠĠĠĠĠĠĠ Ġch Ġ= ĠTrue ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġch Ġ= ĠFalse ĊĊ ĠĠĠ Ġreturn Ġch ĊĊĊĊ l Ġ= Ġ 2 *a [- 1 ]+ 1 ĠĠĠ Ġ# NG ĊĊ r Ġ= Ġ 1 Ġ# OK ĊĊĊĊ while Ġabs (r -l ) Ġ> Ġ 1 :ĊĊ ĠĠĠ Ġkk Ġ= Ġ( r +l )// 2 ĊĊ ĠĠĠ Ġif Ġchk (k k ):ĊĊ ĠĠĠĠĠĠĠ Ġr Ġ= Ġkk ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġl Ġ= Ġkk ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ sm Ġ= Ġsum (a )ĊĊĊĊ l Ġ= Ġr ĊĊĊĊ case Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġnum Ġ= Ġn -b is ect _right (a ,l -a [i ]- 1 )ĊĊ ĠĠĠ Ġcase Ġ+= Ġnum ĊĊ ĠĠĠ Ġans Ġ+= Ġnum *a [i ]* 2 ĊĊĊĊ ans Ġ-= Ġ( case -m )* l ĊĊĊĊ print (ans )


Input:
X, Y, Z = list(map(int, input().split()))

for n in range(10 ** 5, 0, -1):

    if X >= n * (Y + Z) + Z:

        break

print(n)

X , ĠY , ĠZ Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ for Ġn Ġin Ġrange ( 1 0 Ġ** Ġ 5 , Ġ 0 , Ġ- 1 ):ĊĊ ĠĠĠ Ġif ĠX Ġ>= Ġn Ġ* Ġ( Y Ġ+ ĠZ ) Ġ+ ĠZ :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ print (n )


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

if array[0] % array[1] > 0:

    print(((array[0] // array[1] + 1) * array[2]))

else:

    print(((array[0] // array[1]) * array[2]))

array Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ if Ġarray [ 0 ] Ġ% Ġarray [ 1 ] Ġ> Ġ 0 :ĊĊ ĠĠĠ Ġprint ((( array [ 0 ] Ġ// Ġarray [ 1 ] Ġ+ Ġ 1 ) Ġ* Ġarray [ 2 ]))ĊĊ else :ĊĊ ĠĠĠ Ġprint ((( array [ 0 ] Ġ// Ġarray [ 1 ]) Ġ* Ġarray [ 2 ]))


Input:
N = int(input())

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

Q = int(input())

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

def binary_search(target_num, head, tail):

    idx = int((head+tail)/2)

    if target_num == S[idx]:

        return True

    elif target_num < S[idx]:

        if head == idx:

            return False

        return binary_search(target_num, head, idx-1)

    else:

        if tail == idx:

            return False

        return binary_search(target_num, idx+1, tail)

match_count = 0

for target_num in T:

    if binary_search(target_num, 0, len(S)-1):

        match_count += 1

print((str(match_count)))

N Ġ= Ġint (input ())ĊĊ S Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ Q Ġ= Ġint (input ())ĊĊ T Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ def Ġbinary _search (target _num , Ġhead , Ġtail ):ĊĊ ĠĠĠ Ġidx Ġ= Ġint (( head + tail )/ 2 )ĊĊ ĠĠĠ Ġif Ġtarget _num Ġ== ĠS [idx ]:ĊĊ ĠĠĠĠĠĠĠ Ġreturn ĠTrue ĊĊ ĠĠĠ Ġelif Ġtarget _num Ġ< ĠS [idx ]:ĊĊ ĠĠĠĠĠĠĠ Ġif Ġhead Ġ== Ġidx :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠFalse ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġbinary _search (target _num , Ġhead , Ġidx - 1 )ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġtail Ġ== Ġidx :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠFalse ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġbinary _search (target _num , Ġidx + 1 , Ġtail )ĊĊĊĊĊĊ match _count Ġ= Ġ 0 ĊĊ for Ġtarget _num Ġin ĠT :ĊĊ ĠĠĠ Ġif Ġbinary _search (target _num , Ġ 0 , Ġlen (S )- 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġmatch _count Ġ+= Ġ 1 ĊĊĊĊ print (( str (match _count )))Ċ


Input:
n=input()

n=int(n)

a=1

for i in range(n):

    a=a*(i+1)

    if a>=pow(10,9)+7:

        a=a%(pow(10,9)+7)

print(a)

n =input ()ĊĊ n =int (n )ĊĊ a = 1 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġa =a *( i + 1 )ĊĊ ĠĠĠ Ġif Ġa >= pow ( 1 0 , 9 )+ 7 :ĊĊ ĠĠĠĠĠĠĠ Ġa =a %( pow ( 1 0 , 9 )+ 7 )ĊĊ print (a )


Input:
import sys

r = []

n = int(input())

l = sys.stdin.readlines()

for i in l:

  x, y, z = sorted([x*x for x in list(map(int, i.split()))])

  if x + y == z:

      print("YES")

  else:

      print("NO")

import Ġsys ĊĊ r Ġ= Ġ[]ĊĊ n Ġ= Ġint (input ())ĊĊ l Ġ= Ġsys .stdin .readlines ()ĊĊ for Ġi Ġin Ġl :ĊĊ Ġ Ġx , Ġy , Ġz Ġ= Ġsorted ([ x *x Ġfor Ġx Ġin Ġlist (map (int , Ġi .split ())) ])ĊĊ Ġ Ġif Ġx Ġ+ Ġy Ġ== Ġz :ĊĊ ĠĠĠĠĠ Ġprint (" YES ")ĊĊ Ġ Ġelse :ĊĊ ĠĠĠĠĠ Ġprint (" NO ")


Input:
import re

ptn = re.compile(r"(A|C|G|T)*")

S = input()

ans = 0

for i in range(len(S)):

  for j in range(len(S)):

    x = ptn.match(S[i:i+j+1]).group(0)

    if(x):

      ans = max(ans, len(x))

print(ans)

import Ġre ĊĊ pt n Ġ= Ġre .compile (r "( A | C | G | T )* ")ĊĊ ĊĊ S Ġ= Ġinput ()ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (len (S )) :ĊĊ Ġ Ġfor Ġj Ġin Ġrange (len (S )) :ĊĊ ĠĠĠ Ġx Ġ= Ġp tn .match (S [i :i +j + 1 ]). group ( 0 )ĊĊ ĠĠĠ Ġif (x ):ĊĊ ĠĠĠĠĠ Ġans Ġ= Ġmax (ans , Ġlen (x ))ĊĊ print (ans )


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

ab = c * 2

res = float("inf")

if a + b <= ab:

    res = x * a + y * b

else:

    if x == y:

        res = x * ab

    elif x > y:

        for i in range(y, x + 1):

            cost = i * ab + (x - i) * a

            res = min(res, cost)

    else:

        for i in range(x, y + 1):

            cost = i * ab + (y - i) * b

            res = min(res, cost)

print(res)

a , Ġb , Ġc , Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ab Ġ= Ġc Ġ* Ġ 2 ĊĊĊĊ res Ġ= Ġfloat (" inf ")ĊĊ if Ġa Ġ+ Ġb Ġ<= Ġab :ĊĊ ĠĠĠ Ġres Ġ= Ġx Ġ* Ġa Ġ+ Ġy Ġ* Ġb ĊĊ else :ĊĊ ĠĠĠ Ġif Ġx Ġ== Ġy :ĊĊ ĠĠĠĠĠĠĠ Ġres Ġ= Ġx Ġ* Ġab ĊĊ ĠĠĠ Ġelif Ġx Ġ> Ġy :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (y , Ġx Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcost Ġ= Ġi Ġ* Ġab Ġ+ Ġ( x Ġ- Ġi ) Ġ* Ġa ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġres Ġ= Ġmin (res , Ġcost )ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (x , Ġy Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcost Ġ= Ġi Ġ* Ġab Ġ+ Ġ( y Ġ- Ġi ) Ġ* Ġb ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġres Ġ= Ġmin (res , Ġcost )ĊĊ print (res )Ċ


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

ans=a*x+b*y

for ci in range(max(x,y)+1):

    sumc = 2*ci*c

    sumc += (x-ci)*a if (x-ci)>0 else 0

    sumc += (y-ci)*b if (y-ci)>0 else 0

    ans=min(ans,sumc)

print(ans)

a ,b ,c ,x ,y =list (map (int ,input (). split ())) ĊĊĊĊ ans =a *x +b *y ĊĊ for Ġci Ġin Ġrange (max (x ,y )+ 1 ):ĊĊ ĠĠĠ Ġsum c Ġ= Ġ 2 * ci *c ĊĊ ĠĠĠ Ġsum c Ġ+= Ġ( x -ci )* a Ġif Ġ( x -ci )> 0 Ġelse Ġ 0 ĊĊ ĠĠĠ Ġsum c Ġ+= Ġ( y -ci )* b Ġif Ġ( y -ci )> 0 Ġelse Ġ 0 ĊĊ ĠĠĠ Ġans =min (ans ,sum c )ĊĊĊĊ print (ans )


Input:
a=65280; b=61680; c=52428; d=43690; e=65535

from heapq import heappush, heappop

base = [a, b, c, d, e, 0]

Q = [(1, el) for el in base]

L = {el: 1 for el in base}

H = []

get = L.get

push = H.append

while Q:

    l, p = heappop(Q)

    if L[p] < l: continue

    if l+1 < get(p ^ e, 17):

        L[p ^ e] = l+1

        if l+1 < 16: heappush(Q, (l+1, p ^ e))

    if l+3 < 16:

        for q, r in H:

            if l+r+3 <= 16:

                if l+r+3 < get(p & q, 17):

                    L[p & q] = l+r+3

                    if l+r+3 < 16: heappush(Q, (l+r+3, p & q))

                if l+r+3 < get(p ^ q, 17):

                    L[p ^ q] = l+r+3

                    if l+r+3 < 16: heappush(Q, (l+r+3, p ^ q))

            else: break

    if l < 7: push((p, l))

print(*map(L.__getitem__, eval("e&%s"%",e&".join(open(0).read().replace(*"-~").replace(*"*&").replace(*"1e").split()[:-1]))),sep='\n')

a = 6 5 2 8 0 ; Ġb = 6 1 6 8 0 ; Ġc = 5 2 4 2 8 ; Ġd = 4 3 6 9 0 ; Ġe = 6 5 5 3 5 ĊĊ from Ġheapq Ġimport Ġhe app ush , Ġhe app op ĊĊ base Ġ= Ġ[ a , Ġb , Ġc , Ġd , Ġe , Ġ 0 ]ĊĊ Q Ġ= Ġ[( 1 , Ġel ) Ġfor Ġel Ġin Ġbase ]ĊĊ L Ġ= Ġ{ el : Ġ 1 Ġfor Ġel Ġin Ġbase }ĊĊ H Ġ= Ġ[]ĊĊ get Ġ= ĠL .get ĊĊ push Ġ= ĠH .append ĊĊ while ĠQ :ĊĊ ĠĠĠ Ġl , Ġp Ġ= Ġhe app op (Q )ĊĊ ĠĠĠ Ġif ĠL [p ] Ġ< Ġl : Ġcontinue ĊĊ ĠĠĠ Ġif Ġl + 1 Ġ< Ġget (p Ġ^ Ġe , Ġ 1 7 ):ĊĊ ĠĠĠĠĠĠĠ ĠL [p Ġ^ Ġe ] Ġ= Ġl + 1 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġl + 1 Ġ< Ġ 1 6 : Ġhe app ush (Q , Ġ( l + 1 , Ġp Ġ^ Ġe ))ĊĊ ĠĠĠ Ġif Ġl + 3 Ġ< Ġ 1 6 :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġq , Ġr Ġin ĠH :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġl +r + 3 Ġ<= Ġ 1 6 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġl +r + 3 Ġ< Ġget (p Ġ& Ġq , Ġ 1 7 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠL [p Ġ& Ġq ] Ġ= Ġl +r + 3 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġl +r + 3 Ġ< Ġ 1 6 : Ġhe app ush (Q , Ġ( l +r + 3 , Ġp Ġ& Ġq ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġl +r + 3 Ġ< Ġget (p Ġ^ Ġq , Ġ 1 7 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠL [p Ġ^ Ġq ] Ġ= Ġl +r + 3 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġl +r + 3 Ġ< Ġ 1 6 : Ġhe app ush (Q , Ġ( l +r + 3 , Ġp Ġ^ Ġq ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse : Ġbreak ĊĊ ĠĠĠ Ġif Ġl Ġ< Ġ 7 : Ġpush (( p , Ġl ))ĊĊ print (* map (L .__ getitem __, Ġeval (" e & % s "% ", e & ". join (open ( 0 ). read (). replace (* "- ~ "). replace (* "* & "). replace (* " 1 e "). split () [:- 1 ])) ), sep ='\ n ')Ċ


Input:
def examB():

    N = I(); A = [I() for _ in range(N)]

    ans = 0; cur= 0

    for i in A:

        if i==0:

            ans += cur//2

            cur = 0

        else:

            cur += i

    ans += cur // 2

    print(ans)

    return

import sys,copy,bisect,itertools,heapq,math

from heapq import heappop,heappush,heapify

from collections import Counter,defaultdict,deque

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

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

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

def LS(): return sys.stdin.readline().split()

def SI(): return sys.stdin.readline().strip()

mod = 10**9 + 7

inf = float('inf')

if __name__ == '__main__':

    examB()

def Ġexam B ():ĊĊ ĠĠĠ ĠN Ġ= ĠI (); ĠA Ġ= Ġ[ I () Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ; Ġcur = Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi == 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġcur // 2 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcur Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcur Ġ+= Ġi ĊĊ ĠĠĠ Ġans Ġ+= Ġcur Ġ// Ġ 2 ĊĊ ĠĠĠ Ġprint (ans )ĊĊ ĠĠĠ Ġreturn ĊĊĊĊ import Ġsys ,copy ,b is ect ,it ertools , heap q , math ĊĊ from Ġheapq Ġimport Ġhe app op , he app ush , heap ify ĊĊ from Ġcollections Ġimport ĠCounter ,default dict , deque ĊĊ def ĠI (): Ġreturn Ġint (sys .stdin .readline ())ĊĊ def ĠLI (): Ġreturn Ġlist (map (int , sys .stdin .readline (). split ()))ĊĊ def ĠL SI (): Ġreturn Ġlist (map (str , sys .stdin .readline (). split ()))ĊĊ def ĠLS (): Ġreturn Ġsys .stdin .readline (). split ()ĊĊ def ĠSI (): Ġreturn Ġsys .stdin .readline (). strip ()ĊĊ mod Ġ= Ġ 1 0 ** 9 Ġ+ Ġ 7 ĊĊ inf Ġ= Ġfloat (' inf ')ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġexam B ()Ċ


Input:
N = int(input())

L = [ 0 ] * 1000000

L[0] = 2

L[1] = 1

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

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

print((L[N]))

N Ġ= Ġint (input ())ĊĊ L Ġ= Ġ[ Ġ 0 Ġ] Ġ* Ġ 1 0 0 0 0 0 0 ĊĊĊĊ L [ 0 ] Ġ= Ġ 2 ĊĊ L [ 1 ] Ġ= Ġ 1 ĊĊĊĊ for Ġi Ġin Ġrange ( 2 , ĠN + 1 ):ĊĊ Ġ ĠL [i ] Ġ= ĠL [i - 2 ] Ġ+ ĠL [i - 1 ]ĊĊĊĊ print (( L [N ]))Ċ


Input:
import sys

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

S=set(map(int,sys.stdin))

a,b=0,1

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

    if i in S:

        a,b=b,0

    else:

        a,b=b,a+b

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

import Ġsys ĊĊ N ,M =list (map (int ,input (). split ()))ĊĊ S =set (map (int , sys .stdin )) ĊĊĊĊ a ,b = 0 , 1 ĊĊ for Ġi Ġin Ġrange ( 1 ,N + 1 ):ĊĊ ĠĠĠ Ġif Ġi Ġin ĠS :ĊĊ ĠĠĠĠĠĠĠ Ġa ,b =b , 0 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġa ,b =b ,a +b ĊĊĊĊ print (( b %( 1 0 ** 9 + 7 )))Ċ


Input:
import re

while True:

    n = int(input())

    if n == 0:

        break

    l = [0] * (24*60*60+1)

    for _ in range(n):

        h1,m1,s1,h2,m2,s2 = list(map(int, re.split(':| ', input())))

        l[h1*60*60 + m1*60 + s1] += 1

        l[h2*60*60 + m2*60 + s2] -= 1

    r = 0

    for i in range(24*60*60):

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

        r = max(r, l[i+1])

    print(r)

import Ġre ĊĊĊĊ while ĠTrue :ĊĊ ĠĠĠ Ġn Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġif Ġn Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġl Ġ= Ġ[ 0 ] Ġ* Ġ( 2 4 * 6 0 * 6 0 + 1 )ĊĊ ĠĠĠ Ġfor Ġ_ Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġh 1 ,m 1 ,s 1 ,h 2 ,m 2 ,s 2 Ġ= Ġlist (map (int , Ġre .split (': | Ġ', Ġinput ())) )ĊĊ ĠĠĠĠĠĠĠ Ġl [h 1 * 6 0 * 6 0 Ġ+ Ġm 1 * 6 0 Ġ+ Ġs 1 ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġl [h 2 * 6 0 * 6 0 Ġ+ Ġm 2 * 6 0 Ġ+ Ġs 2 ] Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġr Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 2 4 * 6 0 * 6 0 ):ĊĊ ĠĠĠĠĠĠĠ Ġl [i + 1 ] Ġ+= Ġl [i ]ĊĊ ĠĠĠĠĠĠĠ Ġr Ġ= Ġmax (r , Ġl [i + 1 ])ĊĊ ĠĠĠ Ġprint (r )


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

S = input()

nums = []

now = 1

cnt = 0

for i in range(N):

    if S[i] == str(now):

        cnt += 1

    else:

        nums.append(cnt)

        now = 1 - now

        cnt = 1

if cnt != 0:

    nums.append(cnt)

if len(nums) % 2 == 0:

    nums.append(0)

add = 2 * K + 1

ans = 0

left = 0

right = 0

tmp = 0

for i in range(0, len(nums), 2):

    next_left = i

    next_right = min(i + add, len(nums))

    while next_left > left:

        tmp -= nums[left]

        left += 1

    while next_right > right:

        tmp += nums[right]

        right += 1

    ans = max(ans, tmp)

print(ans)

N , ĠK Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ S Ġ= Ġinput ()ĊĊ nums Ġ= Ġ[]ĊĊ now Ġ= Ġ 1 ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġif ĠS [i ] Ġ== Ġstr (now ):ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġnums .append (cnt )ĊĊ ĠĠĠĠĠĠĠ Ġnow Ġ= Ġ 1 Ġ- Ġnow ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ= Ġ 1 ĊĊ if Ġcnt Ġ!= Ġ 0 :ĊĊ ĠĠĠ Ġnums .append (cnt )ĊĊ if Ġlen (nums ) Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġnums .append ( 0 )ĊĊĊĊ add Ġ= Ġ 2 Ġ* ĠK Ġ+ Ġ 1 ĊĊ ans Ġ= Ġ 0 ĊĊ left Ġ= Ġ 0 ĊĊ right Ġ= Ġ 0 ĊĊ tmp Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 0 , Ġlen (nums ), Ġ 2 ): ĊĊĊĊ ĠĠĠ Ġnext _left Ġ= Ġi ĊĊ ĠĠĠ Ġnext _right Ġ= Ġmin (i Ġ+ Ġadd , Ġlen (nums )) ĊĊĊĊ ĠĠĠ Ġwhile Ġnext _left Ġ> Ġleft :ĊĊ ĠĠĠĠĠĠĠ Ġtmp Ġ-= Ġnums [left ]ĊĊ ĠĠĠĠĠĠĠ Ġleft Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġwhile Ġnext _right Ġ> Ġright :ĊĊ ĠĠĠĠĠĠĠ Ġtmp Ġ+= Ġnums [right ]ĊĊ ĠĠĠĠĠĠĠ Ġright Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġans Ġ= Ġmax (ans , Ġtmp )ĊĊ print (ans )


Input:
n=int(input())

s=list(map(str,input().split()))

total=[]

for i in range(n):

    if s[i] not in total:

        total.append(s[i])

print(('Three' if len(total)==3 else 'Four'))

n =int (input ())ĊĊ s =list (map (str ,input (). split ()))ĊĊ total =[] ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġif Ġs [i ] Ġnot Ġin Ġtotal :ĊĊ ĠĠĠĠĠĠĠ Ġtotal .append (s [i ])ĊĊ print ((' Three ' Ġif Ġlen (total )== 3 Ġelse Ġ' Four '))


Input:
import sys

from collections import Counter, deque, defaultdict

from itertools import accumulate, permutations, combinations, takewhile, compress, cycle

from functools import reduce

from math import ceil, floor, log10, log2, factorial

from pprint import pprint

sys.setrecursionlimit(1000000)

# MOD = 10 ** 9 + 7

# N = int(input())

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

# V = [[0] * 100 for _ in range(100)]

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

N, W = [int(x) for x in input().split()]

dp = [float('inf')] * 1000 * 100*10

vs = set()

vs.add(0)

dp[0] = 0

for i in range(N):

    w, v = [int(x) for x in input().split()]

    tmpDP = dp.copy()

    for vv in list(vs):

        if dp[vv + v] > dp[vv] + w:

            tmpDP[vv + v] = dp[vv] + w

            vs.add(vv + v)

    dp = tmpDP

ans = 0

for v in list(vs):

    if dp[v] <= W:

        ans = max(ans, v)

print(ans)

import Ġsys ĊĊ from Ġcollections Ġimport ĠCounter , Ġdeque , Ġdefaultdict ĊĊ from Ġitertools Ġimport Ġaccumulate , Ġpermutations , Ġcombinations , Ġtak ew h ile , Ġcompress , Ġcycle ĊĊ from Ġfunctools Ġimport Ġreduce ĊĊ from Ġmath Ġimport Ġceil , Ġfloor , Ġlog 1 0 , Ġlog 2 , Ġfactorial ĊĊ from Ġpprint Ġimport Ġpprint ĊĊĊĊ sys .set rec ursion limit ( 1 0 0 0 0 0 0 )ĊĊ # ĠMOD Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĊĊ # ĠN Ġ= Ġint (input ())ĊĊ # ĠA Ġ= Ġ[ int (x ) Ġfor Ġx Ġin Ġinput (). split ()]ĊĊ # ĠV Ġ= Ġ[[ 0 ] Ġ* Ġ 1 0 0 Ġfor Ġ_ Ġin Ġrange ( 1 0 0 )]ĊĊ # ĠA Ġ= Ġ[ int (input ()) Ġfor Ġ_ Ġin Ġrange (N )] ĊĊĊĊ N , ĠW Ġ= Ġ[ int (x ) Ġfor Ġx Ġin Ġinput (). split ()] ĊĊĊĊ dp Ġ= Ġ[ float (' inf ')] Ġ* Ġ 1 0 0 0 Ġ* Ġ 1 0 0 * 1 0 ĊĊ vs Ġ= Ġset ()ĊĊ vs .add ( 0 )ĊĊ dp [ 0 ] Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġw , Ġv Ġ= Ġ[ int (x ) Ġfor Ġx Ġin Ġinput (). split ()] ĊĊĊĊ ĠĠĠ Ġtmp DP Ġ= Ġdp .copy ()ĊĊ ĠĠĠ Ġfor Ġvv Ġin Ġlist (vs ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġdp [v v Ġ+ Ġv ] Ġ> Ġdp [v v ] Ġ+ Ġw :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġtmp DP [v v Ġ+ Ġv ] Ġ= Ġdp [v v ] Ġ+ Ġw ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġvs .add (v v Ġ+ Ġv )ĊĊ ĠĠĠ Ġdp Ġ= Ġtmp DP ĊĊĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġv Ġin Ġlist (vs ):ĊĊ ĠĠĠ Ġif Ġdp [v ] Ġ<= ĠW :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġmax (ans , Ġv )ĊĊ print (ans )Ċ


Input:
from math import factorial

N = int(input())

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

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


Input:
import math

while True:

	try:

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

		print('%d %d' % (math.gcd(x,y),x/math.gcd(x,y)*y))

	except EOFError:

		break

import Ġmath ĊĊ while ĠTrue :ĊĊ ĉtry :ĊĊ ĉ ĉx ,y Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĉ ĉprint ('% d Ġ% d ' Ġ% Ġ( math .g cd (x ,y ), x /math .g cd (x ,y )* y ))ĊĊ ĉexcept ĠEOF Error :ĊĊ ĉ ĉbreak


Input:
n = int(input())

r = int(n**.5)

for i in range(r):

  if n % (r-i) == 0:

    print(( (r-i) + n//(r-i) - 2 ))

    break

n Ġ= Ġint (input ())ĊĊ r Ġ= Ġint (n ** . 5 )ĊĊ for Ġi Ġin Ġrange (r ):ĊĊ Ġ Ġif Ġn Ġ% Ġ( r -i ) Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġprint (( Ġ( r -i ) Ġ+ Ġn //( r -i ) Ġ- Ġ 2 Ġ))ĊĊ ĠĠĠ Ġbreak


Input:
from collections import Counter

def factorization(n) -> list:

	if n==1:

		return [1]

	ret = []

	i = 2

	while i*i<=n:

		while n%i==0:

			n //= i

			ret.append(i)

		i += 1

	if n!=1:

		ret.append(n)

	return ret

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

mod = 10**9+7

if m==1:

	print((1));exit()

factors = Counter(factorization(m))

mx = n+max(factors.values())

fac = [1]*(mx+1)

inv = [1]*(mx+1)

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

	fac[i] = fac[i-1] * i % mod

inv[-1] = pow(fac[-1], mod - 2, mod)

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

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

def cmb(n,r):

	assert n >= r >= 0

	return fac[n] * inv[n-r] * inv[r] % mod

ans=1

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

	ans*=cmb(n+v-1,v)

	ans%=mod

print(ans)

from Ġcollections Ġimport ĠCounter ĊĊ def Ġfactor ization (n ) Ġ-> Ġlist :ĊĊ ĉif Ġn == 1 :ĊĊ ĉ ĉreturn Ġ[ 1 ]ĊĊ ĉret Ġ= Ġ[]ĊĊ ĉi Ġ= Ġ 2 ĊĊ ĉwhile Ġi *i <= n :ĊĊ ĉ ĉwhile Ġn %i == 0 :ĊĊ ĉĉ ĉn Ġ//= Ġi ĊĊ ĉĉ ĉret .append (i )ĊĊ ĉ ĉi Ġ+= Ġ 1 ĊĊ ĉif Ġn != 1 :ĊĊ ĉ ĉret .append (n )ĊĊ ĉreturn Ġret ĊĊĊĊ n ,m Ġ= Ġlist (map (int ,input (). split ()))ĊĊ mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊ if Ġm == 1 :ĊĊ ĉprint (( 1 )); exit ()ĊĊĊĊ f actors Ġ= ĠCounter (factor ization (m ))ĊĊ mx Ġ= Ġn + max (f actors .values ())ĊĊ ĊĊ fac Ġ= Ġ[ 1 ]*( mx + 1 )ĊĊ inv Ġ= Ġ[ 1 ]*( mx + 1 )ĊĊ for Ġi Ġin Ġrange ( 1 ,m x + 1 ):ĊĊ ĉf ac [i ] Ġ= Ġfac [i - 1 ] Ġ* Ġi Ġ% Ġmod ĊĊ inv [- 1 ] Ġ= Ġpow (f ac [- 1 ], Ġmod Ġ- Ġ 2 , Ġmod )ĊĊ for Ġi Ġin Ġrange (mx - 1 , Ġ- 1 , Ġ- 1 ):ĊĊ ĉ inv [i ] Ġ= Ġinv [i + 1 ] Ġ* Ġ( i + 1 ) Ġ% Ġmod ĊĊ def Ġcmb (n ,r ):ĊĊ ĉassert Ġn Ġ>= Ġr Ġ>= Ġ 0 ĊĊ ĉreturn Ġfac [n ] Ġ* Ġinv [n -r ] Ġ* Ġinv [r ] Ġ% Ġmod ĊĊ ĉĊĊ ans = 1 ĊĊ for Ġv Ġin Ġlist (f actors .values ()) :ĊĊ ĉans *= cmb (n +v - 1 ,v )ĊĊ ĉans %= mod ĊĊĊĊ print (ans )


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

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

diff = A[0] + K - A[-1]

ans = A[-1] - A[0]

for i in range(1, N):

    dist = K - A[i] + A[i - 1]

    if dist < ans:

        ans = dist

print(ans)

K , ĠN Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ A Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ diff Ġ= ĠA [ 0 ] Ġ+ ĠK Ġ- ĠA [- 1 ]ĊĊ ans Ġ= ĠA [- 1 ] Ġ- ĠA [ 0 ]ĊĊ for Ġi Ġin Ġrange ( 1 , ĠN ):ĊĊ ĠĠĠ Ġdist Ġ= ĠK Ġ- ĠA [i ] Ġ+ ĠA [i Ġ- Ġ 1 ]ĊĊ ĠĠĠ Ġif Ġdist Ġ< Ġans :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġdist ĊĊĊĊ print (ans )Ċ


Input:
import sys

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

def resolve():

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

    ans = float('inf')

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

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

    print(ans)

if __name__ == '__main__':

    resolve()

import Ġsys ĊĊ input Ġ= Ġlambda : Ġsys .stdin .readline (). rstrip () ĠĊĊĊĊ def Ġresolve ():ĊĊ ĠĠĠ ĠA , ĠB , ĠC , ĠX , ĠY Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ĠĠĠ Ġans Ġ= Ġfloat (' inf ')ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 0 , Ġmax (X , ĠY )* 2 + 1 , Ġ 2 ):ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġmin (A * max (X -i // 2 , Ġ 0 )+ B * max (Y -i // 2 , Ġ 0 )+ C *i , Ġans )ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġresolve ()Ċ


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

ans = 0

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

    i = str(i)

    if i[0] == i[4]:

        if i[1] == i[3]:

            ans += 1

        else:

            ans += 0

    else:

        ans += 0

print(ans)

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


Input:
def main():

    N = int(input())

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

    if N == 1:

        return print(1 if A[0] % 2 == 0 else 2)

    ans = 0

    d = (-1, 0, 1)

    from itertools import product

    for i in product(range(3), repeat=N):

        cur = 1

        for j in range(N):

            cur *= (A[j] + d[i[j]])

        if cur % 2 == 0:

            ans += 1

    print(ans)

if __name__ == '__main__':

    main()

def Ġmain ():ĊĊ ĠĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠA Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ ĠĠĠ Ġif ĠN Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġprint ( 1 Ġif ĠA [ 0 ] Ġ% Ġ 2 Ġ== Ġ 0 Ġelse Ġ 2 )ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġd Ġ= Ġ(- 1 , Ġ 0 , Ġ 1 )ĊĊ ĠĠĠ Ġfrom Ġitertools Ġimport Ġproduct ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġproduct (range ( 3 ), Ġrepeat =N ):ĊĊ ĠĠĠĠĠĠĠ Ġcur Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (N ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcur Ġ*= Ġ( A [j ] Ġ+ Ġd [i [j ]])ĊĊ ĠĠĠĠĠĠĠ Ġif Ġcur Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


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

from collections import defaultdict

from itertools import combinations

N = int(input())

C = [0, 0, 0, 0, 0, 0]

D = defaultdict(int)

for i, m in enumerate("MARCH", start=1):

    D[m] = i

for _ in range(N):

    C[D[input()[0]]] += 1

ans = 0

for a, b, c in combinations(list(range(1, 6)), r=3):

    ans += C[a]*C[b]*C[c]

print(ans)

# Ġ-*- Ġcoding : Ġutf - 8 Ġ-*-ĊĊ from Ġcollections Ġimport Ġdefaultdict ĊĊ from Ġitertools Ġimport Ġcombinations ĊĊ N Ġ= Ġint (input ())ĊĊ C Ġ= Ġ[ 0 , Ġ 0 , Ġ 0 , Ġ 0 , Ġ 0 , Ġ 0 ]ĊĊ D Ġ= Ġdefaultdict (int )ĊĊ for Ġi , Ġm Ġin Ġenumerate (" M ARCH ", Ġstart = 1 ):ĊĊ ĠĠĠ ĠD [m ] Ġ= Ġi ĊĊĊĊ for Ġ_ Ġin Ġrange (N ):ĊĊ ĠĠĠ ĠC [D [input ()[ 0 ]] ] Ġ+= Ġ 1 ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġa , Ġb , Ġc Ġin Ġcombinations (list (range ( 1 , Ġ 6 )), Ġr = 3 ):ĊĊ ĠĠĠ Ġans Ġ+= ĠC [a ]* C [b ]* C [c ]ĊĊ print (ans )


Input:
import math

N = int(input())

print((math.factorial(N) % (1000000000 + 7)))


Input:
def main():

    from statistics import median

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

    a = [x - i for i, x in enumerate(a, 1)]

    a.sort()

    m = int(median(a))

    ans = sum([abs(x - m) for x in a])

    print(ans)

if __name__ == '__main__':

    main()

def Ġmain ():ĊĊ ĠĠĠ Ġfrom Ġstatistics Ġimport Ġmedian ĊĊĊĊ ĠĠĠ Ġn , Ġ* a , Ġ= Ġlist (map (int , Ġopen ( 0 ). read (). split ()))ĊĊ ĠĠĠ Ġa Ġ= Ġ[ x Ġ- Ġi Ġfor Ġi , Ġx Ġin Ġenumerate (a , Ġ 1 )]ĊĊ ĠĠĠ Ġa .sort ()ĊĊ ĠĠĠ Ġm Ġ= Ġint (m edian (a )) ĊĊĊĊ ĠĠĠ Ġans Ġ= Ġsum ([ abs (x Ġ- Ġm ) Ġfor Ġx Ġin Ġa ])ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


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

L, R = [], []

low = -float('INF')

high = float('INF')

for i in range(M):

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

    L.append(l)

    R.append(r)

    if l > low:

        low = l

    if r < high:

        high = r

print((max(0, high - low + 1)))

N , ĠM Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ L , ĠR Ġ= Ġ[], Ġ[]ĊĊ low Ġ= Ġ- float (' INF ')ĊĊ high Ġ= Ġfloat (' INF ')ĊĊ for Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠ Ġl , Ġr Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠL .append (l )ĊĊ ĠĠĠ ĠR .append (r )ĊĊ ĠĠĠ Ġif Ġl Ġ> Ġlow :ĊĊ ĠĠĠĠĠĠĠ Ġlow Ġ= Ġl ĊĊ ĠĠĠ Ġif Ġr Ġ< Ġhigh :ĊĊ ĠĠĠĠĠĠĠ Ġhigh Ġ= Ġr ĊĊ print (( max ( 0 , Ġhigh Ġ- Ġlow Ġ+ Ġ 1 )))Ċ


Input:
a,b,c=1,0,0

exec('a,b,c=b,c,(a+c)%(10**9+7);'*(int(input())-2))

print(c)


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

z = max(x,y) * 2

min_sum = c * z

for i in range(z):

    r = max(0, y - i) * b

    t = max(0, x - i) * a

    sum = c * i * 2 + r + t

    if sum < min_sum:

        min_sum = sum

print(min_sum)

a , Ġb , Ġc , Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ z Ġ= Ġmax (x ,y ) Ġ* Ġ 2 ĊĊ min _sum Ġ= Ġc Ġ* Ġz ĊĊĊĊ for Ġi Ġin Ġrange (z ):ĊĊ ĠĠĠ Ġr Ġ= Ġmax ( 0 , Ġy Ġ- Ġi ) Ġ* Ġb ĊĊ ĠĠĠ Ġt Ġ= Ġmax ( 0 , Ġx Ġ- Ġi ) Ġ* Ġa ĊĊ ĠĠĠ Ġsum Ġ= Ġc Ġ* Ġi Ġ* Ġ 2 Ġ+ Ġr Ġ+ Ġt ĊĊ ĠĠĠ Ġif Ġsum Ġ< Ġmin _sum :ĊĊ ĠĠĠĠĠĠĠ Ġmin _sum Ġ= Ġsum ĊĊĊĊ print (min _sum )


Input:
N = int(input())

a = 1

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

    a = a*n % (10**9+7)

print(a)

N Ġ= Ġint (input ())ĊĊ a Ġ= Ġ 1 ĊĊ for Ġn Ġin Ġrange ( 2 ,N + 1 ):ĊĊ ĠĠĠ Ġa Ġ= Ġa *n Ġ% Ġ( 1 0 ** 9 + 7 )ĊĊ print (a )


Input:
import sys

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines

from operator import xor

from functools import reduce

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

a = reduce(xor,(1<<a for a in A))

dp = 0 # bitset

for n in range(K):

    if not(dp&(1<<n)):

        dp |= (a<<n)

answer = 'First' if dp&(1<<K) else 'Second'

print(answer)

import Ġsys ĊĊ read Ġ= Ġsys .stdin .buffer .read ĊĊ read line Ġ= Ġsys .stdin .buffer .readline ĊĊ read lines Ġ= Ġsys .stdin .buffer .readlines ĊĊĊĊ from Ġoperator Ġimport Ġxor ĊĊ from Ġfunctools Ġimport Ġreduce ĊĊĊĊ N ,K ,* A Ġ= Ġlist (map (int , read (). split ())) ĊĊĊĊ a Ġ= Ġreduce (x or ,( 1 << a Ġfor Ġa Ġin ĠA )) ĊĊĊĊ dp Ġ= Ġ 0 Ġ# Ġbit set ĊĊ for Ġn Ġin Ġrange (K ):ĊĊ ĠĠĠ Ġif Ġnot (dp &( 1 << n )) :ĊĊ ĠĠĠĠĠĠĠ Ġdp Ġ|= Ġ( a << n )ĊĊĊĊ answer Ġ= Ġ' First ' Ġif Ġdp &( 1 << K ) Ġelse Ġ' Second 'ĊĊ print (answer )


Input:
n = int(input())

ans = 0

SQRT = int(n ** 0.5)

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

    b = int(n/m)

    ans += m * (m + b) * (b + 1 - m)

ans -= SQRT * (SQRT+1) * (2*SQRT+1) // 6

print(ans)

n Ġ= Ġint (input ())ĊĊ ans Ġ= Ġ 0 ĊĊ SQ RT Ġ= Ġint (n Ġ** Ġ 0 . 5 )ĊĊ for Ġm Ġin Ġrange ( 1 ,S Q RT Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġb Ġ= Ġint (n /m )ĊĊ ĠĠĠ Ġans Ġ+= Ġm Ġ* Ġ( m Ġ+ Ġb ) Ġ* Ġ( b Ġ+ Ġ 1 Ġ- Ġm )ĊĊ ans Ġ-= ĠSQ RT Ġ* Ġ( SQ RT + 1 ) Ġ* Ġ( 2 * SQ RT + 1 ) Ġ// Ġ 6 ĊĊ print (ans )


Input:
import math

import collections

N = int(input())

a = math.factorial(N)

check = []

ans = 1

i = 2

while a != 1:

    if a % i == 0:

        a //= i

        check.append(i)

    else:

        i += 1

check = list(collections.Counter(check).values())

for i in check:

    ans *= (i+1)

    ans %= 10**9+7

print(ans)

import Ġmath ĊĊ import Ġcollections ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ a Ġ= Ġmath .factor ial (N )ĊĊ check Ġ= Ġ[]ĊĊ ans Ġ= Ġ 1 ĊĊ i Ġ= Ġ 2 ĊĊĊĊ while Ġa Ġ!= Ġ 1 :ĊĊ ĠĠĠ Ġif Ġa Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġa Ġ//= Ġi ĊĊ ĠĠĠĠĠĠĠ Ġcheck .append (i )ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġi Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĊĊ check Ġ= Ġlist (c ollections .Counter (check ). values ())ĊĊ for Ġi Ġin Ġcheck :ĊĊ ĠĠĠ Ġans Ġ*= Ġ( i + 1 )ĊĊ ĠĠĠ Ġans Ġ%= Ġ 1 0 ** 9 + 7 ĊĊ print (ans )


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

K=10**9

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

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

    K=min(K,S)

print(K)

A ,B ,C ,X ,Y =list (map (int ,input (). split ())) ĊĊĊĊ K = 1 0 ** 9 ĊĊ for Ġi Ġin Ġrange ( 1 0 ** 5 + 1 ):ĊĊ ĠĠĠ ĠS =i * 2 *C + max ( 0 ,X -i )* A + max ( 0 ,Y -i )* B ĊĊ ĠĠĠ ĠK =min (K ,S )ĊĊ print (K )


Input:
S = int(input())

if S >= 3600:

    h=S//3600

    m=S%3600//60

    s=S%60

elif 3600 > S >= 60:

    h=0

    m=S//60

    s=S%60

else:

    h=m=0

    s=S

print(h, m, s, sep=":")

S Ġ= Ġint (input ())ĊĊ ĊĊ if ĠS Ġ>= Ġ 3 6 0 0 :ĊĊ ĠĠĠ Ġh =S // 3 6 0 0 ĊĊ ĠĠĠ Ġm =S % 3 6 0 0 // 6 0 ĊĊ ĠĠĠ Ġs =S % 6 0 ĊĊ elif Ġ 3 6 0 0 Ġ> ĠS Ġ>= Ġ 6 0 :ĊĊ ĠĠĠ Ġh = 0 ĊĊ ĠĠĠ Ġm =S // 6 0 ĊĊ ĠĠĠ Ġs =S % 6 0 ĊĊ else :ĊĊ ĠĠĠ Ġh =m = 0 ĊĊ ĠĠĠ Ġs =S ĊĊ print (h , Ġm , Ġs , Ġsep =" :")Ċ


Input:
def main():

	n, ma, mb, *L = list(map(int, open(0).read().split()))

	M = 1<<30

	dp = [[M] * 420 for _ in range(420)]

	dp[0][0] = 0

	for a, b, c in zip(*[iter(L)] * 3):

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

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

				t = dp[i][j] + c

				if dp[i + a][j + b] > t:

					dp[i + a][j + b] = t

	ans = M

	_ma, _mb = ma, mb

	while _ma < 410 > _mb:

		ans = min(ans, dp[_ma][_mb])

		_ma += ma

		_mb += mb

	print((ans if ans < M else -1))

if __name__=="__main__":

	main()

def Ġmain ():ĊĊ ĉn , Ġma , Ġmb , Ġ* L Ġ= Ġlist (map (int , Ġopen ( 0 ). read (). split ()))ĊĊ ĉM Ġ= Ġ 1 << 3 0 ĊĊ ĉdp Ġ= Ġ[[ M ] Ġ* Ġ 4 2 0 Ġfor Ġ_ Ġin Ġrange ( 4 2 0 )]ĊĊ ĉdp [ 0 ][ 0 ] Ġ= Ġ 0 ĊĊ ĉfor Ġa , Ġb , Ġc Ġin Ġzip (* [ iter (L )] Ġ* Ġ 3 ):ĊĊ ĉ ĉfor Ġi Ġin Ġrange ( 4 0 0 , Ġ- 1 , Ġ- 1 ):ĊĊ ĉĉ ĉfor Ġj Ġin Ġrange ( 4 0 0 , Ġ- 1 , Ġ- 1 ):ĊĊ ĉĉĉ ĉt Ġ= Ġdp [i ][ j ] Ġ+ Ġc ĊĊ ĉĉĉ ĉif Ġdp [i Ġ+ Ġa ][ j Ġ+ Ġb ] Ġ> Ġt :ĊĊ ĉĉĉĉ ĉdp [i Ġ+ Ġa ][ j Ġ+ Ġb ] Ġ= Ġt ĊĊ ĉans Ġ= ĠM ĊĊ ĉ _ma , Ġ_ mb Ġ= Ġma , Ġmb ĊĊ ĉwhile Ġ_ ma Ġ< Ġ 4 1 0 Ġ> Ġ_ mb :ĊĊ ĉ ĉans Ġ= Ġmin (ans , Ġdp [_ ma ][_ mb ])ĊĊ ĉ ĉ _ma Ġ+= Ġma ĊĊ ĉ ĉ _mb Ġ+= Ġmb ĊĊ ĉprint (( ans Ġif Ġans Ġ< ĠM Ġelse Ġ- 1 )) ĊĊĊĊ if Ġ__ name __ ==" __ main __ ":ĊĊ ĉmain ()


Input:
_,s=open(c:=0)

for a in sorted(map(int,s.split())):c=a-c

print(c)

_, s =open (c := 0 )ĊĊ for Ġa Ġin Ġsorted (map (int ,s .split ())) : c =a -c ĊĊ print (c )


Input:
s = input()

t = ""

while len(t) < len(s):

    target_len = len(s) - len(t)

    if s[len(t)] == 'd':

        if target_len == 5:

            t += "dream"

        elif target_len == 7:

            t += "dreamer"

        elif target_len > 7:

            if s[len(t) + 5] != 'd' and s[len(t) + 5:len(t) + 7 + 1] != "era":

                t += "dreamer"

            else:

                t += "dream"

        else:

            break

    else:

        if target_len == 5:

            t += "erase"

        elif target_len == 6:

            t += "eraser"

        elif target_len > 6:

            if s[len(t) + 5] != 'd' and s[len(t) + 5:len(t) + 6 + 2] != "era":

                t += "eraser"

            else:

                t += "erase"

        else:

            break

    if s[0:len(t)] != t:

        break

print(("YES" if s == t else "NO"))

s Ġ= Ġinput ()ĊĊ t Ġ= Ġ""ĊĊ while Ġlen (t ) Ġ< Ġlen (s ):ĊĊ ĠĠĠ Ġtarget _len Ġ= Ġlen (s ) Ġ- Ġlen (t )ĊĊĊĊ ĠĠĠ Ġif Ġs [len (t )] Ġ== Ġ' d ':ĊĊ ĠĠĠĠĠĠĠ Ġif Ġtarget _len Ġ== Ġ 5 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġ" dream "ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġtarget _len Ġ== Ġ 7 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġ" dream er "ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġtarget _len Ġ> Ġ 7 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġs [len (t ) Ġ+ Ġ 5 ] Ġ!= Ġ' d ' Ġand Ġs [len (t ) Ġ+ Ġ 5 :len (t ) Ġ+ Ġ 7 Ġ+ Ġ 1 ] Ġ!= Ġ" era ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġ" dream er "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġ" dream "ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġtarget _len Ġ== Ġ 5 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġ" erase "ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġtarget _len Ġ== Ġ 6 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġ" eras er "ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġtarget _len Ġ> Ġ 6 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġs [len (t ) Ġ+ Ġ 5 ] Ġ!= Ġ' d ' Ġand Ġs [len (t ) Ġ+ Ġ 5 :len (t ) Ġ+ Ġ 6 Ġ+ Ġ 2 ] Ġ!= Ġ" era ":ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġ" eras er "ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġ" erase "ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ ĠĠĠ Ġif Ġs [ 0 :len (t )] Ġ!= Ġt :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ print ((" YES " Ġif Ġs Ġ== Ġt Ġelse Ġ" NO "))Ċ


Input:
from statistics import mean

inputCount = int(input())

prices = [int(input()) for lp in range(inputCount)]

average = mean(prices)

print((int(average)))

from Ġstatistics Ġimport Ġmean ĊĊĊĊ input Count Ġ= Ġint (input ())ĊĊ prices Ġ= Ġ[ int (input ()) Ġfor Ġlp Ġin Ġrange (input Count )]ĊĊ average Ġ= Ġmean (pr ices )ĊĊ print (( int ( average )))ĊĊĊ


Input:
from collections import Counter,defaultdict,deque

from heapq import heappop,heappush,heapify

import sys,bisect,math,itertools,math,pprint

sys.setrecursionlimit(10**8)

mod = 10**9+7

INF = float('inf')

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

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

n = inp()

A = sorted(inpl())

B = sorted(inpl())

C = sorted(inpl())

cnt = [0] * n

res = 0

for i,b in enumerate(B):

    c = bisect.bisect_left(C,b+1)

    cnt[i] = n-c

acc = [0]

for x in cnt:

    acc += [acc[-1] + x]

su = sum(cnt)

for i,a in enumerate(A):

    c = bisect.bisect_left(B,a+1)

    res += su - acc[c]

print(res)

from Ġcollections Ġimport ĠCounter ,default dict , deque ĊĊ from Ġheapq Ġimport Ġhe app op , he app ush , heap ify ĊĊ import Ġsys ,b is ect , math ,it ertools , math , pp rint ĊĊ sys .set rec ursion limit ( 1 0 ** 8 )ĊĊ mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊ INF Ġ= Ġfloat (' inf ')ĊĊ def Ġinp (): Ġreturn Ġint (sys .stdin .readline ())ĊĊ def Ġin pl (): Ġreturn Ġlist (map (int , Ġsys .stdin .readline (). split ())) ĊĊĊĊ n Ġ= Ġinp ()ĊĊ A Ġ= Ġsorted (in pl ())ĊĊ B Ġ= Ġsorted (in pl ())ĊĊ C Ġ= Ġsorted (in pl ())ĊĊ cnt Ġ= Ġ[ 0 ] Ġ* Ġn ĊĊ res Ġ= Ġ 0 ĊĊ for Ġi ,b Ġin Ġenumerate (B ):ĊĊ ĠĠĠ Ġc Ġ= Ġbis ect .b is ect _left (C ,b + 1 )ĊĊ ĠĠĠ Ġcnt [i ] Ġ= Ġn -c ĊĊĊĊ acc Ġ= Ġ[ 0 ]ĊĊ for Ġx Ġin Ġcnt :ĊĊ ĠĠĠ Ġacc Ġ+= Ġ[ acc [- 1 ] Ġ+ Ġx ]ĊĊ su Ġ= Ġsum (cnt ) ĠĊĊ for Ġi ,a Ġin Ġenumerate (A ):ĊĊ ĠĠĠ Ġc Ġ= Ġbis ect .b is ect _left (B ,a + 1 )ĊĊ ĠĠĠ Ġres Ġ+= Ġsu Ġ- Ġacc [c ]ĊĊ print (res )


Input:
x = int(input())

print((0 if x==1 else 1))

x Ġ= Ġint (input ())ĊĊ print (( 0 Ġif Ġx == 1 Ġelse Ġ 1 ))


Input:
def binarySearch():

    n = int(input())

    S = set(map(int, input().split()))

    q = int(input())

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

    print((len(S.intersection(T))))

binarySearch()

def Ġbinary Search ():ĊĊ ĠĠĠ Ġn Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠS Ġ= Ġset (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġq Ġ= Ġint (input ())ĊĊ ĠĠĠ ĠT Ġ= Ġset (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġprint (( len (S .intersection (T ))))ĊĊ ĠĠĠĠ ĊĊĊĊ binary Search ()


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

ans=0

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

    buf=str(i)

    #print(buf[0:int(len(buf)/2)],buf[int(len(buf)/2+1):])

    str1=buf[0:int(len(buf)/2)]

    str2=buf[int(len(buf)/2+1):]

    if str1[0]==str2[1] and str1[1]==str2[0]:

        ans+=1

print(ans)

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


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

RD = list(list(map(int, input().split())) for _ in range(m))

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

    ans = 0

    for j in RD:

        ans += j.count(i)

    print(ans)

n , Ġm Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ RD Ġ= Ġlist (list (map (int , Ġinput (). split ())) Ġfor Ġ_ Ġin Ġrange (m ))ĊĊ for Ġi Ġin Ġrange ( 1 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġj Ġin ĠRD :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġj .count (i )ĊĊ ĠĠĠ Ġprint (ans )


Input:
N = int(input())

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

cnt = 0

for i in x:

  while i % 2 == 0:

    cnt += 1

    i /= 2

print(cnt)

N Ġ= Ġint (input ())ĊĊ x Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġx :ĊĊ Ġ Ġwhile Ġi Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġi Ġ/= Ġ 2 ĊĊ print (cnt )


Input:
def popcount(x):

    x = x - ((x >> 1) & 0x55555555)

    x = (x & 0x33333333) + ((x >> 2) & 0x33333333)

    x = (x + (x >> 4)) & 0x0f0f0f0f

    x = x + (x >> 8)

    x = x + (x >> 16)

    return x & 0x0000007f

cmb=[[0 for i in range(51)] for j in range(51)]

cmb[0][0]=1

for i in range(51):

    for j in range(51):

        if i!=50 and j!=50:

            cmb[i+1][j+1]+=cmb[i][j]

        if i!=50:

            cmb[i+1][j]+=cmb[i][j]

for i in range(1,51):

    for j in range(2,51):

        cmb[i][j]+=cmb[i][j-1]

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

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

must0=[i for i in range(18) if S>>i &1==0]

must1=[i for i in range(18) if T>>i &1==1]

A=[]

for val in a:

    check=True

    for j in must0:

        check=check&(val>>j &1==0)

    for j in must1:

        check=check&(val>>j &1==1)

    if check:

        A.append(val)

if not A:

    print((0))

    exit()

bit=[]

for i in range(18):

    if i not in must0 and i not in must1:

        bit.append(i)

for i in range(len(A)):

    temp=0

    for j in range(len(bit)):

        temp+=(A[i]>>bit[j] &1==1)*2**j

    A[i]=temp

ans=0

n=len(bit)

data=[0]*(2**n)

for i in range(2**n):

    t=set([])

    for a in A:

        data[a&i]+=1

        t.add(a&i)

    temp=0

    for val in t:

        temp+=cmb[data[val]][min(K,data[val])]

    ans+=temp*(-1)**popcount(i)

    for val in t:

        data[val]=0

print(ans)

def Ġpop count (x ):ĊĊ ĠĠĠ Ġx Ġ= Ġx Ġ- Ġ(( x Ġ>> Ġ 1 ) Ġ& Ġ 0 x 5 5 5 5 5 5 5 5 )ĊĊ ĠĠĠ Ġx Ġ= Ġ( x Ġ& Ġ 0 x 3 3 3 3 3 3 3 3 ) Ġ+ Ġ(( x Ġ>> Ġ 2 ) Ġ& Ġ 0 x 3 3 3 3 3 3 3 3 )ĊĊ ĠĠĠ Ġx Ġ= Ġ( x Ġ+ Ġ( x Ġ>> Ġ 4 )) Ġ& Ġ 0 x 0 f 0 f 0 f 0 f ĊĊ ĠĠĠ Ġx Ġ= Ġx Ġ+ Ġ( x Ġ>> Ġ 8 )ĊĊ ĠĠĠ Ġx Ġ= Ġx Ġ+ Ġ( x Ġ>> Ġ 1 6 )ĊĊ ĠĠĠ Ġreturn Ġx Ġ& Ġ 0 x 0 0 0 0 0 0 7 f ĊĊĊĊ cmb =[[ 0 Ġfor Ġi Ġin Ġrange ( 5 1 )] Ġfor Ġj Ġin Ġrange ( 5 1 )]ĊĊ cmb [ 0 ][ 0 ]= 1 ĊĊ for Ġi Ġin Ġrange ( 5 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 5 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi != 5 0 Ġand Ġj != 5 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcmb [i + 1 ][ j + 1 ]+= cmb [i ][ j ]ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi != 5 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcmb [i + 1 ][ j ]+= cmb [i ][ j ]ĊĊĊĊ for Ġi Ġin Ġrange ( 1 , 5 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 2 , 5 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġcmb [i ][ j ]+= cmb [i ][ j - 1 ]ĊĊĊĊ N ,K ,T ,S =list (map (int ,input (). split ()))ĊĊ a =list (map (int ,input (). split ())) ĊĊĊĊ must 0 =[ i Ġfor Ġi Ġin Ġrange ( 1 8 ) Ġif ĠS >> i Ġ& 1 == 0 ]ĊĊ must 1 =[ i Ġfor Ġi Ġin Ġrange ( 1 8 ) Ġif ĠT >> i Ġ& 1 == 1 ]ĊĊĊĊ A =[] ĊĊ for Ġval Ġin Ġa :ĊĊ ĠĠĠ Ġcheck =True ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġmust 0 :ĊĊ ĠĠĠĠĠĠĠ Ġcheck = check &( val >> j Ġ& 1 == 0 )ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġmust 1 :ĊĊ ĠĠĠĠĠĠĠ Ġcheck = check &( val >> j Ġ& 1 == 1 )ĊĊ ĠĠĠ Ġif Ġcheck :ĊĊ ĠĠĠĠĠĠĠ ĠA .append (val )ĊĊĊĊ if Ġnot ĠA :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠ Ġexit ()ĊĊĊĊ bit =[] ĊĊ for Ġi Ġin Ġrange ( 1 8 ):ĊĊ ĠĠĠ Ġif Ġi Ġnot Ġin Ġmust 0 Ġand Ġi Ġnot Ġin Ġmust 1 :ĊĊ ĠĠĠĠĠĠĠ Ġbit .append (i )ĊĊĊĊ for Ġi Ġin Ġrange (len (A )) :ĊĊ ĠĠĠ Ġtemp = 0 ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (len (bit )) :ĊĊ ĠĠĠĠĠĠĠ Ġtemp +=( A [i ] >> bit [j ] Ġ& 1 == 1 )* 2 ** j ĊĊ ĠĠĠ ĠA [i ]= temp ĊĊĊĊ ans = 0 ĊĊ n =len (bit )ĊĊ data =[ 0 ]*( 2 ** n )ĊĊ for Ġi Ġin Ġrange ( 2 ** n ):ĊĊ ĠĠĠ Ġt =set ([] )ĊĊ ĠĠĠ Ġfor Ġa Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġdata [a & i ]+= 1 ĊĊ ĠĠĠĠĠĠĠ Ġt .add (a & i )ĊĊ ĠĠĠ Ġtemp = 0 ĊĊ ĠĠĠ Ġfor Ġval Ġin Ġt :ĊĊ ĠĠĠĠĠĠĠ Ġtemp += cmb [data [val ]][ min (K ,data [val ]) ]ĊĊ ĠĠĠ Ġans += temp *(- 1 )** pop count (i )ĊĊ ĠĠĠ Ġfor Ġval Ġin Ġt :ĊĊ ĠĠĠĠĠĠĠ Ġdata [val ]= 0 ĊĊĊĊ print (ans )Ċ


Input:
import sys

from math import gcd

read = sys.stdin.read

readline = sys.stdin.readline

readlines = sys.stdin.readlines

sys.setrecursionlimit(10 ** 9)

INF = 1 << 60

def lcm(x, y):

    return x * y // gcd(x, y)

def main():

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

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

    A = [a // 2 for a in A]

    semi_lcm = 1

    for a in A:

        semi_lcm = lcm(semi_lcm, a)

        if semi_lcm > M:

            print((0))

            return

    for a in A:

        if semi_lcm // a % 2 == 0:

            print((0))

            return

    print(((M // semi_lcm + 1) // 2))

    return

if __name__ == '__main__':

    main()

import Ġsys ĊĊ from Ġmath Ġimport Ġgcd ĊĊĊĊ read Ġ= Ġsys .stdin .read ĊĊ read line Ġ= Ġsys .stdin .readline ĊĊ read lines Ġ= Ġsys .stdin .readlines ĊĊ sys .set rec ursion limit ( 1 0 Ġ** Ġ 9 )ĊĊ INF Ġ= Ġ 1 Ġ<< Ġ 6 0 ĊĊĊĊĊĊ def Ġlcm (x , Ġy ):ĊĊ ĠĠĠ Ġreturn Ġx Ġ* Ġy Ġ// Ġgcd (x , Ġy )ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠN , ĠM Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠA Ġ= Ġlist (set (map (int , Ġinput (). split (" Ġ" ))))ĊĊ ĠĠĠ ĠA Ġ= Ġ[ a Ġ// Ġ 2 Ġfor Ġa Ġin ĠA ]ĊĊ ĠĠĠ Ġsemi _l cm Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġa Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġsemi _l cm Ġ= Ġlcm (sem i _l cm , Ġa )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġsemi _l cm Ġ> ĠM :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĊĊĊĊ ĠĠĠ Ġfor Ġa Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġsemi _l cm Ġ// Ġa Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĊĊĊĊ ĠĠĠ Ġprint ((( M Ġ// Ġsemi _l cm Ġ+ Ġ 1 ) Ġ// Ġ 2 ))ĊĊ ĠĠĠ Ġreturn ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
import sys

sys.setrecursionlimit(10**6)

def dfs(v,p,d):

    for i, j in tree[v]:

        if i != p:

            depth[i] = d + j

            dfs(i,v,d+j)

N = int(input())

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

for i in range(N-1):

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

    a -= 1

    b -= 1

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

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

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

depth = [0 for i in range(N)]

depth[K-1] = 0

dfs(K-1,-1,0)

for _ in range(Q):

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

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

import Ġsys ĊĊ sys .set rec ursion limit ( 1 0 ** 6 )ĊĊ def Ġdfs (v ,p ,d ):ĊĊ ĠĠĠ Ġfor Ġi , Ġj Ġin Ġtree [v ]:ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi Ġ!= Ġp :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdepth [i ] Ġ= Ġd Ġ+ Ġj ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdfs (i ,v ,d +j )ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ ĊĊ tree Ġ= Ġ[[] Ġfor Ġ_ Ġin Ġrange (N )] ĊĊĊĊ for Ġi Ġin Ġrange (N - 1 ):ĊĊ ĠĠĠ Ġa , Ġb , Ġc Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġa Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġb Ġ-= Ġ 1 ĊĊ ĠĠĠ Ġtree [a ]. append (( b ,c ))ĊĊ ĠĠĠ Ġtree [b ]. append (( a ,c )) ĊĊĊĊ Q , ĠK Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ depth Ġ= Ġ[ 0 Ġfor Ġi Ġin Ġrange (N )]ĊĊ depth [K - 1 ] Ġ= Ġ 0 ĊĊĊĊ dfs (K - 1 ,- 1 , 0 )ĊĊĊĊ for Ġ_ Ġin Ġrange (Q ):ĊĊ ĠĠĠ Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġprint (( depth [x - 1 ] Ġ+ Ġdepth [y - 1 ]))


Input:
import math

n = int(input())

power = math.factorial(n)

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

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


Input:
#!/usr/bin/env python3

import sys

INF = float("inf")

from bisect import bisect_left

def solve(N: int, K: int, A: "List[int]", F: "List[int]"):

    A.sort()

    F.sort(reverse=True)

    h = []

    for a, f in zip(A, F):

        h.append((a*f, a, f))

    h.sort()

    maxtime = h[-1][0]

    def isOK(y):

        i = bisect_left(h, (y+1, -1, -1))

        counter = 0

        # print(h[i:])

        for p, a, f in h[i:]:

            counter += a-y//f

        return counter <= K

    def binary_search(x):

        ng = -1

        ok = len(x)

        while abs(ok - ng) > 1:

            mid = (ok + ng)//2

            # print("mid: {}, in ({}, {})".format(mid, ng, ok))

            if isOK(mid):

                ok = mid

            else:

                ng = mid

        return ng, ok

    ng, ok = binary_search(list(range(maxtime)))

    print(ok)

    # while k > 0:

    #     p1, a1, f1 = heapq.heappop(h)

    #     p2, a2, f2 = heapq.heappop(h)

    #     p1, p2 = -p1, -p2

    #     sub = min(a1 - math.ceil((p2/f1)-1), k)

    #     a1 -= sub

    #     k -= sub

    #     heapq.heappush(h, (-a1*f1, a1, f1))

    #     heapq.heappush(h, (-a2*f2, a2, f2))

    # # print(h)

    # p, a, f = heapq.heappop(h)

    # print(-p)

    return

def main():

    def iterate_tokens():

        for line in sys.stdin:

            for word in line.split():

                yield word

    tokens = iterate_tokens()

    N = int(next(tokens))  # type: int

    K = int(next(tokens))  # type: int

    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"

    F = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"

    solve(N, K, A, F)

if __name__ == '__main__':

    main()

#!/ usr /bin /env Ġpython 3 ĊĊ import Ġsys ĊĊ INF Ġ= Ġfloat (" inf ")ĊĊ from Ġbis ect Ġimport Ġbis ect _left ĊĊĊĊĊĊ def Ġsolve (N : Ġint , ĠK : Ġint , ĠA : Ġ" List [int ]", ĠF : Ġ" List [int ]") :ĊĊ ĠĠĠ ĠA .sort ()ĊĊ ĠĠĠ ĠF .sort (reverse =True )ĊĊ ĠĠĠ Ġh Ġ= Ġ[]ĊĊ ĠĠĠ Ġfor Ġa , Ġf Ġin Ġzip (A , ĠF ):ĊĊ ĠĠĠĠĠĠĠ Ġh .append (( a *f , Ġa , Ġf ))ĊĊ ĠĠĠ Ġh .sort ()ĊĊ ĠĠĠ Ġmax time Ġ= Ġh [- 1 ][ 0 ]ĊĊĊĊ ĠĠĠ Ġdef Ġis OK (y ):ĊĊ ĠĠĠĠĠĠĠ Ġi Ġ= Ġbis ect _left (h , Ġ( y + 1 , Ġ- 1 , Ġ- 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġcounter Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġ# Ġprint (h [i : ])ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġp , Ġa , Ġf Ġin Ġh [i :] :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcounter Ġ+= Ġa -y // f ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġcounter Ġ<= ĠK ĊĊĊĊ ĠĠĠ Ġdef Ġbinary _search (x ):ĊĊ ĠĠĠĠĠĠĠ Ġng Ġ= Ġ- 1 ĊĊ ĠĠĠĠĠĠĠ Ġok Ġ= Ġlen (x )ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġabs (ok Ġ- Ġng ) Ġ> Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmid Ġ= Ġ( ok Ġ+ Ġng )// 2 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġ# Ġprint (" mid : Ġ{}, Ġin Ġ({ }, Ġ{}) ". format (mid , Ġng , Ġok ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġis OK (mid ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġok Ġ= Ġmid ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġng Ġ= Ġmid ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġng , Ġok ĊĊĊĊ ĠĠĠ Ġng , Ġok Ġ= Ġbinary _search (list (range (max time )))ĊĊ ĠĠĠ Ġprint (ok )ĊĊĊĊ ĠĠĠ Ġ# Ġwhile Ġk Ġ> Ġ 0 :ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġp 1 , Ġa 1 , Ġf 1 Ġ= Ġheapq .he app op (h )ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġp 2 , Ġa 2 , Ġf 2 Ġ= Ġheapq .he app op (h )ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġp 1 , Ġp 2 Ġ= Ġ- p 1 , Ġ- p 2 ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġsub Ġ= Ġmin (a 1 Ġ- Ġmath .ceil (( p 2 /f 1 )- 1 ), Ġk )ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġa 1 Ġ-= Ġsub ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġk Ġ-= Ġsub ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġheapq .he app ush (h , Ġ(- a 1 *f 1 , Ġa 1 , Ġf 1 ))ĊĊ ĠĠĠ Ġ# ĠĠĠĠ Ġheapq .he app ush (h , Ġ(- a 2 *f 2 , Ġa 2 , Ġf 2 ))ĊĊ ĠĠĠ Ġ# Ġ# Ġprint (h )ĊĊ ĠĠĠ Ġ# Ġp , Ġa , Ġf Ġ= Ġheapq .he app op (h )ĊĊ ĠĠĠ Ġ# Ġprint (- p )ĊĊĊĊ ĠĠĠ Ġreturn ĊĊĊĊĊĊ def Ġmain (): ĊĊĊĊ ĠĠĠ Ġdef Ġiterate _tokens ():ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġline Ġin Ġsys .stdin :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġword Ġin Ġline .split ():ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġyield Ġword ĊĊ ĠĠĠ Ġtokens Ġ= Ġiterate _tokens ()ĊĊ ĠĠĠ ĠN Ġ= Ġint (next (tokens )) Ġ Ġ# Ġtype : Ġint ĊĊ ĠĠĠ ĠK Ġ= Ġint (next (tokens )) Ġ Ġ# Ġtype : Ġint ĊĊ ĠĠĠ ĠA Ġ= Ġ[ int (next (tokens )) Ġfor Ġ_ Ġin Ġrange (N )] Ġ Ġ# Ġtype : Ġ" List [int ] "ĊĊ ĠĠĠ ĠF Ġ= Ġ[ int (next (tokens )) Ġfor Ġ_ Ġin Ġrange (N )] Ġ Ġ# Ġtype : Ġ" List [int ] "ĊĊ ĠĠĠ Ġsolve (N , ĠK , ĠA , ĠF )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


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:
import heapq

N = int(input())

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

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

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

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

INFTY = 10**15

for a,b,c in abc:

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

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

cost = [[INFTY,False] for _  in range(N)]

cost[K-1][0] = 0

q = [(0,K-1)]

while q:

    _,i = heapq.heappop(q)

    if cost[i][1]:

        continue

    cost[i][1] = True

    ci0 = cost[i][0]

    for j,c in connect[i]:

        if cost[j][1]:

            continue

        tmp_cost = ci0+c

        if tmp_cost < cost[j][0]:

            cost[j][0] = tmp_cost

            heapq.heappush(q,(tmp_cost,j))

for x,y in xy:

    print((cost[x-1][0] + cost[y-1][0]))

import Ġheapq ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ abc Ġ= Ġ[ list (map (int ,input (). split ())) Ġfor Ġ_ Ġin Ġrange (N - 1 )]ĊĊ Q ,K Ġ= Ġlist (map (int ,input (). split ()))ĊĊ xy Ġ= Ġ[ list (map (int ,input (). split ())) Ġfor Ġ_ Ġin Ġrange (Q )] ĊĊĊĊ connect Ġ= Ġ[[] Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ IN FT Y Ġ= Ġ 1 0 ** 1 5 ĊĊ for Ġa ,b ,c Ġin Ġabc :ĊĊ ĠĠĠ Ġconnect [a - 1 ]. append ([ b - 1 ,c ])ĊĊ ĠĠĠ Ġconnect [b - 1 ]. append ([ a - 1 ,c ])ĊĊ ĊĊ cost Ġ= Ġ[[ IN FT Y ,False ] Ġfor Ġ_ Ġ Ġin Ġrange (N )]ĊĊ cost [K - 1 ][ 0 ] Ġ= Ġ 0 ĊĊ q Ġ= Ġ[( 0 ,K - 1 )]ĊĊ while Ġq :ĊĊ ĠĠĠ Ġ_, i Ġ= Ġheapq .he app op (q )ĊĊ ĠĠĠ Ġif Ġcost [i ][ 1 ]:ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġcost [i ][ 1 ] Ġ= ĠTrue ĊĊ ĠĠĠ Ġci 0 Ġ= Ġcost [i ][ 0 ]ĊĊ ĠĠĠ Ġfor Ġj ,c Ġin Ġconnect [i ]:ĊĊ ĠĠĠĠĠĠĠ Ġif Ġcost [j ][ 1 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠ Ġtmp _cost Ġ= Ġci 0 +c ĊĊ ĠĠĠĠĠĠĠ Ġif Ġtmp _cost Ġ< Ġcost [j ][ 0 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcost [j ][ 0 ] Ġ= Ġtmp _cost ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (q ,( tmp _cost ,j )) ĊĊĊĊ for Ġx ,y Ġin Ġxy :ĊĊ ĠĠĠ Ġprint (( cost [x - 1 ][ 0 ] Ġ+ Ġcost [y - 1 ][ 0 ]))


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

def kaibun(n):

	key = 0

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

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

			key += 1

	return key

print((kaibun(B)-kaibun(A-1)))

A ,B Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊĊĊ def Ġka ib un (n ):ĊĊ ĉkey Ġ= Ġ 0 ĊĊ ĉfor Ġi Ġin Ġrange ( 1 ,n + 1 ):ĊĊ ĉ ĉif Ġstr (i ) Ġ== Ġstr (i )[ ::- 1 ]:ĊĊ ĉĉ ĉkey Ġ+= Ġ 1 ĊĊ ĉreturn Ġkey ĊĊĊĊ print (( ka ib un (B )- ka ib un (A - 1 )))


Input:
from sys import stdin

def solve():

    s = int(stdin.readline())

    mod = 10**9+7

    if s < 3: return 0

    dp = [0]*(s+1)

    dp[0] = 1

    for i in range(3,s+1):

        for x in range(3,i+1):

            if x in [i-1,i-2]:

                continue

            dp[i] += dp[i-x]

    return dp[s]%mod

print((solve()))

from Ġsys Ġimport Ġstdin ĊĊ def Ġsolve ():ĊĊ ĠĠĠ Ġs Ġ= Ġint (stdin .readline ())ĊĊ ĠĠĠ Ġmod Ġ= Ġ 1 0 ** 9 + 7 ĊĊ ĠĠĠ Ġif Ġs Ġ< Ġ 3 : Ġreturn Ġ 0 ĊĊ ĠĠĠ Ġdp Ġ= Ġ[ 0 ]*( s + 1 )ĊĊ ĠĠĠ Ġdp [ 0 ] Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange ( 3 ,s + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx Ġin Ġrange ( 3 ,i + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġx Ġin Ġ[ i - 1 ,i - 2 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdp [i ] Ġ+= Ġdp [i -x ]ĊĊ ĠĠĠ Ġreturn Ġdp [s ]% mod ĊĊ print (( solve ()))


Input:
N = int(input())

s_list = {}

for i in range(N):

  S = input()

  if S in list(s_list.keys()):

    s_list[S] += 1

  else:

    s_list[S] = 0

max = 0

maxs = []

for s,c in list(s_list.items()):

  if c > max:

    maxs = [s]

    max = c

  elif c == max:

    maxs.append(s)

maxs.sort()

for m in maxs:

  print(m)

N Ġ= Ġint (input ())ĊĊ s _list Ġ= Ġ{}ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ Ġ ĠS Ġ= Ġinput ()ĊĊ Ġ Ġif ĠS Ġin Ġlist (s _list .keys ()) :ĊĊ ĠĠĠ Ġs _list [S ] Ġ+= Ġ 1 ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ Ġs _list [S ] Ġ= Ġ 0 ĊĊ max Ġ= Ġ 0 ĊĊ max s Ġ= Ġ[]ĊĊ for Ġs ,c Ġin Ġlist (s _list .items ()) :ĊĊ Ġ Ġif Ġc Ġ> Ġmax :ĊĊ ĠĠĠ Ġmax s Ġ= Ġ[ s ]ĊĊ ĠĠĠ Ġmax Ġ= Ġc ĊĊ Ġ Ġelif Ġc Ġ== Ġmax :ĊĊ ĠĠĠ Ġmax s .append (s )ĊĊ max s .sort ()ĊĊ for Ġm Ġin Ġmax s :ĊĊ Ġ Ġprint (m )


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:
S = input()

N = len(S)

left = S[:int(N/2)]

right = S[int((N+2)/2):]

S_reversed = "".join(reversed(list(S)))

left_reversed = "".join(reversed(list(left)))

right_reversed = "".join(reversed(list(right)))

if S == S_reversed and left == left_reversed and right == right_reversed:

    print("Yes")

else:

    print("No")

S Ġ= Ġinput ()ĊĊ N Ġ= Ġlen (S )ĊĊ left Ġ= ĠS [: int (N / 2 )]ĊĊ right Ġ= ĠS [int (( N + 2 )/ 2 ): ]ĊĊ S _re versed Ġ= Ġ"". join (re versed (list (S )))ĊĊ left _re versed Ġ= Ġ"". join (re versed (list (left )))ĊĊ right _re versed Ġ= Ġ"". join (re versed (list (right )) )ĊĊĊĊ if ĠS Ġ== ĠS _re versed Ġand Ġleft Ġ== Ġleft _re versed Ġand Ġright Ġ== Ġright _re versed :ĊĊ ĠĠĠ Ġprint (" Yes ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" No ")


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

ans=0

for i in range(b+1)[a:]:

  if len(str(i))%2==0:

    p=list(str(i))[:len(str(i))//2]

    q=list(reversed(list(str(i))[len(str(i))//2:]))

    if p==q:

      ans+=1

  else:

    s=list(str(i))[:len(str(i))//2+1]

    d=list(reversed(list(str(i))[len(str(i))//2:]))

    if s==d:

      ans += 1

print(ans)

a ,b =list (map (int ,input (). split ()))ĊĊ ans = 0 ĊĊ for Ġi Ġin Ġrange (b + 1 )[ a :] :ĊĊ Ġ Ġif Ġlen (str (i )) % 2 == 0 :ĊĊ ĠĠĠ Ġp =list (str (i )) [: len (str (i )) // 2 ]ĊĊ ĠĠĠ Ġq =list (re versed (list (str (i ))[ len (str (i )) // 2 :] ))ĊĊ ĠĠĠ Ġif Ġp == q :ĊĊ ĠĠĠĠĠ Ġans += 1 ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ Ġs =list (str (i )) [: len (str (i )) // 2 + 1 ]ĊĊ ĠĠĠ Ġd =list (re versed (list (str (i ))[ len (str (i )) // 2 :] ))ĊĊ ĠĠĠ Ġif Ġs == d :ĊĊ ĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ print (ans )


Input:
import sys

import itertools

# import numpy as np

import time

import math

sys.setrecursionlimit(10 ** 7)

from collections import defaultdict

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines

from functools import reduce

# from math import *

from math import *

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

A = list(sorted([int(x) // 2 for x in readline().split()]))

min_cm = reduce(lambda a, b: (a * b) // gcd(a, b), A)

# print(all(map(lambda x: (min_cm // x) % 2 == 1, A)))

if not all([(min_cm // x) % 2 == 1 for x in A]):

    print((0))

    exit(0)

if min_cm > M:

    print((0))

    exit(0)

ans = (M // min_cm + 1) // 2

print(ans)

import Ġsys ĊĊ import Ġitertools ĊĊ # Ġimport Ġnumpy Ġas Ġnp ĊĊ import Ġtime ĊĊ import Ġmath ĊĊ ĠĊĊ sys .set rec ursion limit ( 1 0 Ġ** Ġ 7 )ĊĊ ĠĊĊ from Ġcollections Ġimport Ġdefaultdict ĊĊ ĠĊĊ read Ġ= Ġsys .stdin .buffer .read ĊĊ read line Ġ= Ġsys .stdin .buffer .readline ĊĊ read lines Ġ= Ġsys .stdin .buffer .readlines ĊĊ ĠĊĊ ĠĊĊ from Ġfunctools Ġimport Ġreduce ĊĊ # Ġfrom Ġmath Ġimport Ġ*ĊĊ from Ġmath Ġimport Ġ*ĊĊ N , ĠM Ġ= Ġlist (map (int , Ġreadline (). split ()))ĊĊ A Ġ= Ġlist (sorted ([ int (x ) Ġ// Ġ 2 Ġfor Ġx Ġin Ġreadline (). split ()] ))ĊĊ min _cm Ġ= Ġreduce (lambda Ġa , Ġb : Ġ( a Ġ* Ġb ) Ġ// Ġgcd (a , Ġb ), ĠA )ĊĊ ĠĊĊ # Ġprint (all (map (lambda Ġx : Ġ( min _cm Ġ// Ġx ) Ġ% Ġ 2 Ġ== Ġ 1 , ĠA )))ĊĊ if Ġnot Ġall ([( min _cm Ġ// Ġx ) Ġ% Ġ 2 Ġ== Ġ 1 Ġfor Ġx Ġin ĠA ]) :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠ Ġexit ( 0 )ĊĊ if Ġmin _cm Ġ> ĠM :ĊĊ ĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠ Ġexit ( 0 )ĊĊ ans Ġ= Ġ( M Ġ// Ġmin _cm Ġ+ Ġ 1 ) Ġ// Ġ 2 ĊĊ print (ans )


Input:
while int(input()) > 0:

    s = sorted(map(int, input().split()))

    print((min(abs(a - b) for (a, b) in zip(s, s[1:]))))

while Ġint (input ()) Ġ> Ġ 0 :ĊĊ ĠĠĠ Ġs Ġ= Ġsorted (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġprint (( min (abs (a Ġ- Ġb ) Ġfor Ġ( a , Ġb ) Ġin Ġzip (s , Ġs [ 1 : ])) ))